Cum funcționează injectarea dependențelor în NestJS?

Question

Accepted Answer

**Injectarea dependențelor (DI)** este un patern fundamental în NestJS unde framework-ul **creează și furnizează automat** dependențele de care o clasă are nevoie, în loc ca clasa să le construiască singură. Declarați ce aveți nevoie în constructor, și NestJS o furnizează — ceea ce duce la cod cu cuplaj redus și ușor de testat.

## Cum funcționează: declarați în constructor

```ts
@Injectable()
export class UsersService {
  // declare dependencies as constructor parameters — Nest injects them
  constructor(
    private readonly db: DatabaseService,
    private readonly logger: LoggerService,
  ) {}
  // you NEVER write `new DatabaseService()` — Nest creates and provides it
}
```

Nest citește tipurile parametrilor constructorului, caută providerii corespondenți înregistrați, îi creează (dacă nu există deja) și îi transmite — rezolvând automat întregul graf de dependențe.

## Fluxul DI

```text
1. A class is marked @Injectable() → it's a provider
2. The provider is registered in a module's `providers` array
3. Another class declares it as a constructor parameter
4. NestJS's IoC container resolves and INJECTS the instance automatically
```

## Înregistrare și rezolvare

```ts
@Module({
  providers: [UsersService, DatabaseService, LoggerService],  // register all providers
  controllers: [UsersController],
})
export class UsersModule {}
// Nest's container now knows how to construct each and inject them where needed
```

## De ce DI este valoros

```text
✓ Loose coupling — classes depend on ABSTRACTIONS, not on constructing concrete deps
✓ Testability — inject MOCK dependencies in tests easily (no real DB needed)
✓ Reusability — one shared instance (singleton) used across the app
✓ Maintainability — change an implementation in one place (the module registration)
```

## Testabilitate — avantajul decisiv

```ts
// in a test, provide a fake DatabaseService — no real database required
const module = await Test.createTestingModule({
  providers: [
    UsersService,
    { provide: DatabaseService, useValue: mockDatabase },  // inject a mock
  ],
}).compile();
```

Deoarece clasa nu construiește dependențele sale, puteți substitui mock-uri pentru testare — DI face aplicațiile NestJS foarte ușor de testat.

## Injectarea valorilor non-clasă

```ts
// use injection tokens for config/values, not just classes
constructor(@Inject("CONFIG") private config: AppConfig) {}
```

## De ce conteaza

Injectarea dependențelor este paternul fundamental care susține întreaga arhitectură a NestJS — este modul în care controllerele obțin servicii, serviciile obțin depozite și alte servicii, și cum este cablată întreaga aplicație.

Înțelegerea sa este esențială deoarece aproape fiecare clasă din NestJS participă în DI: declarați dependențele în constructor și containerul IoC al framework-ului le rezolvă și le furnizează automat, eliminând instantierea manuală și cuplajul strict.

Avantajele sunt semnificative și centrale pentru motivul pentru care NestJS este valorizat: **cuplaj redus** (depinde de abstracții), **testabilitate** (injectați mock-uri în loc de dependențe reale — ceea ce ușurează testarea unitară amănunțită), reutilizabilitate (singleton-uri partajate) și ușurință în mentenanță.

DI este împrumutat din framework-uri cum ar fi Angular și Spring, iar stăpânirea sa — cum să declarați, înregistrați, injectați și faceți mock dependențele — este necesară pentru construirea de aplicații NestJS bine-structurate și ușor de testat și este unul dintre conceptele cele mai importante de înțeles în profunzime în framework.