container-ioc

container-ioc

is a Dependency Injection / IoC container package for Typescript/ES6+ projects. It manages the dependencies between classes, so that applications stay easy to change and maintain as they grow.

Features:

• Well-known Angular4+ DI API.
• Can be used in ES6+/Typescript projects.
• No external dependencies.
• Singleton and Non-Singleton configuration.
• Hierarchical containers.
• Pluggable metadata annotator.
• 97% test coverage.

Installation:

npm install --save container-ioc

Quick start

Typescript:

import { Container, Inject, Injectable } from 'container-ioc';

let container = new Container();

@Injectable()
class App {}

interface IService {}

@Injectable()
class Service implements IService {
    constructor(@Inject('IService') public service: IService) {}
}

let providers = [
    { token: App, useClass: App }, 
    { token: 'IService', useClass: Service }
];

container.register(providers);
let app = container.resolve(App);

Javascript ES6+:

use alternative syntax for declaring injections shown below and don't use interfaces.

@Injectable(['IService'])
class Service implements IService {
    constructor(service) {
        this.service = service;
    }
}

NOTE: All the examples below are written in Typescript. Check out examples/javascript and examples/typescript for examples.

Best Practise: use InjectionToken instances for tokens instead of string/class literals:

Without InjectionToken:

interface IService {}

@Injectable()
class ConcreteService {}

container.register({ token: 'IService', useClass: ConcreteService });
container.resolve('IService');

With InjectionToken

interface IService {}

const TService = new InjectionToken<IService>('IService'); // T stands for Token, you can pick another prefix

@Injectable()
class ConcreteService {}

container.register({ token: TService, useClass: ConcreteService });
container.resolve(TService);

Persistence control.

By default, resolved instances are singletons. You can change that by setting provider's attribute LifeTime to LifeTime.PerRequest.

import { Container, Injectable, LifeTime } from 'container-ioc';

const container = new Container();

@Injectable()
class A {}

container.register({ token: A, useClass: A, lifeTime: LifeTime.PerRequest });

const instance1 = container.resolve(A);
const instance2 = container.resolve(A);

// instance1 !== instance2

Hierarchical containers.

if a provider wasn't found in a container it will look up in ascendant containers if there are any:

import { Container } from 'container-ioc';

@Injectable()
class A {}

let parentContainer = new Container();
let childContainer = parentContainer.createScope();

parentContainer.register({ token: 'IA', useClass: A });

childContainer.resolve('IA');

Pluggable metadata annotator.

By default metadata is assigned to static properties. If you want to use Reflect API for annotation, you can implement IMetadataAnnotator interface with your implementation using Reflect API. Then plug it into AnnotatorProvider

import { AnnotatorProvider, IMetadataAnnotator, Container } from 'container-ioc';

class ReflectMetadataAnnotator implements IMetadataAnnotator {
    // your implementation
}

AnnotatorProvider.set(new ReflectMetadataAnnotator());

let container = new Container();

...

Contribution:

Feel free to submit a bug or a feature request. Or pick an issue from here and leave a comment with your proposal.

see CONTRIBUTION.md

Changelog

1.6.8 (2017-10-05)

Features

• Added support for ES6+ - Added new syntax for declaring injectioins of a class, now it's possible via Injectable decorator. see examples/javascript.

<a name="1.6.0"></a>