smart-injector

Small lightweight (~3kb minified) module for Inversion of Control (IoC Container) and Dependency Injection for JavaScript, EcmaScript and TypeScript.

$ npm install smart-injector --save

Use ts-ioc-compiler for syntactic sugar, and interface intellisense: https://github.com/jeppeskovsen/ts-ioc-compiler

Usage

It is not necessary to wrap the container inside a class, but this will make sure container.register happens sooner.

import { Container, Instantiate, SmartInjectorSetup } from "smart-injector";
import { CustomService } from "./custom.service";

@SmartInjectorSetup
class SmartInjector {
    constructor() {
        const container = new Container();
        
        container.register<ICustomService>(CustomService);
        container.register<IAnotherCustomService>(IAnotherCustomService, Instantiate.EachRequest);
        
        container.verify();
    }
}

And just import it in your main file, and make sure it is one of the first thing being loaded.

import "./ioc-setup.ts";

Instantiate is an enum with 3 properties:

enum Instantiate {
    WhenUsed, // default
    RightAway,
    EachRequest
}

Getting the instance of the class without dependency injection:

import { Container } from "smart-injector";
const customService = Container.getInstance<ICustomService>(CustomService);

Dependency Injection

There are two ways to inject into a class, that is registered in the container.

Via contructor

import { Inject } from "smart-injector";

export class CustomService implements ICustomService {
    constructor(
        @Inject<IAnotherCustomService>() private customService2: IAnotherCustomService
    ) {}
    
    public customMethod(): string {
        return this.customService2.someMethod();
    }
}

Via properties

import { Inject } from "smart-injector";

export class CustomService implements ICustomService {
    @Inject<IAnotherCustomService>()
    customService2: IAnotherCustomService;
    
    public customMethod(): string {
        return this.customService2.someMethod();
    }
}

@Inject vs @StaticInject

@StaticInject will try to inject the property immediately, where @Inject will inject when instance is created.

@StaticInject only works for properties, and not constructor arguments.

Without ts-ioc-compiler (magic strings)

@Inject("ICustomService");
@StaticInject("ICustomService");
container.register("ICustomService", CustomService);
Container.getInstance("ICustomService", CustomService);