Overview

depents is a typescript dependency injection framework

How to install

npm i depents

Quickstart (TL;DR)

import {Singleton, Inject, Injector} from 'depents'


@Singleton()
class AClass{
    private A = 'a'
    
    getA () {
        return this.A
    }
}

@Singleton()
class BClass{

    @Inject(AClass)
    private a: AClass

    getA(){
        return this.a.getA()
    }
}


console.log(Injector.resolve(BClass).getA()) //"a"

Working with interfaces as non-default injection tokens

As interfaces are not a runtime construct in javascript, classes have to be used in their place in order to work with injection resolution.

Consider this quick example:

File MyModule/Interface.ts

export abstract class IComponent{
    get: () => string
}

File MyModule/Implementation.ts

import {IComponent} from 'Interface.ts'

@Singleton({
    interface: IComponentB,
})
export class ComponentB implements IComponent{
    get(): string {
        return "Hello!"
    }
}

File Main.ts

import {IComponent} from 'MyModule/Interface.ts'
import {ComponentB} from 'Module/Implementation.ts'
ComponentB; //see Tree shaking pitfall below

Injector.resolve(IComponent).get()

Tree shaking pitfall

TSC will attempt to exclude unused code in order to keep the compiled JS minimal. In the above example neither Main.ts nor MyModule/Interface.ts ever reference MyModule/Implementation.ts and it is therefore considered unused code. This will lead to the compilation output not containing the ComponentB class. To forcibly include ComponentB, it has to be referenced at least once - even if it is a senseless operation like in the above example.

Initialization

This version of depents will simply call all constructors of classes marked as Singleton without arguments and it is therefore recommended that the user does not place initialization logic there. Alternatively, you may provide a function named initialize which will be called during Singleton creation.

An example:

@Singleton()
export class Component{
    private value: string

    get(): string {
        return this.value
    }

    initialize():void { //Called during object creation
        this.value = "Hello!"
    }
}

If your code requires objects to be initialized in a particular order, you may pass an optional initializationPriority parameter to @Singleton. The respective initialize operations will be called in order of initializationPriority from lowest to highest. If omitted, the default value is 0.

@Singleton({
    initializationPriority: 0
})
export class InitializedFirst{
    private value: number

    get(): number {
        return this.value
    }

    initialize():void {
        this.value = 1
    }
}

@Singleton({
    initializationPriority: 1
})
export class InitializedSecond{
    @Inject(InitializedFirst)
    private otherSingleton: InitializedFirst

    private value: number

    get(): number {
        return this.value
    }

    initialize():void {
        this.value = 1 + this.otherSingleton.get()
    }
}

console.log(Injector.resolve(InitializedSecond).get()) //2

Full documentation