Shank

A Swift micro-library that provides lightweight dependency injection.

Read more here: https://basememara.com/swift-dependency-injection-via-property-wrapper/

Inject dependencies via property wrappers:

class ViewController: UIViewController {
    
    @Inject private var widgetModule: WidgetModuleType
    @Inject private var sampleModule: SampleModuleType
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        widgetModule.test()
        sampleModule.test()
    }
}

Register modules early in your app:

class AppDelegate: UIResponder, UIApplicationDelegate {

    private let dependencies = Dependencies {
        Module { WidgetModule() as WidgetModuleType }
        Module { SampleModule() as SampleModuleType }
    }
    
    override init() {
        super.init()
        dependencies.build()
    }
}

If you forget to build the dependency container, it will result in a run-time exception.
Since there is no type-safety to guard against this, it is recommended to
limit the dependency container to hold “modules” only:

struct WidgetModule: WidgetModuleType {
    
    func component() -> WidgetWorkerType {
        WidgetWorker(
            store: component(),
            remote: component()
        )
    }
    
    func component() -> WidgetRemote {
        WidgetNetworkRemote(httpService: component())
    }
    
    func component() -> WidgetStore {
        WidgetRealmStore()
    }
    
    func component() -> HTTPServiceType {
        HTTPService()
    }
    
    func test() -> String {
        "WidgetModule.test()"
    }
}

struct SampleModule: SampleModuleType {
    
    func component() -> SomeObjectType {
        SomeObject()
    }
    
    func component() -> AnotherObjectType {
        AnotherObject(someObject: component())
    }
    
    func component() -> ViewModelObjectType {
        SomeViewModel(
            someObject: component(),
            anotherObject: component()
        )
    }
    
    func component() -> ViewControllerObjectType {
        SomeViewController()
    }
    
    func test() -> String {
        "SampleModule.test()"
    }
}

// MARK: API

protocol WidgetModuleType {
    func component() -> WidgetWorkerType
    func component() -> WidgetRemote
    func component() -> WidgetStore
    func component() -> HTTPServiceType
    func test() -> String
}

protocol SampleModuleType {
    func component() -> SomeObjectType
    func component() -> AnotherObjectType
    func component() -> ViewModelObjectType
    func component() -> ViewControllerObjectType
    func test() -> String
}

Then resolve individual components lazily:

class ViewController: UIViewController {
    
    @Inject private var widgetModule: WidgetModuleType
    @Inject private var sampleModule: SampleModuleType
    
    private lazy var widgetWorker: WidgetWorkerType = widgetModule.component()
    private lazy var someObject: SomeObjectType = sampleModule.component()
    private lazy var anotherObject: AnotherObjectType = sampleModule.component()
    private lazy var viewModelObject: ViewModelObjectType = sampleModule.component()
    private lazy var viewControllerObject: ViewControllerObjectType = sampleModule.component()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        widgetModule.test() //"WidgetModule.test()"
        sampleModule.test() //"SampleModule.test()"
        widgetWorker.fetch(id: 3) //"|MediaRealmStore.3||MediaNetworkRemote.3|"
        someObject.testAbc() //"SomeObject.testAbc"
        anotherObject.testXyz() //"AnotherObject.testXyz|SomeObject.testAbc"
        viewModelObject.testLmn() //"SomeViewModel.testLmn|SomeObject.testAbc"
        viewModelObject.testLmnNested() //"SomeViewModel.testLmnNested|AnotherObject.testXyz|SomeObject.testAbc"
        viewControllerObject.testRst() //"SomeViewController.testRst|SomeObject.testAbc"
        viewControllerObject.testRstNested() //"SomeViewController.testRstNested|AnotherObject.testXyz|SomeObject.testAbc"
    }
}

// MARK: - Subtypes

extension DependencyTests {

struct WidgetModule: WidgetModuleType {
    
    func component() -> WidgetWorkerType {
        WidgetWorker(
            store: component(),
            remote: component()
        )
    }
    
    func component() -> WidgetRemote {
        WidgetNetworkRemote(httpService: component())
    }
    
    func component() -> WidgetStore {
        WidgetRealmStore()
    }
    
    func component() -> HTTPServiceType {
        HTTPService()
    }
    
    func test() -> String {
        "WidgetModule.test()"
    }
}

struct SampleModule: SampleModuleType {
    
    func component() -> SomeObjectType {
        SomeObject()
    }
    
