Cosa sono i provider personalizzati e i token di iniezione?

Question

Accepted Answer

Oltre alle semplici classi `@Injectable()`, NestJS supporta i **provider personalizzati** — modi flessibili per definire cosa viene iniettato — utilizzando i **token di iniezione**. Questo ti permette di iniettare valori, configurare come vengono create le istanze, scambiare implementazioni e iniettare dipendenze non-classe.

## I quattro tipi di provider personalizzati

```ts
@Module({
  providers: [
    // 1. useClass — standard (or swap the implementation behind a token)
    { provide: PaymentService, useClass: StripePaymentService },

// 2. useValue — inject a constant/object/mock (great for config and testing)
    { provide: "CONFIG", useValue: { apiKey: "abc", timeout: 5000 } },

// 3. useFactory — compute the provider dynamically (can use other deps)
    {
      provide: "DATABASE_CONNECTION",
      useFactory: async (config: ConfigService) => {
        return await createConnection(config.get("DB_URL"));   // async setup
      },
      inject: [ConfigService],        // dependencies for the factory
    },

// 4. useExisting — create an alias for an existing provider
    { provide: "ALIAS", useExisting: PaymentService },
  ],
})
export class AppModule {}
```

## Token di iniezione — per dipendenze non-classe

```ts
// classes can be tokens directly (by type). For values/interfaces, use a string/Symbol token:
@Injectable()
export class PaymentProcessor {
  constructor(@Inject("CONFIG") private config: AppConfig) {}   // inject by token
}
```

Poiché non puoi iniettare un'interfaccia o un valore semplice per tipo (non esistono a runtime), usi un **token** (una stringa o un `Symbol`) con `@Inject(token)` per iniettarlo. Questo è il modo in cui inietti oggetti di configurazione, client di terze parti, o dipendenze tipizzate con interfacce.

## useFactory — il più potente (setup dinamico e asincrono)

```ts
// create a provider whose value depends on runtime config / async initialization
{
  provide: "REDIS_CLIENT",
  useFactory: (config: ConfigService) => new Redis(config.get("REDIS_URL")),
  inject: [ConfigService],
}
```

`useFactory` esegue una funzione (con dipendenze iniettate) per produrre il provider — essenziale per connessioni, client, o qualsiasi cosa che necessiti di configurazione a runtime o setup asincrono.

## Scambiare implementazioni (useClass) — flessibilità e testing

```ts
// inject a different implementation based on environment
{
  provide: PaymentService,
  useClass: process.env.NODE_ENV === "test" ? MockPaymentService : StripePaymentService,
}
```

Poiché i consumatori dipendono dal token (`PaymentService`), puoi scambiare la classe concreta — un vero servizio Stripe in produzione, un mock nei test — senza cambiare alcun codice consumatore.

## Perché è importante

I provider personalizzati e i token di iniezione estendono l'iniezione di dipendenze di NestJS oltre le semplici classi, dandoti la flessibilità necessaria per le applicazioni del mondo reale.

Comprenderli è importante per diversi scenari comuni: **iniettare valori non-classe** (oggetti di configurazione, costanti) tramite `useValue` e token stringa/Symbol (poiché non puoi iniettare interfacce o valori semplici per tipo); **creazione di provider dinamico/asincrono** tramite `useFactory` (la forma più potente — creare connessioni a database, client Redis, o istanze di SDK di terze parti configurate da valori a runtime, con le loro proprie dipendenze iniettate); e **scambiare implementazioni** tramite `useClass` dietro un token (abilitando implementazioni basate su ambiente e, crucialmente, **mocking facile nei test** — fornire una classe mock per un token senza toccare i consumatori).

Questa flessibilità è ciò che rende potente il DI di NestJS per l'architettura di produzione e per l'eccellente testabilità.

Conoscere i quattro tipi di provider (`useClass`, `useValue`, `useFactory`, `useExisting`), come funzionano i token di iniezione per dipendenze non-classe, e quando ricorrere a ciascuno è un passo importante oltre il DI base — è il modo in cui colleghi database, servizi esterni, configurazione, e dipendenze scambiabili/mockabili nel modo idiomatico di NestJS, rendendolo un argomento frequentemente necessario e architetturalmente significativo nelle applicazioni reali.