Come funziona l'iniettazione delle dipendenze in NestJS?

Question

Accepted Answer

**Dependency Injection (DI)** è un pattern fondamentale di NestJS dove il framework **crea automaticamente e fornisce** le dipendenze di cui una classe ha bisogno, invece di farle costruire dalla classe stessa. Dichiari ciò di cui hai bisogno nel costruttore, e NestJS lo fornisce — portando a codice debolmente accoppiato e testabile.

## Come funziona: dichiara nel costruttore

```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 legge i tipi dei parametri del costruttore, cerca i provider registrati corrispondenti, li crea (se non già creati), e li passa — risolvendo automaticamente l'intero grafo delle dipendenze.

## Il flusso 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
```

## Registrazione e risoluzione

```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
```

## Perché DI è prezioso

```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)
```

## Testabilità — il vantaggio decisivo

```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();
```

Poiché la classe non costruisce le sue dipendenze, puoi sostituire i mock per i test — DI rende le app NestJS altamente testabili.

## Iniettare valori non-classe

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

## Perché è importante

L'iniettazione delle dipendenze è il pattern fondamentale che sottende l'intera architettura di NestJS — è come i controller ottengono servizi, i servizi ottengono repository e altri servizi, e l'intera applicazione è collegata insieme.

Comprendere ciò è essenziale perché quasi ogni classe NestJS partecipa in DI: dichiari le dipendenze nel costruttore e il container IoC del framework le risolve e le fornisce automaticamente, eliminando l'istanziazione manuale e l'accoppiamento stretto.

I vantaggi sono significativi e centrali al motivo per cui NestJS è apprezzato: **accoppiamento debole** (dipendi da astrazioni), **testabilità** (inietta mock invece di dipendenze reali — rendendo facili i test unitari approfonditi), riutilizzabilità (singleton condivisi), e manutenibilità.

DI è preso in prestito da framework come Angular e Spring, e padroneggiarlo — come dichiarare, registrare, iniettare e mockare le dipendenze — è necessario per costruire applicazioni NestJS ben strutturate e testabili ed è uno dei concetti più importanti da capire profondamente nel framework.