Dependency injection basics in NestJS - Step-by-Step Execution

Concept Flow - Dependency injection basics

Define Service Class

↓

Register Service in Module

↓

Inject Service into Consumer

↓

Use Service Methods

↓

NestJS Provides Instance Automatically

This flow shows how a service is created, registered, injected, and used automatically by NestJS.

Execution Sample

NestJS

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

@Injectable()
export class CatsService {
  getCats() { return ['Tom', 'Jerry']; }
}

Defines a simple service class that NestJS can inject where needed.

Execution Table

Step	Action	Evaluation	Result
1	Define CatsService with @Injectable()	NestJS marks it as injectable	CatsService class ready for injection
2	Register CatsService in AppModule providers	NestJS adds it to the container	CatsService instance managed by NestJS
3	Inject CatsService into CatsController constructor	NestJS finds provider and injects instance	CatsController has CatsService instance
4	Call catsService.getCats() in controller method	Method returns ['Tom', 'Jerry']	Controller returns cat list
5	Request handled with injected service data	Response sent with cat names	Execution complete

💡 All steps complete; service injected and used successfully

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
CatsService	undefined	Defined class with method	Registered in container	Instance injected in controller	Method called returns array	Instance used to respond

Key Moments - 3 Insights

Why do we add @Injectable() to the service class?

Because @Injectable() tells NestJS this class can be managed and injected. Without it, NestJS won't create or inject the service (see execution_table step 1).

How does NestJS know which instance to inject?

NestJS uses the providers registered in the module to find the matching class and injects the same instance wherever needed (see execution_table step 2 and 3).

What happens if we forget to register the service in the module?

NestJS will throw an error because it can't find the provider to inject (missing step 2 in execution_table).

Visual Quiz - 3 Questions

Look at the execution_table, what is the result after step 3?

A CatsController has CatsService instance

B CatsService method returns array

C CatsService class is undefined

D Request handled with cat names

💡 Hint

Check the 'Result' column in step 3 of execution_table

At which step does NestJS register the service in its container?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look for 'Registered in container' in the 'Result' column

If we remove @Injectable() from CatsService, what will happen?

A NestJS will still inject the service

B Service methods will return empty arrays

C NestJS will throw an error at injection

D Nothing changes

💡 Hint

Refer to key_moments about the role of @Injectable() and execution_table step 1

Concept Snapshot

Dependency Injection in NestJS:
- Mark classes with @Injectable() to make them injectable.
- Register services in module providers.
- Inject services via constructor in consumers.
- NestJS creates and shares instances automatically.
- Enables easy reuse and testing.

Full Transcript

Dependency injection in NestJS means creating service classes marked with @Injectable(), registering them in a module's providers array, and then injecting them into other classes like controllers via constructor parameters. NestJS automatically creates and shares instances of these services. This process helps organize code and makes it easy to reuse and test. The execution flow starts with defining the service, registering it, injecting it, and finally using its methods to handle requests.