Wat zijn pipes en hoe werkt validatie?

Question

Accepted Answer

**Pipes** zijn classes die **invoergegevens transformeren of valideren** voordat deze een route handler bereikt. Ze werken op de argumenten van controllermethoden — door ze te transformeren (bijvoorbeeld string → getal) of ze te valideren (ongeldige gegevens af te wijzen). Validatie in NestJS is ingebouwd op pipes.

## Built-in transformation pipes

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

Transformation pipes converteren invoer naar het juiste type (routeparameters/query zijn altijd strings) en mislukken met een 400 als conversie niet mogelijk is.

## The ValidationPipe — automatische DTO-validatie

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

De `ValidationPipe` leest de `class-validator` decorators van de DTO en valideert binnenkomende gegevens automatisch — retourneert een gedetailleerde 400-fout bij mislukking, dus uw handler ontvangt alleen geldige gegevens.

## Waarom het belangrijk is

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

## Custom pipes

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

U implementeert de `transform()` methode van `PipeTransform` voor aangepaste validatie-/transformatielogica.

## Pipes toepassen op verschillende niveaus

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

## Waarom het belangrijk is

Pipes zijn een sleutelfunctie van NestJS voor het veilig afhandelen van invoer en vormen de basis van het **validatiesysteem** van het framework.

Begrijpen is essentieel omdat vrijwel elk API-eindpunt invoer moet valideren en transformeren: transformatiepipes (`ParseIntPipe`, enz.) zorgen ervoor dat parameters het juiste type hebben, en — vooral belangrijk — de **`ValidationPipe`** gecombineerd met DTO's biedt automatische, declaratieve validatie van verzoeken tegen `class-validator` regels, waarbij ongeldige of schadelijke invoer met duidelijke fouten wordt afgewezen *voordat* deze uw bedrijfslogica bereikt.

Dit is kritiek voor zowel beveiliging (onbetrouwde invoer valideren/ontsmetten, onverwachte eigenschappen verwijderen) als robuustheid (handlers ontvangen alleen geldige gegevens).

Weten hoe u de globale validatiepipe met verstandige opties (`whitelist`, `transform`) inschakelt, ingebouwde transformatiepipes gebruikt en aangepaste pipes schrijft, is fundamenteel voor het bouwen van veilige, goed gestructureerde NestJS API's — pipes en validatie zijn alledaagse, must-know concepten in het framework.