Repositories

Repositories are a fundamental component of an application's architecture, responsible for handling data persistence and retrieval. This document outlines how we create and use repositories in our backend development process at Wisemen.

See the TypeORM Chapter for more information on TypeORM.

Creating and Using Repositories

WARNING

You need to use @wisemen/nestjs-typeorm instead of @nest/typeorm.

Default repositories must be injected with InjectRepository.

Custom repositories must extend from TypeOrmRepository.

See transactions

There are two primary approaches to working with repositories:

1. Repositories in a Use-Case: Ideal for simple use-cases with minimal repository logic.
2. Custom Repository Classes: Suitable when repository logic becomes more complex or spans multiple methods.

Repositories in a Use-Case

Repositories are injected directly within a use-case, like so:

import { InjectRepository } from '@wisemen/nestjs-typeorm'

export class GetUserByEmailOrUsernameUseCase {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>
  ) {}

  public async execute(input: string): Promise<User> {
    const user = await this.findUserByEmailOrUsername(input)
    return new UserResponse(user)
  }

  private async findUserByEmailOrUsername(input: string): Promise<User> {
    return await this.findOneOrFail({
      where: [
        { email: input },
        { username: input }
      ],
    })
  }
}

Note that we are importing the InjectRepository decorator from `@wisemen/nestjs-type.

Key Steps:

1. Initialize the repository in the constructor using the @InjectRepository to ensure transaction support.
2. Encapsulate repository logic in clearly named private methods in the use case class for readability and maintainability.

💡 Why Inject Repositories?

• Simple logic that doesn't clutter the use-case.
• Ideal when only a few lines of repository-related code are required.

For anything more complex, use a custom repository class.

Custom Repository Classes

Custom repository classes encapsulate complex repository logic, separating it from the use-case logic.

@Injectable()
export class UserRepository extends TypeOrmRepository<User> {
  constructor (entityManager: EntityManager) {
    super(User, entityManager)
  }

  public async findByEmailOrUsername(input: string): Promise<User> {
    // Repository logic
  }
}

Key Points:

• Mark the repository class as @Injectable().
• Register it as a provider in your module for dependency injection.

Example Use-Case with a Repository Class:

export class GetUserByEmailOrUsernameUseCase {
  constructor(
    private readonly userRepository: UserRepository
  ) {}

  public async execute(input: string): Promise<User> {
    const user = await this.userRepository.findByEmailOrUsername(input)

    return new UserResponse(user)
  }
}

When to Use a Repository Class:

• If a single repository method takes up significant lines of code (e.g., 50+ lines).
• If multiple repository methods collectively take up a considerable portion of the use-case.

Writing Repository Methods

Here's an example of a repository method:

export class UserRepository extends TypeOrmRepository<User> {
  constructor(entityManager: EntityManager) {
    super(User, entityManager)
  }

  public async findByEmailOrUsername(input: string): Promise<User> {
    return await this.findOneOrFail({
      where: [
        { email: input },
        { username: input }
      ],
    })
  }
}

Method Breakdown:

1. Use await for asynchronous operations.
2. Use findOneOrFail to retrieve a single record or throw an error if none is found.

• Alternatively, findOne can return null if no record matches.

3. Use the where clause to specify query conditions. Arrays in where create OR conditions.

Other Available Methods: Explore methods like findBy, insert, save, and remove. Learn more in the TypeORM Documentation.