DDD: Can application services throw domain errors?

Question

I'm new to DDD and I trying to create an API using DDD concepts for study purposes. Today, I faced a scenario where I've to create an Application Service to expose a functionality to be cosumed from the external world. The scenario that I came across is to consult in the repository some Domain Entity informations by its id and if the Entity does not exists it should throw a Domain Error to the client, informing that the Entity does not exists. Therefore, my questions are:

• Should I throw Domain Errors in Application Services?
• Should this scenario be converted to a Domain Service that is called by the Application service, where the Domain Service treats the repository's response and throws the Error? If yes, how can I nominate this service?

My code looks like this:

import { CostumerRepository } from '@/main/com/acme/sales/domain/repositories';
import { CostumerNotFound } from '@/main/com/acme/sales/domain/errors';
import { GetCostumerHistoryInputDTO } from './dtos/inputs';
import { CostumerHistoryOutputDTO } from './dtos/output';

export class GetCostumerHistory {
  constructor(private readonly costumerRepository: CostumerRepository) {}

  execute(input: GetCostumerHistoryInputDTO): CostumerHistoryOutputDTO {
    const costumer = this.costumerRepository.getById(input.costumerId);

    if (costumer == null) throw new CostumerNotFound();

    return new CostumerHistoryOutputDTO({ costumer });
  }
}

Answer 1

Should this scenario be converted to a Domain Service that is called by the Application service, where the Domain Service treats the repository's response and throws the Error?

Yes, this is probably the better path to take.

In Domain-Driven Design, the responsibility of throwing Domain Errors should be delegated to the Domain layer; This knowledge comes from the Domain after all. So it would be better to implement the logic of checking if the Entity exists in a Domain Service and throw the Domain Error from there.

If yes, how can I nominate this service?

Here's an example of how you could refactor your code to delegate the error handling to a Domain Service:

import { CustomerRepository } from '@/main/com/acme/sales/domain/repositories';
import { CustomerNotFound } from '@/main/com/acme/sales/domain/errors';
import { GetCustomerService } from '@/main/com/acme/sales/domain/services';
import { GetCustomerHistoryInputDTO } from './dtos/inputs';
import { CustomerHistoryOutputDTO } from './dtos/output';

export class GetCustomerHistory {
  constructor(
    private readonly customerRepository: CustomerRepository,
    private readonly getCustomerService: GetCustomerService,
  ) {}

  execute(input: GetCustomerHistoryInputDTO): CustomerHistoryOutputDTO {
    const customer = this.getCustomerService.getById(input.customerId);
    return new CustomerHistoryOutputDTO({ customer });
  }
}

import { CustomerRepository } from '@/main/com/acme/sales/domain/repositories';
import { CustomerNotFound } from '@/main/com/acme/sales/domain/errors';

export class GetCustomerService {
  constructor(private readonly customerRepository: CustomerRepository) {}

  getById(id: string): Customer {
    const customer = this.customerRepository.getById(id);
    if (customer == null) throw new CustomerNotFound();
    return customer;
  }
}

The GetCustomerHistory class is an Application Service that provides the external API for retrieving a customer's history. It relies on the GetCustomerService class, which is a Domain Service responsible for retrieving a customer by their id and throwing the CustomerNotFound error if the customer does not exist.

Hope this helps!