Understanding Dependency Injection in NestJS: A Practical Guide - Part 1

Dependency Injection (DI) is a fundamental concept in NestJS that can greatly improve your application’s architecture. In this article, I’ll walk you through what DI is, why it matters, and how to implement it effectively using a practical example.

What is Dependency Injection?

Dependency Injection is a design pattern where a class receives its dependencies from external sources rather than creating them itself. In simpler terms, instead of a class creating the objects it needs, those objects are “injected” from outside.

Benefits of using DI include:

• Decoupling: Classes are less dependent on specific implementations
• Testability: Dependencies can be easily mocked during testing
• Reusability: Services can be shared across different parts of your application
• Maintainability: Changes to one part of your application affect fewer other parts

Our Example Project: Modeling a Computer

To understand how dependency injection works in NestJS, we’ll build a simple project that models a computer with different components:

1. Power Module: Supplies power to other components
2. CPU Module: Processes data, requires power to work
3. Disk Module: Stores data, also requires power
4. Computer Module: The main module that uses both CPU and disk

Each component is represented by its own module with corresponding services (or controllers). The dependencies flow as shown in the diagram above.

Getting Started

Let’s begin by setting up our project:

# Create a new NestJS project
nest new di-example

# Generate the modules
nest g module computer
nest g module cpu
nest g module disk
nest g module power

# Generate services and controller
nest g service cpu
nest g service disk
nest g service power
nest g controller computer

After generating these files, we need to update our main.ts to use our Computer module as the root:

import { NestFactory } from '@nestjs/core';
import { ComputerModule } from './computer/computer.module';

async function bootstrap() {
  const app = await NestFactory.create(ComputerModule);
  await app.listen(3000);
}
bootstrap();

Understanding NestJS Modules

Before diving into dependency injection across modules, let’s clarify what NestJS modules are:

A module in NestJS is a class annotated with the @Module() decorator. This decorator provides metadata that NestJS uses to organize the application structure.

Each module has several properties:

• providers: Services that will be instantiated by the NestJS injector
• controllers: Controllers that need to be instantiated
• imports: List of imported modules that export providers needed in this module
• exports: Providers that should be available for modules that import this module

By default, providers created within a module are private - they can only be used within that module unless explicitly exported.

Implementing the Power Module

Let’s start with our “bottom-up” approach by implementing the foundational Power module:

// power/power.service.ts
import { Injectable } from '@nestjs/common';

@Injectable()
export class PowerService {
  supplyPower(watts: number) {
    console.log(`Supplying ${watts} watts of power`);
    return watts;
  }
}

Now, we need to make this service available to other modules by modifying the Power module:

// power/power.module.ts
import { Module } from '@nestjs/common';
import { PowerService } from './power.service';

@Module({
  providers: [PowerService],
  exports: [PowerService] // This makes PowerService available to other modules
})
export class PowerModule {}

The exports array is crucial here - it explicitly tells NestJS which providers from this module should be available for injection in other modules that import this one.

Dependency Injection Between Modules: The Three-Step Process

When sharing services between different modules in NestJS, you need to follow these three steps:

1. Export the service from its module: Add the service to the exports array in its module
2. Import the module in the target module: Add the source module to the imports array in the target module
3. Inject the service: Use constructor injection in the target service/controller

Let’s see this in action by connecting our modules together.

Part 1: Conclusion

In this first part of our series on Dependency Injection in NestJS, we’ve covered:

• The concept of Dependency Injection and its benefits
• Project setup and module generation
• How NestJS modules work
• Building our first module and understanding exports

In the next article, we’ll implement the CPU and Disk modules that depend on the Power module, and see how Dependency Injection works across modules in practice.

GitHub Repository: https://github.com/mfenerich/nest-di

See you in the Part II.