[Question] - Migration from Resolver about factory

[hmlongco]

That one's tough.

What you're currently doing is what Resolver does. Basically the code is hoping that someone, somewhere, has registered a factory to provide an instance of the needed interface.

Factory, on the other hand, works by ensuring that there's an implementation to be seen, hence it's compile-time safe. It doesn't hope. It knows.

I'll have to think about that one a bit.

[alexanderwe]

Thanks a lot for thinking about it. I was also wondering if the approach described by me will even be possible with Factory. Because it is exactly what you said.
The features just rely on, that there will be some implementation conforming to the given protocol. They have no guarantee however and the application will crash if a developer has forgotten to add a certain dependency.

[hmlongco]

Still thinking, but one option might be something like this...

protocol FeatureAInterface {
    ...
}
extension Container {
    static var featureA = Factory<FeatureAInterface?> { nil }
}

Which allows...

import FeatureA
...
class FeatureBImplementation: FeatureBInterface {
    private var featureA = Container.featureA()
    func fetchResourceB() async -> ResourceB {
        let _ = await featureA?.fetchResourceA()
        return ResourceB()
    }
}

Then at app launch you call setup...

func setup() {
    Container.featureA.register { FeatureAImplementation() }
    Container.featureB.register { FeatureBImplementation() }
}

Each interface publishes an optional Factory that returns nil so it doesn't expose implementation. Anyone who uses it has to handle optional aspect, but no crash if not provided. Setup function on app registers implementations and wires the world together, much as you did before.

[hmlongco]

Oh, and note

class FeatureBImplementation: FeatureBInterface {

   @Injected(Container.featureA) private var featureA

    func fetchResourceB() async -> ResourceB {
        let _ = await featureA?.fetchResourceA()
        return ResourceB()
    }
}

If the type of the factory is optional, then the type injected is optional. No need for OptionalInjected property wrapper.

[alexanderwe]

Very interesting, thanks a lot for providing the suggestions. This means, that, in the context of the example: FeatureB then needs to validate that necessary injected types are not nil, right ? So basically what previously was done by Resolver internally, now needs to be done by the different Feature implementations.

So the general idea high level idea would be:
In the Interface we provide a "cutout" for the injected service, but set it to nil. Inside the app we fill it out with the correct implementation.

I need to think a little bit about it - I quite liked this "dynamic" approach of Resolver - or better said, the "implicit unwrapped optional" approach. But with your suggestions, I think, I could atleast keep the base functionality. It seems I need to re-think the whole approach on my side.

Also very nice, that @OptionalInjected is not needed any longer :)

[alexanderwe]

But I think compile time safety is definitely a very nice approach ! Great to see this improvement :) So really good work.

[hmlongco]

I mean, there's nothing stopping you from explicitly unwrapping it on your own...

class FeatureBImplementation: FeatureBInterface {

    @Injected(Container.featureA) private var featureA: FeatureAInterface!

    func fetchResourceB() async -> ResourceB {
        let _ = await featureA.fetchResourceA()
        return ResourceB()
    }
}

Other than losing the main benefit of Factory, this is. ;)

I'll still noodle on this. Let me know if you come up with something.

[hmlongco]

Another conversation on this is occurring in issue 3.

[alexanderwe]

@hmlongco Thanks a lot for linking the other issue !