Is there a way to detect missing dependencies?

[kamil-zaborowski-pb]

The project I am working on uses Composable Architecture. Some of the reducers are being used "separately" from the main context of the application, thus they do not have access to the app dependencies out of the box.

When I create such a reducer, is there a good way to tell at runtime that I forgot to attach some dependency to it?

If no live dependency is accessible when running the app, I would expect it to f.e. throw an assertion. Is this something configurable?

[mbrandonw]

When a dependency is resolved at runtime, if the library does not see a DependencyKey conformance, and only sees a TestDependencyKey conformance, then the library will produce a purple runtime warning in Xcode letting you know that there is no live implementation.

Does that help?

[kamil-zaborowski-pb]

This doesn’t appear to be working in my case 🤔

I have a UIKit host. It creates two separate StoreOf<A> and StoreOf<B>. I have single instance of the service Foo. This service is being added via withDependencies to both stores, when they are being created.
I am currently testing it with Simulator running on iOS 16, swift dependencies 1.2.2

I can try to create a code sample that reproduces this scenario if it would be helpful.

[mbrandonw]

If you are overriding the service for each store then the runtime warning will not be triggered. I should have been more precise in my description above. The warning is only triggered if there is no live implementation provided (via DependencyKey) or if a value has not been provided via withDependencies.

But also, if you are overriding for each store, then why would you want a warning?

I can try to create a code sample that reproduces this scenario if it would be helpful.

That is always helpful! 🙂

[kamil-zaborowski-pb]

I have tried to recreate this case in the smaller project, but there everything worked as you've described. I got the purple warning.
Interestingly enough, runtimeWarn("""@Dependency(\(argument)) has no live implementation is also being triggered in the real project. But the purple warning never appears 🤔. Console is empty too, in the sample project I see: "To fix you can do one of two things: ..."

import UIKit
import ComposableArchitecture

struct FooService {
    var action: () -> Void
}

extension FooService: TestDependencyKey {
    static var testValue = Self(action: { })
}

extension FooService {
    static func live() -> Self {
        Self(action: { })
    }
}

extension DependencyValues {
    var foo: FooService {
        get { self[FooService.self] }
        set { self[FooService.self] = newValue }
    }
}

@Reducer
struct FeatureA {
    @ObservableState
    struct State {}
    enum Action {
        case task
    }

    @Dependency(\.foo) var foo

    var body: some Reducer<State, Action> {
        Reduce { state, action in
            switch action {
                case .task:
                    foo.action()
                    return .none
            }
        }
    }
}

@Reducer
struct FeatureB {
    @ObservableState
    struct State {}
    enum Action {
        case start
    }

    @Dependency(\.foo) var foo

    var body: some Reducer<State, Action> {
        Reduce { state, action in
            switch action {
                case .start:
                    foo.action()
                    return .none
            }
        }
    }
}

class ViewController: UIViewController {

    let fooLive = FooService.live()

    lazy var storeA: StoreOf<FeatureA> = {
        Store(initialState: .init(), reducer: {
            FeatureA()
        }, withDependencies: {
            $0.foo = self.fooLive
        })
    }()

    lazy var storeB: StoreOf<FeatureB> = {
        Store(initialState: .init(), reducer: {
            FeatureB()
        }, withDependencies: { _ in
            // foo service has not assigned live value
        })
    }()

    override func viewDidLoad() {
        super.viewDidLoad()

        // StoreA would be part of SwiftUI View,
        // but it seems it doesn't matter for now.
        storeA.send(.task)
        storeB.send(.start)
    }
}

[kamil-zaborowski-pb]

Something I would find very useful is a custom error handler. According to the project requirements it could f.e. send the report to firebase if such thing would happen on production, or even crash when running test-build.