typedi

What is typedi?

TypeDI is a dependency injection tool for TypeScript and JavaScript. It allows you to manage the lifecycle and dependencies of your services and components in a clean and efficient way.

What are typedi's main functionalities?

Service Decorator

The `@Service` decorator is used to mark a class as a service that can be injected. The `Container.get` method is then used to retrieve an instance of the service.

```typescript
import { Service } from 'typedi';

@Service()
class ExampleService {
  sayHello() {
    return 'Hello, World!';
  }
}

const exampleService = Container.get(ExampleService);
console.log(exampleService.sayHello()); // Output: Hello, World!
```

Inject Decorator

The `@Inject` decorator is used to inject a dependency into a class. In this example, `DependencyService` is injected into `MainService`.

```typescript
import { Service, Inject } from 'typedi';

@Service()
class DependencyService {
  getValue() {
    return 'Dependency Value';
  }
}

@Service()
class MainService {
  constructor(@Inject(() => DependencyService) private dependencyService: DependencyService) {}

  getValue() {
    return this.dependencyService.getValue();
  }
}

const mainService = Container.get(MainService);
console.log(mainService.getValue()); // Output: Dependency Value
```

Container

The `Container` class is used to manage the lifecycle of services. You can manually set and get instances of services using `Container.set` and `Container.get`.

```typescript
import { Container } from 'typedi';

class ExampleService {
  sayHello() {
    return 'Hello, World!';
  }
}

Container.set(ExampleService, new ExampleService());
const exampleService = Container.get(ExampleService);
console.log(exampleService.sayHello()); // Output: Hello, World!
```

Other packages similar to typedi

inversify

Inversify is a powerful and flexible inversion of control (IoC) container for JavaScript and TypeScript. It provides a similar feature set to TypeDI, including decorators for services and dependency injection. Inversify is known for its extensive documentation and strong community support.

tsyringe

TSyringe is a lightweight dependency injection container for TypeScript. It offers a similar decorator-based API for defining and injecting services. TSyringe is designed to be simple and easy to use, making it a good choice for smaller projects or those new to dependency injection.

awilix

Awilix is a dependency injection container for JavaScript and TypeScript that focuses on developer experience and ease of use. It provides a fluent API for defining and resolving dependencies, and supports both class-based and function-based services. Awilix is known for its flexibility and ease of integration with various frameworks.

README

TypeDI

TypeDI is a dependency injection tool for TypeScript and JavaScript. With it you can build well-structured and easily testable applications in Node or in the browser.

Main features includes:

• property based injection
• constructor based injection
• singleton and transient services
• support for multiple DI containers

Installation

Note: This installation guide is for usage with TypeScript, if you wish to use TypeDI without Typescript please read the documentation about how get started.

To start using TypeDI install the required packages via NPM:

npm install typedi reflect-metadata

Import the reflect-metadata package at the first line of your application:

import 'reflect-metadata';

// Your other imports and initialization code
// comes here after you imported the reflect-metadata package!

As a last step, you need to enable emitting decorator metadata in your Typescript config. Add these two lines to your tsconfig.json file under the compilerOptions key:

"emitDecoratorMetadata": true,
"experimentalDecorators": true,

Now you are ready to use TypeDI with Typescript!

Basic Usage

import { Container, Service } from 'typedi';

@Service()
class ExampleInjectedService {
  printMessage() {
    console.log('I am alive!');
  }
}

@Service()
class ExampleService {
  constructor(
    // because we annotated ExampleInjectedService with the @Service()
    // decorator TypeDI will automatically inject an instance of
    // ExampleInjectedService here when the ExampleService class is requested
    // from TypeDI.
    private injectedService: ExampleInjectedService
  ) {}
}

const serviceInstance = Container.get(ExampleService);
// we request an instance of ExampleService from TypeDI

serviceInstance.injectedService.printMessage();
// logs "I am alive!" to the console

Documentation

The detailed usage guide and API documentation for the project can be found:

• at docs.typestack.community/typedi
• in the ./docs folder of the repository

Contributing

Please read our contributing guidelines to get started.

Changelog

0.9.1 - 2021.01.11

Fixed

• correctly export error classes from package root