@jojoxd/simple-di

See on NPM

Simple, Extensible Dependency Injection.

Installation

You can get the latest release and the type definitions using npm:

$ npm install @jojoxd/simple-di

The type definitions are included in the @jojoxd/simple-di npm package.

⚠️ Important: If you want to use @Inject() without specifying the ProviderToken,
you need to npm install reflect-metadata and import 'reflect-metadata' in your entrypoint.
You also want to enable experimentalDecorators and emitDecoratorMetadata in your tsconfig.json file.

Examples

Creating an Injectable and injecting it into another class

The basis of any DI library:

import { container, Inject, Injectable } from "@jojoxd/simple-di";

class MyService {}

// Explicit declaration
container.addProvider(MyService, new ClassProvider(MyService));

// Implicit decorator service declaration
@Injectable()
class MyOtherService {}

class MyInjectionService
{
    @Inject() // Note: if not using reflect-metadata, you need to use @Inject(MyService)
    public myService!: MyService;

    @Inject()
    public myOtherService!: MyOtherService;
}

const myInjectionService = new MyInjectionService();
myInjectionService.myService; // => MyService instance

Using Factories

Factories are big in @jojoxd/simple-di. They allow you to use "scoped" injections,
caching (bring-your-own-caching-layer), and possibly more (you think of it!).

import {
    container,
    Inject, Injectable,
    BaseFactoryProvider, FactoryProvider, IFactoryProvider
} from "@jojoxd/simple-di";

class MyService {
    constructor(public scope: any, public name: string) {}
}

// Explicit declaration
// Note: name is an additional argument, it is not needed.
container.addProvider(MyService, new BaseFactoryProvider((scope, name) => new MyService(scope, name)));

// Implicit creation of a Factory Provider
@FactoryProvider(MyService)
class MyFactoryProvider implements IFactoryProvider<MyService>
{
    public provide(scope: any, name: string): T
    {
        return new MyService(scope, name);
    }
}

// From Root Scope
const rootScopeMyService = container.get<MyService>(MyService, "some-name");

// From other scope
const otherScopeMyService = container.scoped({ test: true }).get<MyService>(MyService, "some-other-name");

Using Tags to fetch a collection

import { container, WithTags, Injectable } from "@jojoxd/simple-di";

@Inject()
@WithTags("my-tag")
class Test {}

@Inject()
@WithTags("my-tag", "other-tag")
class Test2 {}

container.getAllTagged("my-tag") // > [ Test {}, Test2 {} ]