Qu'est-ce que les pipes et comment fonctionne la validation ?

Question

Accepted Answer

**Les pipes** sont des classes qui **transforment ou valident** les données d'entrée avant qu'elles n'atteignent un gestionnaire de route. Ils opèrent sur les arguments des méthodes du contrôleur — soit en les transformant (par exemple chaîne → nombre), soit en les validant (rejetant les données invalides). La validation dans NestJS est construite sur les pipes.

## Pipes de transformation intégrés

```ts
@Get(":id")
findOne(@Param("id", ParseIntPipe) id: number) {    // transforms "5" (string) → 5 (number)
  // id is guaranteed to be a number; non-numeric input → 400 error automatically
  return this.usersService.findOne(id);
}
// other built-ins: ParseBoolPipe, ParseUUIDPipe, ParseArrayPipe, DefaultValuePipe
```

Les pipes de transformation convertissent l'entrée au bon type (les paramètres de route/requête sont toujours des chaînes), échouant avec un 400 si la conversion n'est pas possible.

## The ValidationPipe — validation automatique des DTO

```ts
// enable globally in main.ts
app.useGlobalPipes(new ValidationPipe({
  whitelist: true,              // remove properties not declared in the DTO
  forbidNonWhitelisted: true,   // throw if unknown properties are present
  transform: true,              // turn plain objects into DTO instances, convert types
}));
```

```ts
// with a DTO using class-validator decorators:
export class CreateUserDto {
  @IsEmail() email: string;
  @MinLength(8) password: string;
}

@Post()
create(@Body() dto: CreateUserDto) {   // ValidationPipe validates the body automatically
  // if invalid → 400 with details, BEFORE this runs
}
```

Le `ValidationPipe` lit les décorateurs `class-validator` du DTO et valide automatiquement les données entrantes — retournant une erreur 400 détaillée en cas d'échec, afin que votre gestionnaire ne reçoive que des données valides.

## Comment les pipes s'intègrent dans le flux de requête

```text
Request → ...middleware/guards/interceptors... → PIPES (transform/validate) → Handler
Pipes run JUST BEFORE the route handler, operating on its method arguments.
```

## Pipes personnalisés

```ts
@Injectable()
export class TrimPipe implements PipeTransform {
  transform(value: any) {
    return typeof value === "string" ? value.trim() : value;   // custom transformation
  }
}
// usage: @Body(TrimPipe) ...
```

Vous implémentez la méthode `transform()` de l'interface `PipeTransform` pour une logique personnalisée de validation/transformation.

## Application des pipes à différents niveaux

```ts
@UsePipes(new ValidationPipe())      // method or controller level
@Param("id", ParseIntPipe)            // parameter level
app.useGlobalPipes(new ValidationPipe())   // global (most common for validation)
```

## Pourquoi c'est important

Les pipes sont une fonctionnalité clé de NestJS pour gérer l'entrée en toute sécurité, et ils constituent la fondation du **système de validation** du framework.

Les comprendre est essentiel car presque tous les points de terminaison d'API doivent valider et transformer l'entrée : les pipes de transformation (`ParseIntPipe`, etc.) garantissent que les paramètres sont du bon type, et — surtout — le **`ValidationPipe`** combiné aux DTO fournit une validation automatique et déclarative des corps de requête par rapport aux règles `class-validator`, rejetant les entrées invalides ou malveillantes avec des erreurs claires *avant* qu'elles n'atteignent votre logique métier.

C'est critique à la fois pour la sécurité (validation/désinfection des entrées non fiables, suppression des propriétés inattendues) et la robustesse (les gestionnaires ne reçoivent que des données valides).

Savoir comment activer le pipe de validation global avec des options judicieuses (`whitelist`, `transform`), utiliser les pipes de transformation intégrés et écrire des pipes personnalisés est fondamental pour construire des API NestJS sûres et bien structurées — les pipes et la validation sont des concepts quotidiens et incontournables du framework.