Curli-DI

A Dependency Injection (DI) library in typescript without using decorators.

Installation

Install by npm

npm install --save curli-di

Basic Usage

import {DependencyInjection} from "curli-di";
import {Database} from "database";

class Foo {
  constructor(private database: Database) {}
}

const container = new DependencyInjection();

//register the dependencies for the class
container.registerService("dataBase", [], Database);
container.registerService("foo", ["dataBase"], Foo);

//creating the service
const foo = container.get("foo");

Registering external dependencies/properties:

Some time we need to inject properties or other kind of values into our services, for this we use the class ExternalDependencies like here:

import {DependencyInjection, ExternalDependencies} from "curli-di";
import {Database} from "database";

class Foo {
  constructor(private database: Database) {}
}

// Register previous dependencies already instantiated
const externalDependencies = new ExternalDependencies();
externalDependencies.add("dataBaseUser", "root");
externalDependencies.add("dataBasePass", "");

const container = new DependencyInjection(externalDependencies);

//register the dependencies for the class
container.registerService("dataBase", ["@dataBaseUser", "@dataBasePass"], Database);
container.registerService("foo", ["dataBase"], Foo);

//creating the service
const foo = container.get("foo");

As this example shows, to access to any external dependency or property we need to add the prefix @.

Also to inject or use a external dependency we can use the registerServiceBuilded method in the container after we initialized it:

import {DependencyInjection} from "curli-di";

const container = new DependencyInjection();
container.registerServiceBuilded("dataBaseUser", "root");

const dataBaseUser: string = container.get("@dataBaseUser");

Registering external dependencies/properties with an object in bulk mode:

import {DependencyInjection, ExternalDependencies} from "curli-di";
import {Database} from "database";
import {Oauth} from "oauth";
import {Lang} from "lang";

class Foo {
  constructor(private database: Database) {}
}

// Register previous dependencies already instantiated
const externalDependencies = new ExternalDependencies();
externalDependencies.bulk({
    "dataBaseUser": "root",
    "dataBasePass": "",
    "useOauth": false,
    "languagesSupported": ['en-GB','es-MX', 'zh-HK']
});

const container = new DependencyInjection(externalDependencies);

//register the dependencies for the class
container.registerService("dataBase", ["@dataBaseUser", "@dataBasePass"], Database);
container.registerService("foo", ["dataBase"], Foo);
container.registerService("lang", ["@languagesSupported"], Lang);
container.registerService("oauth", [], Oauth);

if (container.get("@useOauth")) {
    container.get("oauth").start();
}

//creating the service
const foo = container.get("foo");

Circular dependency:

To create a circular dependency between two services, one of the then will receive their dependencies with a different method than the constructor.

import {DependencyInjection} from "curli-di";

class Foo {
    constructor(private database: Database, private taa: Taa) {}
}


class Taa {
    private foo: Foo;

    public injectDependencies(foo: Foo) {
        this.foo = foo;
    }
}

const container = new DependencyInjection();

//registering of dependencies with the classes
container.registerService("foo", ["dataBase", "taa"], Foo);
container.registerService("taa", ["foo"], Taa, false, Taa.prototype.injectDependencies);

//creating the service
const foo = container.get("foo");

Registering services descriptions in different sides of the application:

If we want to split the responsibility of register services in different sides of the application we can perform it using the ExternalServicesRegister class:

import {DependencyInjection, ExternalServicesRegister} from "curli-di";
import {Database} from "database";

class Foo {
  constructor(private database: Database) {}
}

// Register previous dependencies already instantiated
const container = new DependencyInjection(),
      externalServicesRegister = new ExternalServicesRegister();


//register the dependencies for the class
externalServicesRegister.registerService("dataBase", ["@dataBaseUser", "@dataBasePass"], Database);
externalServicesRegister.registerService("foo", ["dataBase"], Foo);

container.registerExternalServiceRegister(externalServicesRegister);

//creating the service
const foo = container.get("foo");

Instantiate one or more services in a specific moment (like when we start the app) using autoInit option:

import {DependencyInjection} from "curli-di";
import {Database} from "database";
import {Oauth} from "oauth";
import {Lang} from "lang";
import {Foo} from "foo";

const container = new DependencyInjection();

//register the dependencies for the class
container.registerService("dataBase", [], Database, true);
container.registerService("foo", [], Foo);
container.registerService("lang", [], Lang);
container.registerService("oauth", [], Oauth, true);


//start dataBase service and oauth
container.callAllServicesWithAutoInit();