Qu'est-ce que les fournisseurs personnalisés et les jetons d'injection ?

Question

Accepted Answer

Au-delà des simples classes `@Injectable()`, NestJS supporte les **fournisseurs personnalisés** — des façons flexibles de définir ce qui est injecté — en utilisant les **jetons d'injection**. Cela vous permet d'injecter des valeurs, de configurer comment les instances sont créées, de remplacer les implémentations et d'injecter des dépendances non-classe.

## Pourquoi c'est important

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

## Jetons d'injection — pour les dépendances 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
}
```

Puisque vous ne pouvez pas injecter une interface ou une valeur simple par type (elles n'existent pas à l'exécution), vous utilisez un **jeton** (une chaîne ou un `Symbol`) avec `@Inject(token)` pour l'injecter. C'est comment vous injectez des objets de configuration, des clients tiers ou des dépendances typées par interface.

## useFactory — le plus puissant (configuration dynamique et asynchrone)

```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` exécute une fonction (avec des dépendances injectées) pour produire le fournisseur — essentiel pour les connexions, les clients ou tout ce qui nécessite une configuration d'exécution ou une configuration asynchrone.

## Remplacer les implémentations (useClass) — flexibilité et tests

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

Puisque les consommateurs dépendent du jeton (`PaymentService`), vous pouvez remplacer la classe concrète — un vrai service Stripe en production, un mock en tests — sans modifier aucun code consommateur.

## Pourquoi c'est important

Les fournisseurs personnalisés et les jetons d'injection étendent l'injection de dépendances de NestJS au-delà des simples classes, vous donnant la flexibilité nécessaire pour les applications du monde réel.

Comprendre cela est important pour plusieurs scénarios courants : **injecter des valeurs non-classe** (objets de configuration, constantes) via `useValue` et des jetons string/Symbol (puisque vous ne pouvez pas injecter les interfaces ou les valeurs simples par type) ; **création de fournisseur dynamique/asynchrone** via `useFactory` (la forme la plus puissante — créer des connexions à des bases de données, des clients Redis ou des instances SDK tiers configurées à partir de valeurs d'exécution, avec leurs propres dépendances injectées) ; et **remplacer les implémentations** via `useClass` derrière un jeton (permettant les implémentations basées sur l'environnement et, crucially, le **mocking facile en tests** — fournir une classe mock pour un jeton sans toucher les consommateurs).

Cette flexibilité est ce qui rend la DI de NestJS puissante pour l'architecture en production et excellente pour la testabilité.

Connaître les quatre types de fournisseurs (`useClass`, `useValue`, `useFactory`, `useExisting`), comment fonctionnent les jetons d'injection pour les dépendances non-classe, et quand utiliser chacun est une étape importante au-delà de la DI basique — c'est comment vous câblez les bases de données, les services externes, la configuration et les dépendances interchangeables/mockables de la façon idiomatique de NestJS, ce qui en fait un sujet fréquemment nécessaire et architecturalement significatif dans les applications réelles.