    func component() -> AnotherObjectType {
        AnotherObject(someObject: component())
    }
    
    func component() -> ViewModelObjectType {
        SomeViewModel(
            someObject: component(),
            anotherObject: component()
        )
    }
    
    func component() -> ViewControllerObjectType {
        SomeViewController()
    }
    
    func test() -> String {
        "SampleModule.test()"
    }
}

struct SomeObject: SomeObjectType {
    func testAbc() -> String {
        "SomeObject.testAbc"
    }
}

struct AnotherObject: AnotherObjectType {
    private let someObject: SomeObjectType
    
    init(someObject: SomeObjectType) {
        self.someObject = someObject
    }
    
    func testXyz() -> String {
        "AnotherObject.testXyz|" + someObject.testAbc()
    }
}

struct SomeViewModel: ViewModelObjectType {
    private let someObject: SomeObjectType
    private let anotherObject: AnotherObjectType
    
    init(someObject: SomeObjectType, anotherObject: AnotherObjectType) {
        self.someObject = someObject
        self.anotherObject = anotherObject
    }
    
    func testLmn() -> String {
        "SomeViewModel.testLmn|" + someObject.testAbc()
    }
    
    func testLmnNested() -> String {
        "SomeViewModel.testLmnNested|" + anotherObject.testXyz()
    }
}

class SomeViewController: ViewControllerObjectType {
    @Inject private var module: SampleModuleType
    
    private lazy var someObject: SomeObjectType = module.component()
    private lazy var anotherObject: AnotherObjectType = module.component()
    
    func testRst() -> String {
        "SomeViewController.testRst|" + someObject.testAbc()
    }
    
    func testRstNested() -> String {
        "SomeViewController.testRstNested|" + anotherObject.testXyz()
    }
}

struct WidgetWorker: WidgetWorkerType {
    private let store: WidgetStore
    private let remote: WidgetRemote
    
    init(store: WidgetStore, remote: WidgetRemote) {
        self.store = store
        self.remote = remote
    }
    
    func fetch(id: Int) -> String {
        store.fetch(id: id)
            + remote.fetch(id: id)
    }
}

struct WidgetNetworkRemote: WidgetRemote {
    private let httpService: HTTPServiceType
    
    init(httpService: HTTPServiceType) {
        self.httpService = httpService
    }
    
    func fetch(id: Int) -> String {
        "|MediaNetworkRemote.\(id)|"
    }
}

struct WidgetRealmStore: WidgetStore {
    
    func fetch(id: Int) -> String {
        "|MediaRealmStore.\(id)|"
    }
    
    func createOrUpdate(_ request: String) -> String {
        "MediaRealmStore.createOrUpdate\(request)"
    }
}

struct HTTPService: HTTPServiceType {
    
    func get(url: String) -> String {
        "HTTPService.get"
    }
    
    func post(url: String) -> String {
        "HTTPService.post"
    }
}

// MARK: API

protocol WidgetModuleType {
    func component() -> WidgetWorkerType
    func component() -> WidgetRemote
    func component() -> WidgetStore
    func component() -> HTTPServiceType
    func test() -> String
}

protocol SampleModuleType {
    func component() -> SomeObjectType
    func component() -> AnotherObjectType
    func component() -> ViewModelObjectType
    func component() -> ViewControllerObjectType
    func test() -> String
}

protocol SomeObjectType {
    func testAbc() -> String
}

protocol AnotherObjectType {
    func testXyz() -> String
}

protocol ViewModelObjectType {
    func testLmn() -> String
    func testLmnNested() -> String
}

protocol ViewControllerObjectType {
    func testRst() -> String
    func testRstNested() -> String
}

protocol WidgetStore {
    func fetch(id: Int) -> String
    func createOrUpdate(_ request: String) -> String
}

protocol WidgetRemote {
    func fetch(id: Int) -> String
}

protocol WidgetWorkerType {
    func fetch(id: Int) -> String
}

protocol HTTPServiceType {
    func get(url: String) -> String
    func post(url: String) -> String
}

This way, only your “modules” are not type-safe, which is acceptable since
an exception with a missing module should happen early on and hopefully
obvious enough in development.

However, the individual components are type-safe and have greater flexiblity to include
parameters while resolving the component. The components should have their dependencies
injected through the constructor, which is the best form of dependency injection.
The modules get the property wrappers support and can even inject modules within modules.