Use Case

A use case is a class designed to handle a single, specific task that represents a distinct need of the application. It takes input, processes it, and optionally returns a result.

For example, an address creation use case would solely handle the creation of an address. By limiting the scope to this one task, the coupling between different features is minimized, making the system easier to maintain and extend.

This approach ensures that each use case is responsible for only one action, resulting in a cleaner and more modular codebase.

Typically, a single use case is associated with a single API route and interacts with the following components:

• Command
• Response
• Repository
• Service

Below is an example of how an address creation use case might look like.

@Injectable()
export class CreateAddressUseCase {
  constructor (
    private readonly addressRepository: Repository<Address>
  ) { }

  async createAddress(command: CreateAddressCommand): Promise<Response> {
    await this.validate(command);
    const address = this.mapCommandToAddress(command);
    await this.persist(address);
    return new CreatedAddressResponse(address);
  }

  private async validate(command: CreateAddressCommand): Promise<void> {
    // validate input
  }

  private async mapCommandToAddress(command: CreateAddressCommand): Address {
    // map input to domain model
  }

  private async persist(address): Promise<void> {
    // store address in database
  }
}