Qu'est-ce que les intercepteurs ?

Question

Accepted Answer

**Les intercepteurs** encapsulent l'exécution d'un gestionnaire de route, vous permettant d'exécuter de la logique **avant et après** — et de transformer la requête ou la réponse. Ils sont inspirés par la programmation orientée aspect, idéaux pour les préoccupations transversales comme la journalisation, la transformation de réponse, la mise en cache et le chronométrage.

## La structure : avant + après via RxJS

```ts
@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    console.log("Before handler");          // runs BEFORE the route handler
    const now = Date.now();

return next.handle().pipe(               // next.handle() = invoke the handler
      tap(() => console.log(`After: ${Date.now() - now}ms`)),   // runs AFTER
    );
  }
}
```

Un intercepteur implémente `intercept()`. Le code avant `next.handle()` s'exécute **avant** le gestionnaire ; `next.handle()` retourne un `Observable` RxJS de la réponse, et les opérateurs comme `tap`/`map` vous permettent d'agir sur la réponse **après** que le gestionnaire se termine.

## Transformer la réponse (un usage courant)

```ts
@Injectable()
export class TransformInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler) {
    return next.handle().pipe(
      map(data => ({ success: true, data, timestamp: new Date().toISOString() })),
      // wraps EVERY response in a consistent envelope: { success, data, timestamp }
    );
  }
}
```

En utilisant `map`, un intercepteur peut remodeler chaque réponse — par exemple en enveloppant toutes les réponses dans une enveloppe standard, un motif très courant pour des réponses d'API cohérentes.

## Autres usages puissants

```ts
// caching — return a cached response, skipping the handler entirely
// timeout — fail requests taking too long
return next.handle().pipe(timeout(5000));

// error mapping — transform exceptions
return next.handle().pipe(catchError(err => throwError(() => new BadGatewayException())));

// excluding fields (serialization) — ClassSerializerInterceptor strips @Exclude() fields
```

```text
Common interceptor uses:
  ✓ Logging / timing requests (before + after)
  ✓ Transforming responses (consistent envelopes, field exclusion)
  ✓ Caching responses
  ✓ Adding timeouts
  ✓ Mapping/handling errors
```

## Appliquer les intercepteurs

```ts
@UseInterceptors(LoggingInterceptor)   // method or controller level
app.useGlobalInterceptors(new TransformInterceptor());   // global
```

## Intercepteurs vs middleware vs guards

```text
Middleware  → runs BEFORE everything, with raw req/res (can't easily touch the response)
Guard       → AUTHORIZATION decision (allow/block) before the handler
Interceptor → wraps the handler — runs BEFORE and AFTER, can TRANSFORM the response
```

La caractéristique déterminante : les intercepteurs peuvent exécuter de la logique **après** le gestionnaire et **transformer la réponse** — ce que les middleware et guards ne peuvent pas faire facilement.

## Pourquoi c'est important

Les intercepteurs sont une fonctionnalité puissante de NestJS pour gérer les **préoccupations transversales** élégamment, et leur capacité distinctive — exécuter de la logique avant *et après* le gestionnaire, et transformer la réponse — en fait l'outil approprié pour les besoins que les middleware et guards ne peuvent pas adresser.

Comprendre les intercepteurs est important car de nombreux besoins courants correspondent naturellement à des intercepteurs : le formatage de réponse cohérent (envelopper toutes les réponses dans une enveloppe standard `{ success, data }`), la journalisation/chronométrage (mesurer la durée du gestionnaire), la mise en cache (retourner les réponses mises en cache), les délais d'expiration, la transformation d'erreur et la sérialisation (exclure les champs sensibles).

Connaître la structure (l'`Observable` de `next.handle()`, avec `tap`/`map`/`catchError` pour agir avant/après), les cas d'usage courants, et surtout **comment les intercepteurs diffèrent des middleware et guards** (la capacité à envelopper et transformer la réponse) est une part clé de la compétence architecturale NestJS.

Les intercepteurs gardent la logique transversale DRY et centralisée plutôt que dupliquée à travers les gestionnaires, les rendant un outil fréquemment utilisé et important pour construire des applications NestJS propres et maintenables.