TiDI

Dead simple dependency injection.

Installation

npm

npm install tidi

Yarn

yarn add tidi

pnpm

pnpm add tidi

bun

bun add tidi

Why TiDI?

• It's small, ridiculously small (<600B minified)
• Designed specifically for classes, it's easy to understand and use

Getting Started

TiDI (pronounced "tie dye") is comprised of two main pieces: containers and injections. The container manage bound services and ensures services are only constructed once and used everywhere in the container. Injections allow you to use inject dependencies into your services.

The following example shows a basic example of creating a logging service and a user service where the user service depends on the logging service.

import { Container, inject, injectable } from "tidi"

const container = new Container()

@injectable("userService")
class LoggingService {}

@injectable("userService")
class UserService {
  @inject("loggingService") private loggingService: LoggingService
}

container.bind(LoggingService, UserService)

With the container created and services bound, we can now get a services from the IOC container using the get method.

const userService = container.get<UserService>("userService")

Keep in mind that the get method should only be used in the root of your application where you created your container. Services themselves should use @inject to inject other services.

Constructor Injection

In certain cases, you may need to access injected services in the constructor. To support this, you can use constructor injection.

@injectable("userService")
class UserService {
  constructor(
    @inject("loggingService") private loggingService: LoggingService,
  ) {
    this.loggingService.log("In the constructor!")
  }
}

Both injection types are supported simultaneously, so you can mix and match in the same class!

TypeScript

To use TiDI with TypeScript, You'll want to enable the following properties:

{
  "compilerOptions": {
    "experimentalDecorators": true,
    "strictPropertyInitialization": false
  }
}

Setting strictPropertyInitialization=false is not necessarily required, but it is highly recommended to prevent you from needing to type cast usages of @inject.

FAQ

Are Circular Dependencies Supported?

I really would like to support circular dependencies, but supporting them in a way that doesn't have a pile of caveats is not worth it for this library given the focus on simplicity and small size. It maybe supported in the future, but for now it is not.