Injecting externally resolved dependencies into DependencyValues

[PereAlmendro]

Hi, is there a way to inject an externally resolved dependency to the dependency values without having to create an empty implementation for it ?

Problem:
I have a module, and i'm given a resolved instance of a class that i want to add to the dependency values, so i can resolve it anywhere.

Actual solution:

import Dependencies

// MARK: - Register dependency

struct FOODependencyKey: DependencyKey {
    static var liveValue: any FOODependencyProtocol = FOOEmptyImplementation() // not Concurrency safe in swift 6
    // static let liveValue: any FOODependencyProtocol = FOOEmptyImplementation()
}

extension DependencyValues {
    var fooDependency: any FOODependencyProtocol {
        get { self[FOODependencyKey.self] }
        set { self[FOODependencyKey.self] = newValue }
    }
}

// MARK: - Update dependency

struct SomeModule {
    init(fooDependency: FOODependencyProtocol) {
       //  1 - working without issues
       FOODependencyKey.liveValue = fooDependency
      
       // option 2 - I Had problems when having multiple instances of my module
       prepareDependencies { values in
           values[FOODependencyKey.self] = fooDependency
       }
    }
}

// MARK: - Use dependency

@Dependency(\.fooDependency) var fooDependency

Despite the fact i should avoid having multiple instances of "SomeModule"

Is there any way to avoid the empty implementation ? it does not look very nice to me, but i didn't found a better solution for the moment.

Can i have some help with this 🙏 What would you recommend me to do in this case ?

Thanks in advance.

[mbrandonw]

Hi @PereAlmendro, I'm not sure I fully understand your problem, but it seems to me that you want to conform to just TestDependencyKey, not DependencyKey, that way you don't have to provide a liveValue:

enum FOODependencyKey: TestDependencyKey {
  static var testValue: any FOODependencyProtocol {
    FooEmptyImplementation()
  }
}

(Aside: Even better if your FooEmptyImplementation invokes reportIssue in every protocol requirement that way you will get test failures if you ever use it in tests.)

Then in the entry point of your app you will prepare the live dependency:

@main 
struct EntryPoint: App {
  init() {
    prepareDependencies {
      $0.fooDependency = FooLiveImplementation()
    }
  }
}

[PereAlmendro]

Hi @mbrandonw, thanks for your fast response.

Removing the live value and implementing the prepareDependencies worked fine.

In addition, I had to make sure that there is only one instance of the EntryPoint during the app lifetime, because of the prepareDependencies.

It would be nice to be able to add dependencies to the DependencyValues also without a DependencyKey, to avoid that Empty Implementation I have to provide in this cases, I don't know if that could be possible.

Thanks for the support !