Dependency injection in Node.js with TypeDI

Dependency injection is an important idea in object-oriented programming. It’s a option to decouple the creation of objects from their utilization. On this article, we’ll study what dependency injection is and the way we are able to use it in Node.js functions utilizing the TypeDI library.

To leap forward:

Dependency injection

Dependency injection is a design sample that permits us to inject dependencies into a category as an alternative of making the dependency occasion inside the category.

Dependency injection may also help us:

• Write versatile courses
• Simply take a look at our code
• Cut back the quantity of boilerplate code
• Enhance the readability of our code

So, it’s clear why dependency injection is an effective factor in your utility, however how can we do it?

First, let’s take a look at what ache level dependency injections remedy.

Consider a normal API that returns a listing of customers. The request circulate has three steps:

1. The request will come to the Controller, which handles all of the routing
2. The Controller will name the Service, which handles all of the enterprise logic
3. The Service will name the Repository, which handles all of the database calls

UserController -> UserService -> UserRepository

So the Controller will depend on the Service, and the Service will depend on the Repository. This can be a typical dependency circulate in a Node.js utility.

If we take a look at the code, we are able to see that the Controller creates the occasion of UserService, and the Service creates the occasion of Repository.

The service class will look one thing like this:

import { UserRepository } from "./UserRepository";

export class UserService {
  userRepo: UserRepository;

  constructor() {
    this.userRepo = new UserRepository();
  }

  getUserData = () => {
    this.userRepo.getAll();
  };
}

And the controller will look one thing like this:

import { UserService } from "./UserService";

export class UserController {
  userService: UserService;

  constructor() {
    this.userService = new UserService();
  }

  getUserData = () => {
    this.userService.getUserData();
  };
}

Now, if we need to use the UserService class, we must create the occasion of UserRepository contained in the UserService class.

Creating one class occasion inside one other isn’t apply as a result of now, these two courses (i.e., UserRepository and UserService) have tight coupling.

Say we need to take a look at our UserService class. Do we would like our take a look at code to work together with the precise database?

No — we need to mock the database calls and take a look at our UserService class. In any other case:

• We must create a take a look at database
• Our take a look at suite will rely upon the database. So if one thing breaks within the database, your take a look at suite may even break
• The take a look at suite can be very gradual

So we want a option to inject the occasion of UserRepository into the UserService class. That is the place dependency injection comes into play.

Attaining dependency injection with containers

The most typical option to obtain dependency injection is to make use of a dependency injection container.

We will create a worldwide container object that can maintain all of the situations of the dependencies, and we are able to inject the dependencies into the category.

The most typical option to inject the dependencies is to make use of the constructor. We will use the constructor of our UserService class to inject the occasion of the UserRepository class.

Our UserService class will look one thing like this:

import { UserRepository } from "./UserRepository";

export class UserService {
  userRepo: UserRepository;

  constructor(userRepo: UserRepository) {
    this.userRepo = userRepo;
  }

  getUserData = () => {
    this.userRepo.getAll();
  };
}

Now we are able to go the occasion of UserRepository to the UserService class. And guess what?

Once we are testing the UserService class, we are able to go the mock occasion of UserRepository to the UserService class and take a look at it:

import { UserService } from "./UserService";
import { UserRepository } from "./UserRepository";

const mockUserRepo = {
  getAll: jest.fn(),
};

const userService = new UserService(mockUserRepo);

userService.getUserData();

anticipate(mockUserRepo.getAll).toHaveBeenCalled();

We nonetheless need to create the occasion of the UserRepository class and inject it into the UserService class, which we’ll need to do every time we need to use the UserService class. However we don’t need to do that each time — simply as soon as.

Let’s see how we are able to obtain this.

Utilizing TypeDI to realize dependency injection in Node.js

There are a number of methods to realize dependency injection in Node.js. We will create our dependency container, create the situations ourselves, or inject them into the runtime.

However there’s a higher option to obtain dependency injection in Node. It’s by utilizing a library known as TypeDI, which helps a number of DI containers, could be very versatile and speedy, and is easy to make use of.

