Interceptors en NestJS
Tags: javascript, node, nestjs
Published: 2024-07-08 12:59:34


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/94cdg83aev3uh46ymxfv.png)
### Introduction
Dans cet article, nous allons plonger dans le concept des intercepteurs dans Nest.js. Les intercepteurs permettent de transformer les données entrantes ou sortantes, d'effectuer des tâches supplémentaires avant ou après l'exécution d'une méthode de route, et bien plus encore. Ils sont un outil puissant pour gérer les aspects transversaux de vos applications.

### Qu'est-ce qu'un Intercepteur ?
Les intercepteurs dans Nest.js sont des classes annotées avec `@Injectable()` qui implémentent l'interface `NestInterceptor`. Ils interviennent dans le cycle de requête/réponse et peuvent transformer ou manipuler les données à différentes étapes.

### Exemple de Code
Voici un exemple simple pour illustrer comment créer un intercepteur dans Nest.js :

```typescript
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

@Injectable()
export class TransformInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    console.log('Before...');
    const now = Date.now();

    return next
      .handle()
      .pipe(
        map(data => ({
          data,
          timestamp: new Date().toISOString(),
          duration: `${Date.now() - now}ms`,
        })),
      );
  }
}
```

### Explication du Code
- `TransformInterceptor` implémente `NestInterceptor`.
- La méthode `intercept` reçoit le contexte d'exécution (`ExecutionContext`) et le gestionnaire d'appel (`CallHandler`).
- Nous ajoutons une logique pour mesurer la durée de l'exécution et ajouter un timestamp aux données de réponse.
- `next.handle()` continue le traitement de la requête et nous utilisons l'opérateur `map` de RxJS pour transformer les données de la réponse.

### Utilisation dans un Contrôleur
Pour utiliser cet intercepteur dans un contrôleur, vous pouvez l'appliquer à une route spécifique ou globalement :

```typescript
import { Controller, Get, UseInterceptors } from '@nestjs/common';
import { TransformInterceptor } from './transform.interceptor';

@Controller('users')
@UseInterceptors(TransformInterceptor)
export class UsersController {
  @Get()
  findAll(): string {
    return 'This action returns all users';
  }
}
```

### Conclusion
Les intercepteurs sont extrêmement utiles pour implémenter des fonctionnalités transversales telles que la transformation des réponses, le logging, et bien plus encore. En utilisant les intercepteurs, vous pouvez centraliser et réutiliser ces fonctionnalités à travers votre application.

### Prochaines Étapes
- Explorez d'autres types d'intercepteurs pour des cas d'utilisation spécifiques comme le logging, la gestion des erreurs, et la mise en cache.
- Combinez les intercepteurs avec d'autres fonctionnalités avancées de Nest.js comme les guards et les pipes pour une gestion complète des requêtes et des réponses.

### Ressources Additionnelles
- [Documentation officielle Nest.js sur les intercepteurs](https://docs.nestjs.com/interceptors)