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

In the previous article, we set up our project and learned about the fundamentals of Dependency Injection in NestJS. Now, let’s continue by implementing modules that depend on each other, focusing on how to properly inject services across module boundaries.

Implementing the CPU Module

Our CPU module needs access to the Power module’s services. Let’s implement this relationship:

Step 1: Import the Power Module

First, we need to import the Power module into our CPU module:

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

@Module({
  imports: [PowerModule], // This gives access to exported providers from PowerModule
  providers: [CpuService],
  exports: [CpuService]  // Making CpuService available to other modules
})
export class CpuModule {}

Step 2: Inject the Power Service into CPU Service

Now, we can use the PowerService in our CpuService:

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

@Injectable()
export class CpuService {
  constructor(private powerService: PowerService) {}

  compute(a: number, b: number) {
    console.log('Drawing 10 watts of power from PowerService');
    this.powerService.supplyPower(10);
    return a + b;
  }
}

Note how we’ve injected the PowerService through the constructor. NestJS’s Dependency Injection system will automatically create an instance of PowerService and provide it to our CpuService.

Implementing the Disk Module

Similarly, our Disk module also needs power. Let’s implement it following the same pattern:

Step 1: Import the Power Module into Disk Module

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

@Module({
  imports: [PowerModule],
  providers: [DiskService],
  exports: [DiskService]
})
export class DiskModule {}

Step 2: Inject the Power Service into Disk Service

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

@Injectable()
export class DiskService {
  constructor(private powerService: PowerService) {}

  getData() {
    console.log('Drawing 20 watts of power from PowerService');
    this.powerService.supplyPower(20);
    return 'data';
  }
}

Implementing the Computer Module

Now that we have our CPU and Disk modules set up, we need to connect them to our Computer module:

Step 1: Import the CPU and Disk Modules

// computer/computer.module.ts
import { Module } from '@nestjs/common';
import { ComputerController } from './computer.controller';
import { CpuModule } from '../cpu/cpu.module';
import { DiskModule } from '../disk/disk.module';

@Module({
  imports: [CpuModule, DiskModule],
  controllers: [ComputerController]
})
export class ComputerModule {}

Step 2: Inject the CPU and Disk Services into the Computer Controller

// computer/computer.controller.ts
import { Controller, Get } from '@nestjs/common';
import { CpuService } from '../cpu/cpu.service';
import { DiskService } from '../disk/disk.service';

@Controller('computer')
export class ComputerController {
  constructor(
    private cpuService: CpuService,
    private diskService: DiskService
  ) {}

  @Get()
  run() {
    return [
      this.cpuService.compute(1, 2),
      this.diskService.getData()
    ];
  }
}

Important Note on Module Dependencies

An important point to understand: The Computer module does not need to directly import the Power module. Since both CPU and Disk modules already import the Power module, the Computer module inherits these dependencies.

This demonstrates the hierarchical nature of dependency injection in NestJS - dependencies are resolved through the module tree.

Understanding How NestJS Resolves Dependencies

Behind the scenes, NestJS creates a dependency graph to track which services depend on which other services. When a module imports another module, NestJS makes all the exported providers from the imported module available to the importing module.

When our application starts, NestJS:

Creates a dependency injection container
Resolves all dependencies in the correct order
Instantiates all the services as needed
Injects dependencies in the right places

This means that our PowerService is instantiated only once, and the same instance is injected into both the CpuService and DiskService.

Testing Our Implementation

Let’s test our implementation by running the application:

# Start the application
npm run start:dev

Now, if we navigate to http://localhost:3000/computer in our browser, we should see:

[3, "data"]

And in our console, we should see:

Drawing 10 watts of power from PowerService
Supplying 10 watts of power
Drawing 20 watts of power from PowerService
Supplying 20 watts of power

This confirms that our dependency injection is working correctly! The ComputerController successfully calls methods on both CpuService and DiskService, which in turn use the PowerService.

Best Practices for Dependency Injection in NestJS

Based on our example, here are some best practices to follow:

Keep modules focused: Each module should have a clear, single responsibility.
Export only what’s needed: Only add services to the exports array if they need to be used outside the module.
Follow the three-step process:
- Export the service from its module
- Import the module where needed
- Inject the service via constructor
Leverage the module hierarchy: Don’t import modules unnecessarily if they’re already available through the module tree.
Use private class properties: When injecting services, use the private keyword in the constructor to automatically assign the dependency to a class property.

Common Pitfalls

Forgetting to export a service: If you’re trying to inject a service but getting an error, check if the service is exported from its module.
Circular dependencies: Be careful not to create circular dependencies between modules. NestJS can handle them in certain cases, but they should generally be avoided.
Overusing providers: Not everything needs to be a provider. Consider using simple utility functions for operations that don’t require state or other dependencies.

Conclusion

Dependency Injection in NestJS provides a powerful way to structure your application with clear separation of concerns and maintainable code. By understanding how modules, providers, and the dependency injection system work together, you can create applications that are:

Easy to test
Easy to maintain
Highly modular
Well-organized

The three-step process for sharing services between modules is straightforward once you understand it, and it forms the backbone of how NestJS applications are structured.

In the next article, we’ll dive deeper into more advanced Dependency Injection concepts in NestJS, including custom providers, dynamic modules, and scoped providers.

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

Check the Part I.

In the Part III we will delve into more advanced concepts that will give you greater flexibility and control over your application’s architecture. See you there.