领域驱动设计 (DDD) - 领域服务可以进行远程过程调用吗？

Question

I am working on a DDD project and I have a UseCase(ApplicationService) that needs to deploy a project to Kube.netes. So, I have DeployProjectUseCase with inputs (projectId, databaseType) and it first needs to check the database type that the application uses in order to create the specific pods, secrets etc. It will invoke the external service of Kube.netes, but according with the type it has to use some specific methods from it. I thought that this logic shouldn't be in the useCase and be polluted, but instead use a DomainService that will dependency inject the external service. I don't know if Domain Services can have remote procedure calls, but I found this from Vaughn Vernon's book:

There are times when a Domain Service is concerned with remote invocations on
a foreign Bounded Context (2). Yet, the focus here is different in that the Domain
Service is not itself providing a remote procedure call interface but is rather the
client of the RPC.

So, I thought an implementation like this:

I have a Factory that returns the appropriate Domain Service according to the database type. The DeployProjectUseCase calls this and delegates the job to the domain service. I have created a NetworkServicePort and an adapter that uses Kube.netes library for Nodejs, in order to be injected in the useCase and then to the Domain Service:

NetworkServicePort

export interface NetworkServicePort {
  createSecret(namespace: string, body: TCreateSecretBody): Promise<void>;
  createStatefulSet(namespace: string, body: TCreateStatefulSetBody): Promise<void>;
  createConfigMap(...): Promise<void>;
  createPersistentVolume(...): Promise<void>;
  ...
}

DeployProjectUseCase

export class DeployProjectUseCase {
 constructor(
    private projectRepo: ProjectWriteRepoPort,
    private networkService: NetworkServicePort,
  ) {}
  
  async execute(requestDTO: DeployProjectRequestDTO): Promise<DeployProjectUseCaseResponse> {
    const projectFound = await this.projectRepo.getById(projectId);
    if (!projectFound) {
      return fail(...);
    }

    const domainNetworkService = DomainNetworkServiceFactory.createDomainNetworkService(requestDTO.databaseType, this.networkService);
    await domainNetworkService.deploy(projectFound);
    
    ...

    await this.projectRepo.update(projectFound);

    return ok();
  }
}

DomainNetworkServiceFactory

export interface DomainNetworkService {
  deploy(project: ProjectEntity): Promise<void>;
}

export class DomainNetworkServiceFactory {
  static createDomainNetworkService(
    type: string,
    networkService: NetworkServicePort,
  ): DomainNetworkService {
    switch (type) {
      case 'mongo': {
        return new MongoNetworkService(networkService);
      }
      case 'postgreSQL': {
        return new PostgreSQLNetworkService(networkService);
      }
      default: {
        ...
      }
    }
  }
}

MongoNetworkService

export class MongoNetworkService implements DomainNetworkService {
  constructor(private networkService: NetworkServicePort) {}

  public async deploy(project: ProjectEntity): Promise<void> {
    // here have a mapper from Project aggregate to the DTO that service accepts
    await this.networkService.createNamespace(...);
    generatePassword(); // generate username and password from a library
    await this.networkService.createSecret(...);
    ...
    await this.networkService.createStatefulSet(...);
    ...
    const infraNetworkService = InfraNetworkServiceEntity.create({
      type: INFRA_NETWORK_SERVICE_TYPES.MONGO,
    });
    project.addInfraNetworkService(infraNetworkService);
  }
}

PostgreSQLNetworkService

export class PostgreSQLNetworkService implements DomainNetworkService {
  constructor(private networkService: NetworkServicePort) {}

  public async deploy(project: ProjectEntity): Promise<void> {
    // here have a mapper from Project aggregate to the DTO that service accepts
    await this.networkService.createNamespace(...);
    await this.networkService.createConfigMap(...);
    await this.networkService.createPersistentVolume(...);
    ...
    const infraNetworkService = InfraNetworkServiceEntity.create({
      type: INFRA_NETWORK_SERVICE_TYPES.POSTGRESQL,
    });
    project.addInfraNetworkService(infraNetworkService);
  }
}

It seems to me that the above has a domain logic that could be inside a Domain Service, but can a Domain Service have a remote procedure call? Otherwise, this logic could be inside the Application Service, but it seems wrong to me and it would be polluted. Does something like this make sense? How would you implement it with DDD? Any ideas would be really helpful.

Thank you in advance!

Answer 1

From my point of view MongoNetworkService, PostgreSQLNetworkService are neither domain nor application services. They are more like infrastructure services. That is why the design is fine. The only problem I can see here is the line

project.addInfraNetworkService(infraNetworkService)

I couldn't clearly understand if "project" in this line is your domain object if so this call shouldn't be leaked to infrastructure service should be handled on layer above.