1. Allow JavaScript developers to write code that adheres to the SOLID principles.
2. Facilitate and encourage the adherence to the best OOP and IoC practices.
3. Add as little runtime overhead as possible.
4. Provide a state of the art development experience.

$ npm install -g [email protected] 

$ node -v $ tsc -v 

$ mkdir inversify-nodejs-demo $ cd inversify-nodejs-demo $ npm init --yes 

$ npm install --save [email protected] $ npm install --save [email protected] 

$ tsc -init 

{ "compilerOptions": { "lib": ["es6"], "module": "commonjs", "target": "es5", "experimentalDecorators": true, "emitDecoratorMetadata": true } } 

$ touch index.ts 

import "reflect-metadata"; import { interfaces, injectable, inject, Container } from "inversify"; // 1. Declare interfaces interface Warrior { fight(): string; sneak(): string; } interface Weapon { hit(): string; } interface ThrowableWeapon { throw(): string; } // 2. Declare types const TYPES = { Warrior: Symbol("Warrior"), Weapon: Symbol("Weapon"), ThrowableWeapon: Symbol("ThrowableWeapon") }; // 3. Declare classes @injectable() class Katana implements Weapon { public hit() { return "cut!"; } } @injectable() class Shuriken implements ThrowableWeapon { public throw() { return "hit!"; } } @injectable() class Ninja implements Warrior { private _katana: Weapon; private _shuriken: ThrowableWeapon; public constructor( @inject(TYPES.Weapon) katana: Weapon, @inject(TYPES.ThrowableWeapon) shuriken: ThrowableWeapon ) { this._katana = katana; this._shuriken = shuriken; } public fight() { return this._katana.hit(); }; public sneak() { return this._shuriken.throw(); }; } // 4. Create instance of Container & declare type bindings const myContainer = new Container(); myContainer.bind<Warrior>(TYPES.Warrior).to(Ninja); myContainer.bind<Weapon>(TYPES.Weapon).to(Katana); myContainer.bind<ThrowableWeapon>(TYPES.ThrowableWeapon).to(Shuriken); // 5. Resolve Warrior type const ninja = myContainer.get<Warrior>(TYPES.Warrior); // 6. Check “Katana” and “Shuriken” has been injected into “Ninja” console.log(ninja.fight()); // "cut!" console.log(ninja.sneak()); // "hit!" 

1. Import the required dependencies “reflect-metadata” and “inversify”.
2. Declare some interfaces and some types. Types are unique identifiers used to represent interfaces at runtime. We need these unique identifiers because TypeScript is compiled into JavaScript and JavaScript does not have support for static types like interfaces. We use types to identify which types need to be injected into a class.
3. Declare some classes that implement the interfaces that we previously declared. These classes will be instantiated by the IoC container and for that reasons they require to be decorated using the “@injectable” decorator. We also need to use the “@inject” decorator to indicate which types need to be injected into a class.
4. Declare an instance of the “Container” class and then declares some type bindings. A type binding is a dictionary entry that links an abstraction (type) with an implementation (concrete class).
5. Use the IoC container instance previously declared to resolve the “Warrior” type. We declared a type binding between the “Warrior” type and the “Ninja” class so we can expect the IoC container to return an instance of the “Ninja” class. Because the “Ninja” class has a dependency on the “Weapon” and “ThrowableWapon” types and we declared some bindings for those types we can expect instances of the “Katana” and “Shuriken” classes to be instantiated and injected into the “Ninja” class.
6. Use the “log” method from the “console” object to check that instances of the Katana” and “Shuriken” has been correctly injected into the “Ninja” instance.

$ tsc -p tsconfig.json 

$ node index.js 

cut! hit! 

import * as express from "express"; import { response, requestParams, controller, httpGet, httpPost, httpPut } from "inversify-express-utils"; import { injectable, inject } from "inversify"; import { interfaces } from "./interfaces"; import { Type } from "./types"; import { authorize } from "./middleware"; import { Feature } from "./features"; @injectable() @controller( "/api/user" authorize({ feature: Feature.UserManagement }) ) class UserController { @inject(Type.UserRepository) private readonly _userRepository: interfaces.UserRepository; @inject(Type.Logger) private readonly _logger: interfaces.Logger; @httpGet("/") public async get( @request() req: express.Request, @response() res: express.Response ) { try { this._logger.info(`HTTP ${req.method} ${req.url}`); return await this._userRepository.readAll(); } catch (e) { this._logger.error(`HTTP ERROR ${req.method} ${req.url}`, e); res.status(500).json([]); } } @httpGet("/:email") public async getByEmail( @requestParams("email") email: string, @request() req: express.Request, @response() res: express.Response ) { try { this._logger.info(`HTTP ${req.method} ${req.url}`); return await this._userRepository.readAll({ where: { email: email } }); } catch (e) { this._logger.error(`HTTP ERROR ${req.method} ${req.url}`, e); res.status(500).json([]); } } } 

• inversify-binding-decorators
• inversify-inject-decorators
• inversify-express-utils
• inversify-restify-utils
• inversify-vanillajs-helpers
• inversify-tracer
• inversify-logger-middleware
• inversify-devtools (WIP)
• inversify-express-doc

• The official InversifyJS repository
• InversifyJS on Twitter
• Remo H. Jansen on Twitter

Note: This post was originally posted at https://dev.to/remojansen/dependency-injection-in-typescript-applications-powered-by-inversifyjs