There are another common choices for dependency injection, like inversify and awilix, however I discovered TypeDI to be a lot cleaner than the others.

Starter undertaking

You possibly can skip this step if you have already got an current Categorical undertaking. In any other case, you may construct a boilerplate undertaking with Categorical.js and TypeScript utilizing the next command.

git clone https://github.com/Mohammad-Faisal/express-typescript-skeleton-boilerplate

To get began, let’s first set up the dependency inside our Node utility.

npm set up typedi reflect-metadata

Then, modify our tsconfig.json file to correctly work with the typedi. Add the next three choices below the compilerOptions:

"experimentalDecorators": true,
"emitDecoratorMetadata": true,
"strictPropertyInitialization": false // this one is for stopping the typescript 
                                         errors whereas utilizing @Inject()

Now, import reflect-metadata firstly of our utility, like the next, contained in the index.ts file:

import "reflect-metadata";

It will remedy the reflect-metadata shim is required when utilizing class decorators error.

There are a number of methods to make use of TypeDI primarily based on the use case. Let’s see a number of of them.

Get from a worldwide container

We will get the occasion of UserRepository from the worldwide container. That is the direct use of TypeDI:

import { UserRepository } from "./UserRepository";
import { Service, Inject, Container } from "typedi";

@Service()
export class UserService {
  getUserData = () => {
    const userRepo = Container.get(UserRepository);
    userRepo.getAll();
  };
}

However you could mark the UserRepository class with the @Service() decorator. In any other case, you’ll get an error:

import { Service } from "typedi";

@Service()
export class UserRepository {
  getAll = () => {
    console.log("Getting all of the customers");
  };
}

Chances are you’ll surprise why we’re utilizing the @Service() decorator right here.

The @Service() decorator is used to register the UserRepository as a service within the international container in order that we are able to get the occasion of UserRepository from the worldwide container.

Now, after we name the Container.get(UserRepository), it is going to return the occasion of the UserRepository class.

Inject the occasion of UserRepository

We will additionally inject the occasion of UserRepository into the UserService class utilizing the @Inject() decorator:

import { UserRepository } from "./UserRepository";
import { Service, Inject, Container } from "typedi";

@Service()
export class UserService {
  @Inject()   // <- discover right here
  userRepo: UserRepository;

  getUserData = () => {
    this.userRepo.getAll();
  };
}

Now we don’t have to make use of the Container.get(UserRepository) to get the occasion of the UserRepository class. We will instantly use the this.userRepo to entry the occasion of the UserRepository class.

Inject the dependency utilizing the constructor

We will inject the dependency utilizing the constructor of the category:

import { UserRepository } from "./UserRepository";
import { Service, Inject } from "typedi";

@Service()
export class UserService {
  userRepo: UserRepository;

  constructor(@Inject() userRepo: UserRepository) {
    this.userRepo = userRepo;
  }

  logUserData = () => {
    this.userRepo.someFunction();
  };
}

This can be a quite common option to inject dependency into the category. It follows the dependency injection sample.

And that’s the way you implement the dependency injection in Node.js utilizing TypeDI.

Different advantages of TypeDI

There are different advantages of utilizing the TypeDI library. We will use the Container class to set international variables throughout the applying.

First, we should set the variable we have to entry throughout the applying:

import 'reflect-metadata';
import { Container, Token } from 'typedi';

export const SOME_GLOBAL_CONFIG_VALUE = new Token<string>('SOME_CONFIG');
Container.set(SOME_GLOBAL_CONFIG_VALUE, 'very-secret-value');

Now, if we want this worth wherever within the utility, we are able to use the next piece of code:

import { Container, Token } from 'typedi';

const MY_SECRET = Container.get(SOME_GLOBAL_CONFIG_VALUE);

That is additionally very type-safe, as a result of the Tokens are typed.

How cool is that?

Conclusion

Thanks for studying this far. At the moment I demonstrated what dependency injection is within the context of a Node.js utility. We additionally discovered to make use of the TypeDI library to realize dependency injection in a sensible undertaking. For extra info, try the TypeDI documentation and the GitHub repository for this undertaking.

I hope you discovered one thing new right this moment. Have an amazing remainder of your day!