true-di

Zero Dependency, Minimalistic Type-Safe DI Container for TypeScript and JavaScript projects

Installation

npm i --save true-di

yarn add true-di

Documentation

Read Documentation on Git Book

Usage Example:

• Live Demo on Sandbox
• Example Source Code

./src/container.ts

import diContainer from 'true-di';
import { ILogger, IDataSourceService, IECommerceService } from './interfaces';
import Logger from './Logger';
import DataSourceService from './DataSourceService';
import ECommerceService from './ECommerceService';

type IServices = {
  logger: ILogger,
  dataSourceService: IDataSourceService,
  ecommerceService: IECommerceService,
}

export default diContainer<IServices>({
  logger: () =>
    new Logger(),

  dataSourceService: ({ logger }) =>
    new DataSourceService(logger),

  ecommerceService: ({ logger, dataSourceService }) =>
    new ECommerceService(logger, dataSourceService),
});

./src/ECommerceService/index.ts

import {
  IECommerceService, IDataSourceService, Order, IInfoLogger
} from '../interfaces';

class ECommerceSerive implements IECommerceService {
  constructor(
    private readonly _logger: IInfoLogger,
    private readonly _dataSourceService: IDataSourceService,
  ) {
    _logger.info('ECommerceService has been created');
  }

  async getOrders(): Promise<Order[]> {
    const { _logger, _dataSourceService } = this;
    // do something
  }

  async getOrderById(id: string): Promise<Order | null> {
    const { _logger, _dataSourceService } = this;
    // do something
  }
}

export default ECommerceSerive;

./src/controller.ts

import { Request, Response, NextFunction as Next } from 'express';
import { IGetOrderById, IGetOrders } from './interfaces';
import { sendJson } from './utils/sendJson';
import { expectFound } from './utils/NotFoundError';

export const getOrders = (req: Request, res: Response, next: Next) =>
  ({ ecommerceService }: { ecommerceService: IGetOrders }) =>
    ecommerceService
      .getOrders()
      .then(sendJson(res), next);

export const getOrderById = ({ params }: Request<{ id: string }>, res: Response, next: Next) =>
  ({ ecommerceService }: { ecommerceService: IGetOrderById }) =>
    ecommerceService
      .getOrderById(params.id)
      .then(expectFound(`Order(${params.id})`))
      .then(sendJson(res), next);

./src/index.ts

import express from 'express';
import createContext from 'express-async-context';
import container from './container';
import { getOrderById, getOrders } from './controller';
import { handleErrors } from './middlewares';

const app = express();
const Context = createContext(() => container);

app.use(Context.provider);

app.get('/orders', Context.consumer(getOrders));
app.get('/orders/:id', Context.consumer(getOrderById));

app.use(Context.consumer(handleErrors));

app.listen(8080, () => {
  console.log('Server is listening on port: 8080');
  console.log('Follow: http://localhost:8080/orders');
});

Motivation

true-di is designed to be used with Apollo Server considering to make resolvers as thin as possible, to keep all business logic testable and framework agnostic by strictly following S.O.L.I.D Principles.

Despite the origin motivation being related to Apollo Server the library could be used with any other framework or library that supports injection through the context.

The Getting Started Example shows how to use true-di with one of the most popular nodejs libraries: Express. Almost all code in the example (~95%) is covered with tests that prove your business logic could be easily decoupled and kept independent even from dependency injection mechanism.

Thanking to business logic does not depend on specific injection mechanism you can defer the choice of framework. Such deferring is suggested by Robert Martin:

The purpose of a good architecture is to defer decisions, delay decisions. The job of an architect is not to make decisions, the job of an architect is to build a structure that allows decisions to be delayed as long as possible.

© 2014, Robert C. Martin: Clean Architecture and Design, NDC Conference,

Summarizing, true-di is based on:

• emulattion of a plain object that allows to specify exact type for each item and makes strict static type checking possible
• explicit dependency injection for business logic (see example: ./src/container.ts)
• transperent injection through the context for framework-integrated components (see example: ./src/index.ts)

Some useful facts about true-di?

1. No syntatic decorators (annotations) as well as reflect-metadata are needed
2. diContainer uses getters under the hood. Container doesn't create an item until your code requests
3. Constructor-injection of cyclic dependency raises an exception
4. The property-, setter- dependency injects is also supported (what allows to resolve cyclic dependencies)
5. diContainer-s could be composed
6. Symbolic names are also supported for items