Multiple versions of live dependency

[Namedix]

I would like to achieve various multiple implementations of the same client, let's say ApiClient

struct ApiClient {
    var request: () -> Data

    func request(...) { ... }
}

Currently we can add live, test and preview implementations, but what I would like to achieve is diffent live versions of a given client? Ie. for ApiClient, I would like to have one Authorised and another NonAuthorised version with different implementations.

With environment approach I would just create 2 static live implementations of this ApiClient struct like

extension ApiClient {
    static var authorised: Self { ... }
    static var nonAuthorised: Self { ... }
}

but with swift-dependencies only option for this is

extension DependencyValues {
    var apiClient: ApiClient {
        get { self[ApiClient.self] }
        set { self[ApiClient.self] = newValue }
    }
}

Is there any way to solve this? or do I need to change implementation of ApiClient to fit my needs instead of different implementation of this protocol interface struct.

struct ApiClient {
    var request: () -> Data
    var authorisedRequest: () -> Data

    func request(...) { ... }
    func authorisedRequest(...) { ... }
}

---

I know that I can create authorised and nonAuthorised implementation in extension and then use

withDependencies {
    $0.apiClient = .authorised
} operation {
    Model()
}

while creating model to change apiClient, but I would like to have it more static not relying on initialisation, but rather on typing @Dependency(\.authorisedApiClient) var authorisedApiClient and in other places @Dependency(\.nonAuthorisedApiClient) var nonAuthorisedApiClient

[mbrandonw]

It sounds like you want multiple versions of APIClient available in your application at once? If so, then you are free to add as many computed properties to DependencyValues as you want. You just need to create a separate type to act as a key:

private enum AuthorizedAPIClientKey: DependencyKey { /* ... */ }
extension DependencyValues {
  var authorizedApiClient: ApiClient {
    get { self[AuthorizedAPIClientKey.self] }
    set { self[AuthorizedAPIClientKey.self] = newValue }
  }
}

private enum NonAuthorizedAPIClientKey: DependencyKey { /* ... */ }
extension DependencyValues {
  var nonAuthorizedApiClient: ApiClient {
    get { self[NonAuthorizedAPIClientKey.self] }
    set { self[NonAuthorizedAPIClientKey.self] = newValue }
  }
}

[mbrandonw]

@Muhammed9991 Perhaps I don't understand your example. Can you expand a bit more?

[Muhammed9991]

For context, I have some dependencies currently written using Factory. I'm trying to move them to use @Dependency instead.

In Factory, I'll do something like this:

var apiClientOne: Factory<FirstProtocol> { self { SomeClass() } }
var apiClientTwo: Factory<SecondProtocol> { self { SomeClass() } }

I'm not sure what the equivalent in swift-dependencies will be. Because the dependencies are essentially the same underlying class but different protocol conformance. So I can't do something like this:

extension SomeClass: DependencyKey {
    static let liveValue1: FirstProtocol = SomeClass()
    static let liveValue2: SecondProtocol = SomeClass()
}

extension DependencyValues {
    var apiClientOne: FirstProtocol {
        get { self[SomeClass.self] }
        set { self[SomeClass.self] = newValue }
    }
}

extension DependencyValues {
    var apiClientTwo: SecondProtocol {
        get { self[SomeClass.self] }
        set { self[SomeClass.self] = newValue }
    }
}

Just a side note. This protocol oriented approach reminds of Protocol witness series by PointFree 😄.

[stephencelis]

@Muhammed9991 Conforming the dependency itself to DependencyKey is a convenience but not necessary. You can define unique types to the protocol and still delegate to the same class as a dependency:

enum APIClientOneKey: DependencyKey {
  static let liveValue: FirstProtocol = SomeClass()
}
enum APIClientTwoKey: DependencyKey {
  static let liveValue: SecondProtocol = SomeClass()
}

extension DependencyValues {
  var apiClientOne: FirstProtocol {
    get { self[APIClientOneKey.self] }
    set { self[APIClientOneKey.self] = newValue }
  }
}

extension DependencyValues {
  var apiClientTwo: SecondProtocol {
    get { self[APIClientTwoKey.self] }
    set { self[APIClientTwoKey.self] = newValue }
  }
}

[mbrandonw]

Hi @Muhammed9991, I believe your situation does fit into what I was trying to explain above. You have a single object that conforms to two protocols, and you want to expose that as two separate dependencies, one for each protocol:

class SomeClass: FirstProtocol, SecondProtocol { /* ... */ }

private enum FirstDependencyKey: DependencyKey {
  static let liveValue: any FirstProtocol = SomeClass()
}
extension DependencyValues {
 var apiClientOne: FirstProtocol {
    get { self[FirstDependencyKey.self] }
    set { self[FirstDependencyKey.self] = newValue }
  }
}

private enum SecondDependencyKey: DependencyKey {
  static let liveValue: any SecondProtocol = SomeClass()
}
extension DependencyValues {
 var apiClientTwo: SecondProtocol {
    get { self[SecondDependencyKey.self] }
    set { self[SecondDependencyKey.self] = newValue }
  }
}

Note that it is not necessary to conform your dependency object to DependencyKey directly. That's just a shortcut that can be handy for most situations. Any type can conform to the DependencyKey protocol, and often it can just be a little private, empty enum to expose the live value. This is exactly how SwiftUI's environment works.

[Muhammed9991]

Ahh that makes sense. I think I was over complicating it.