How to define dependencies that have other dependencies?

[iwt-sebastian-boldt]

Hey 👋
I am currently considering how exactly dependencies can have other dependencies.

If you look at the code examples from the documentation you can only get an impression of how a single layer of dependencies can be implemented.

If you take a look at the Isowords example project you can see another approach that could give you an idea of
how exactly sub-dependencies could be handled. You simply define the dependency inside the closure you create your implementation in and use them within the implementations, like so:

extension APIWrapper {
 public static var live: Self {
  let networkingService = NetworkingService() // Defining sub
  return Self(
    getObjects: {
        let target = Target.someTarget
        let data = try await networkingService.requestTarget(target: target)
        let objects = ..... // convert data to Objects
        return objects
    }
  )
 }
}

However, this approach has the disadvantage that the actual implementations
are difficult to test because they depend on external factors.
That's why I came up with the idea of making the dependencies externally definable by converting the
var live: Self to a static func which receives the sub-dependencies.
To simplify it further, I pass the live implementation directly as the default value.

extension APIWrapper {
    public static func live(networkingService: NetworkingService = .live) -> Self {
        return Self(
            getObjects: {
                let target = Target.someTarget
                let data = try await networkingService.requestTarget(target: target)
                let objects = ..... // convert data to Objects
                return objects
            }
        )
    }
}

Now one would have the possibility to test the implementations of a dependency with mocked dependencies in the tests.

final class APIWrapper_Tests: XCTestCase {
  func testImplementation() async throws {
    let wrapperWithMockedDependencies = APIWrapper.live(networkingService: .mocked)
    let objects = await apiWithMockedDependencies.getObjects()
    // do some assertions
  }
}

Unfortunately, I am not quite sure if this is the preferred way,
and would be grateful for any comments and suggestions for other solutions.

[atimca]

Hey @iwt-sebastian-boldt ✌️,

I think this example from isowords will answer your question

  let store = Store(
    initialState: AppReducer.State(),
    reducer: AppReducer().transformDependency(\.self) {
      $0.audioPlayer = .liveValue
      $0.database = .live(
        path: FileManager.default
          .urls(for: .documentDirectory, in: .userDomainMask)
          .first!
          .appendingPathComponent("co.pointfree.Isowords")
          .appendingPathComponent("Isowords.sqlite3")
      )
      $0.serverConfig = .live(apiClient: $0.apiClient, build: $0.build)
    }
  )

or here's another approach

import ComposableArchitecture
import Foundation

struct URLProvider {
    var url: URL
}

struct ApiClient {
    var tellMeURL: () -> URL
}

private enum ApiClientKey: DependencyKey {
    static let liveValue = ApiClient(tellMeURL: {
        @Dependency(\.urlProvider) var urlProvider
        return urlProvider.url
    })
}

private enum URLProviderKey: DependencyKey {
    static let liveValue = URLProvider(url: URL(string: "some.com")!)
}

extension DependencyValues {
    var urlProvider: URLProvider {
        get { self[URLProviderKey.self] }
        set { self[URLProviderKey.self] = newValue }
    }
}

[twocentstudios]

I was going to follow the template from Isowords, but I noticed this warning in the docs for transformDependency that made me 🤔:

The trailing closure of transformDependency(_:transform:) is called for every action sent to the reducer, and so you can expect it to be called many times in an application’s lifecycle. This means you should typically not create dependencies in the closure as that will cause a new dependency to be created everytime an action is sent.

I'm wondering if anyone else has settled on an app-wide run-once first-time initialization pass technique for wiring up dependencies between dependencies.

[rcarver]

Here's what I do

public struct UserClient: Sendable {
    public var fetchMe: @Sendable () async throws -> MeResponse
}
extension UserClient: DependencyKey {
    public static let liveValue: Self = {
        @Dependency(\.apiClient) var apiClient
        return .init(
            fetchMe: {
                try await apiClient.getJSON(path: "/api/users/me")
            }
        }
    }
}

[twocentstudios]

Also want to add that including the withDependencies closure in the Store.init(initialState:reducer:withDependencies:) variant is the same as setting reducer.transformDependency.

[twocentstudios]

@rcarver Thanks! Your nested approach might work for my current requirement. At this point it's mostly curiosity if I happened to need to coordinate the initialization of sibling dependencies.