[Question] Where to put Resolver in Presentation - Domain - Data architecture

[kientux]

I'm currently implement layer architecture for my app, which will separate it into 3 layers:

• Presentation (UI, navigation..)
• Domain: business layer with entities, use cases, repository interfaces
• Data: repository implementations, API services,..

The Data and Presentation depend on Domain.

I have an use case like this:

protocol ProductRepo {
    func getProductList(page: Int, limit: Int, query: String?,
                        completion: @escaping (Result<Paginated<Product>, DomainError>) -> Void)
}

struct GetProductListUseCase: UseCase {
    let repo: ProductRepo

    struct Params {
        var page: Int
        var limit: Int
        var searchQuery: String?
    }

    func execute(_ request: Params, completion: @escaping (Result<Paginated<Product>, DomainError>) -> Void) {
        repo.getProductList(page: request.page, limit: request.limit, query: request.searchQuery, completion: completion)
    }
}

and I want to inject ProductRepo (with something like ProductRepoImpl in the Data layer).

• If I use property injection: @Injected var repo: ProductRepo, then Domain layer will depends on Resolver, and also other layers will depend on Resolver too (they need to register dependencies). Is that bad?
• If I use constructor injection, Domain layer will be completely independent and knows nothing about injection. But then the amount of resolver registration codes will be too much, because there are a lot of use cases, like hundreds.

So anyone has recommendations to use Resolver for this architecture? Thank you.

[hmlongco]

As I wrote in Modern Dependency Injection in Swift, one can create an injection property wrapper for any DI system, so you're not going to be specifically tied to Resolver, though you'll probably have to rewrite your registrations if you were to switch.

Personally, I've tended towards using @Injected in our code where I work, as the app was specifically designed to rely on a dependency injection system and because I really dislike the boilerplate code associated with initializers.

class Test {

    var cache: UserImageCache
    var userService: UserServiceType
    var model: MainViewModel

    internal init(cache: UserImageCache, userService: UserServiceType, model: MainViewModel) {
        self.cache = cache
        self.userService = userService
        self.model = model
    }

}

As opposed to:

class Test {

     @Injected var cache: UserImageCache
     @Injected var userService: UserServiceType
     @Injected var model: MainViewModel

}

And, as mentioned, it makes registration much easier.

register { Test() }
// as opposed to
register { Test(cache: resolve(), userService: resolve(), model: resolve())}