What is the best practice to have dependency within dependency?

[havilog]

I'm thinking about how to deal with dependency.

My situation is

1. I need to have network dependency in account dependency
2. I want to have private function which only excutes inside dependency
3. and those private functions want to access to network dependency

and I can't figure out the best way to manage this situation.

here is my sample code below.

struct SomeFeature: ReducerProtocol {
    // ...
    
    @Dependency(\.tokenClient) var tokenClient
    
    func reduce(into state: inout State, action: Action) -> EffectTask<Action> {
        // wanna use only token dependency
    }
}

struct TokenClient {
    // this will handle all the token logic
    var token: @Sendable () async throws -> Credential
}

extension TokenClient: DependencyKey {
    // static let network: NetworkClient <- I think this can't be injected outside
    
    // I've tried liveValue to be computed property 
    // like `@Dependency(\.network) var network` inside computed property
    // but I can't use network dependency in `doSomeAdditionalFunction1`
    static let liveValue: TokenClient = .init(
        token: {
            // I need some dependency to store token
            // and network dependency to request or refresh token
            
            doSomeAdditionalFunction1()
            
            guard let credential = storage.load() else {
                return network.requestNewToken()
            }
            
            guard credential.isValid else { 
                return network.refresh(credential)
            }
            
            doSomeAdditionalFunction2()
            
            return credential
        }
    )
    
    private static func doSomeAdditionalFunction1() {
        // need some network call
        network.doSomething()
    }
    
    private static func doSomeAdditionalFunction2() {
        // need some dependency
        someDependency.doOtherWork()
    }
}

I have already seen this document.

I'm looking forward to your answer.

[stephencelis]

@havilog You can use @Dependency anywhere you need one, just be aware that cyclical dependencies are not supported (where A depends on B depends on A, etc.).

So in the above case, you could reach out to other dependencies directly in your static functions, or even a static computed property:

extension TokenClient: DependencyKey {
  static var liveValue: Self {
    // Expose a dependency to use later:
    @Dependency(\.network) var network

    return Self(
      token: {
        doSomeAdditionalFunction1()

        guard let credential = storage.load() else {
          return network.requestNewToken()
        }
            
        // ...
      }
    )
    
    private static func doSomeAdditionalFunction1() {
      // To use the "network" dependency in this function:
      @Dependency(\.network) var network

      network.doSomething()
    }

    // ...
  }
}

[havilog]

@stephencelis thanks for fast answer!
The method you taught me works perfectly.
My curiosity about dependency has been resolved.

but I have one more curiosity about dependency having there functionality as a property.
I'm not sure this way is correct.

struct SomeFeature: ReducerProtocol {
    // ...
    
    @Dependency(\.tokenClient) var tokenClient
    
    func reduce(into state: inout State, action: Action) -> EffectTask<Action> {
        switch action {
        case .something:
            return .task {
                await .someResponse(
                    TaskResult{
                        // can't do this
                        // because Function types cannot have argument labels
                        try await tokenClient.doSomething(someParameter: A, next: B) 
                        
                        // so I have to do like this
                        // and I think this signature is a little vague.
                        try await tokenClient.doSomething(A, B)
                    }
                )
            }
        }
    }
}

struct TokenClient {
    var doSomething: @Sendable (_ something: String, _ next: String) async throws
}

[stephencelis]

@havilog This pretty much depends on how TokenClient is defined. If you're accessing closure properties directly off the struct, it's true that Swift doesn't (currently) support argument labels. There are a few workarounds:

1. Extend TokenClient with a method that has argument labels and calls down to the underlying property:

   extension TokenClient {
     func doSomething(someParameter: A, next: B) async throws {
       try await self.doSomething(someParameter, next)
     }
   }

2. You could return a type that has callAsFunction defined with argument labels, instead of a closure:

   struct TokenClient {
     var doSomething: DoSomethingEffect
   }
   
   struct DoSomethingEffect {
     var run: (A, B) async throws -> Void
   
     func callAsFunction(someParameter: A, next: B) async throws {
       try await self.run(someParameter, next)
     }
   }

3. Bundle up your arguments in a struct. It'll get some nesting of parentheses, but you get the argument labels "for free":

   struct DoSomethingRequest {
     var someParameter: A
     var next: B
   }
   
   struct TokenClient {
     var doSomething: (DoSomethingRequest) async throws -> Void
   }
   
   // ...
   try await tokenClient.doSomething(.init(someParameter: a, next: b))

Everything comes with its own boilerplate and trade offs, so you should evaluate them and decide what makes the most sense for you and anyone else working on the project.