Response models from external services used in Application layer?

[thommelutten]

I am accessing an external application to synchronize some data between my applications, and am wondering how I should go about with the implementation.

As far as I understand, all use of external services should reside in the Infrastructure layer, with an interface created in Applications. But if I want to have a command that calls my external service to synchronize cases between applications, then the mapping from the response model to a model in my domain would violate the separation between Application / Infrastructure. How can I get around that?

In my Application layer:

public class CreateCasesCommandHandler : IRequest<CreateCasesCommand, int> {
    private readonly IMyExternalService _myExternalService;
    private readonly IMapper mapper;
    
    public CreateCasesCommandHandler(IMyExternalService myExternalService, IMapper mapper) {
        _myExternalService = myExternalService;
        _mapper = mapper;
    }

    public async Task<int> Handle(CreateCasesCommand, CancellationToken cancellationToken) {
        var externalCases = _myExternalService.FetchCases();
        var domainCases = _mapper.Map<Domain.Case>(externalCases)
        ...
    }
}

If I want to map from the externalCase model to my own domain, it requires a IMapFrom<ExternalCase>, where the Application layer starts knowing about the Infrastructure layer. Which is a violation. Alternatively I should create a new domain model object in the service and pass that back like so:

MyExternalService

public class MyExternalService : IMyExternalService {
    ...
    public async Task<IList<ExternalDomain.Case>> FetchCases() {
        var externalCases = _client.FetchCases();
        IList<Domain.Case> domainCases = new List<Domain.Case>();
        foreach(var externalCase in externalCases) {
            domainCases.Add(new Domain.Case() {
                ...
            });
        }
        return domainCases;
    }
}

But this also seems a bit tedious, and I would like to use the functionality of AutoMapper.

I've tried to look around a bit, and the closest response I could find was #344, but there isn't really a lot to go from in that explanation in regards to the mapping between models.