This is a lightweight zero-dependency library for a service container written in TypeScript.

• Fully typed
• 100 % TypeScript
• 100 % Test coverage
• 0 Dependencies
• < 2 KB Package size
• Typescript Decorator support
• Simple API
• Works beautiful with jest-mock-extended

In this StackBlitz-Demo you can see a demonstration of the ioc-service-container. In the App.tsx you can verify that the UserService is fully typed without importing the class.

Install the dependency with npm install ioc-service-container

If you use the ioc-service-container in a TypeScript project, define the types of your services in a ioc.d.ts file otherwise you can skip this step.

// Import your services
import { TestApi } from '../your-path/to/TestApi';
import { FooApi } from '../your-path/to/FooApi';
import { TestService } from '../your-path/to/TestService';

// Create the mapping between ServiceId and Service
type IoCTypes = {
  TestApi: TestApi;
  FooApi: FooApi;
  TestService: TestService;
  myString: string;
  // ...
};

// Redeclare the scg function to get full Typscript support
declare module 'ioc-service-container' {
  export function scg<T extends keyof IoCTypes, U extends IoCTypes[T]>(id: T): U;
}

According to this you have to pass a factory, a constructable or an entity to the ioc container. So at the initial script of your application you call a function named e.g. setupService:

import { ServiceContainer } from 'ioc-service-container';

function setupService() {
  ServiceContainer.set('TestApi', CustomTestApi); // setup by class reference
  ServiceContainer.set('FooApi', () => new CustomFooApi()); // setup by custom factory

  const testService = new TestService();
  ServiceContainer.set('TestService', testService); // pass the instance directly
  ServiceContainer.set('myString', 'hello world'); // pass primitive values
}

The factory is only instantiated at need.

Now you have 2 options to inject the requested service.

The first is the most common one: const testApi = scg('TestApi);. (Shortcut for ServiceContainer.get(). Because of the type declaration you have full TypeScript support at this point and no dependency on the file/class TestApi. (See the Demo)

This requires "experimentalDecorators": true to be enabled in your tsconfig.json (See Typescript Docs)

export class CustomTestService implements TestService {
  @inject
  private readonly customApi!: Api; // Important is the name of the property, it's mapped to the service id

  @inject('FooApi') // If you don't want to name your property like the service id, pass the id as parameter
  private readonly nameThisHowYouWant!: Api;

  private readonly fooApi = ServiceContainer.get<Api>('FooApi'); // Use this syntax if you don't want to use decorators

  private readonly barApi = scg('BarApi'); // Shortcut for ServiceContainer.get()
}

For Testing or similar use cases you have the option to use ServiceContainer.isSet('anId'), ServiceContainer.override('anId', 123) or ServiceContainer.reset().

Structuring your code and avoiding implizit dependencies is two of the most effective ways to avoiding bugs, especially when code gets extended. To goal of Dependency Injection (DI) is to prevent structures like this:

class CustomService {
  constructor() {
    this.api = new CustomApi();
  }
}

The CustomService has an implizit dependency to the CustomApi.

The goal of DI is to encapsulate the dependencies of a class. The CustomService should work without knowing which api it is using.