Hey everyone! If you’ve worked with Nest.js, you know it’s one of the most powerful and developer-friendly frameworks for building scalable Node.js applications. One of its standout features is its built-in support for Dependency Injection (DI). But what exactly is DI, and how can you master it to build cleaner, more maintainable code? Let’s dive in and explore this concept in depth.

What is Dependency Injection?

At its core, Dependency Injection is a design pattern that helps you write more modular and testable code. Instead of hardcoding dependencies inside a class, you “inject” them from the outside. This makes your code more flexible, reusable, and easier to test.

For example, imagine you have a UserService that needs a DatabaseService to fetch user data. Instead of creating an instance of DatabaseService inside UserService, you inject it as a dependency. This way, you can easily swap out DatabaseService with a mock object for testing or use a different implementation in the future.

Why Dependency Injection in Nest.js?

Nest.js takes DI to the next level by providing a built-in DI container. This container manages the creation and injection of dependencies automatically, so you don’t have to worry about the nitty-gritty details. It’s one of the reasons Nest.js feels so much like Angular—it’s heavily inspired by Angular’s DI system.

With Nest.js, you can focus on writing business logic while the framework handles the plumbing. Let’s see how this works in practice.

How Dependency Injection Works in Nest.js

1. Providers: The Building Blocks

In Nest.js, dependencies are defined as providers. A provider can be a service, repository, factory, or even a value. To create a provider, you use the @Injectable() decorator. Here’s an example:

Typescript copy

import { Injectable } from ’@nestjs/common’;

@Injectable()

export class UserService {

  constructor(private readonly databaseService: DatabaseService) {}

  async getUser(id: string) {

    return this.databaseService.findUser(id);
  }
}

In this example, UserService depends on DatabaseService. Nest.js will automatically inject an instance of DatabaseService when it creates UserService.

2. Registering Providers

To make a provider available for injection, you need to register it in a module. This is done in the providers array of the module:

Typescript copy

import { Module } from ’@nestjs/common’;

import { UserService } from ’./user.service’;

import { DatabaseService } from ’./database.service’;

@Module({

  providers: [UserService, DatabaseService],

})

export class UserModule {}

Now, UserService and DatabaseService are part of the DI container and can be injected wherever needed.

3. Injecting Dependencies

Once a provider is registered, you can inject it into other classes using the constructor or property-based injection. Constructor injection is the most common approach:

Typescript copy

@Controller(’users’)

export class UserController {

  constructor(private readonly userService: UserService) {}

  @Get(’:id’)

  async getUser(@Param(’id’) id: string) {

    return this.userService.getUser(id);

  }
}

Here, UserController depends on UserService, and Nest.js automatically injects it.

Advanced Dependency Injection Techniques

Now that we’ve covered the basics, let’s explore some advanced DI techniques in Nest.js.

1. Custom Providers

Sometimes, you need more control over how a dependency is created. For example, you might want to use a factory function or a specific instance. Nest.js allows you to define custom providers for these scenarios:

Typescript copy

const customProvider = {

  provide: ’CUSTOM_DATABASE’,

  useFactory: () => {

    return new CustomDatabaseService();

  },

};

@Module({

  providers: [customProvider],

})

export class CustomModule {}

You can then inject this custom provider using the @Inject() decorator:

Typescript copy

@Injectable()

export class UserService {

  constructor(@Inject(’CUSTOM_DATABASE’) private readonly databaseService: DatabaseService) {}

}

2. Scoped Providers

By default, providers in Nest.js are singletons, meaning the same instance is shared across the application. However, you can change this behavior by setting the scope:

Typescript copy

@Injectable({ scope: Scope.REQUEST })

export class RequestScopedService {}

This creates a new instance of the provider for each incoming request. Other scopes include Scope.TRANSIENT (new instance for each injection) and Scope.DEFAULT (singleton).

3. Circular Dependencies

Sometimes, two classes depend on each other, creating a circular dependency. Nest.js provides a way to resolve this using the forwardRef() function:

Typescript copy

@Injectable()

export class ServiceA {

  constructor(@Inject(forwardRef(() => ServiceB)) private readonly serviceB: ServiceB) {}

}

@Injectable()

export class ServiceB {

  constructor(@Inject(forwardRef(() => ServiceA)) private readonly serviceA: ServiceA) {}

}

This ensures both classes are properly instantiated.

Testing with Dependency Injection

One of the biggest advantages of DI is that it makes your code easier to test. You can easily mock dependencies and inject them into your classes during testing. Here’s an example using Jest:

Typescript copy

const mockDatabaseService = {

  findUser: jest.fn().mockResolvedValue({ id: ’1’, name: ’John Doe’ }),

};

describe(’UserService’, () => {

  let userService: UserService;

  beforeEach(async () => {

    const module = await Test.createTestingModule({

      providers: [

        UserService,

        { provide: DatabaseService, useValue: mockDatabaseService },

      ],

    }).compile();

    userService = module.get<UserService>(UserService);

  });

  it(’should return a user’, async () => {

    const user = await userService.getUser(’1’);

    expect(user).toEqual({ id: ’1’, name: ’John Doe’ });

  });

});

Best Practices for Dependency Injection

To make the most of DI in Nest.js, follow these best practices:

1. Keep Constructors Simple: Only inject what you need. Avoid injecting too many dependencies into a single class.
2. Use Interfaces for Abstraction: Define interfaces for your services to make them easier to mock and swap out.
3. Leverage Custom Providers: Use factories, values, and classes to handle complex dependency creation.
4. Avoid Circular Dependencies: Refactor your code to minimize circular dependencies, but use forwardRef() when necessary.
5. Test with Mocks: Take advantage of DI to write unit tests with mocked dependencies.

Conclusion

Dependency Injection is one of the most powerful features of Nest.js. It helps you write clean, modular, and testable code while reducing coupling between components. By mastering DI, you can take full advantage of Nest.js’s capabilities and build scalable, maintainable applications.

Whether you’re building a small API or a large enterprise application, understanding DI will make you a better Nest.js developer. So go ahead, experiment with providers, scopes, and custom injections and see how DI can transform your codebase!

What’s your experience with Dependency Injection in Nest.js? Have you run into any challenges or discovered any cool tricks? Let me know in the comments below I’d love to hear your thoughts