Cosa sono i pipe e come funziona la validazione?

Question

Accepted Answer

I **pipe** sono classi che **trasformano o validano** i dati in input prima che raggiungano un route handler. Operano sugli argomenti dei metodi del controller — trasformandoli (es. string → number) o validandoli (rifiutando dati non validi). La validazione in NestJS è costruita sui pipe.

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

I transformation pipe convertono l'input nel tipo corretto (i parametri di route/query sono sempre string), fallendo con un 400 se la conversione non è possibile.

## The ValidationPipe — automatic DTO validation

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

Il `ValidationPipe` legge i decoratori `class-validator` del DTO e valida automaticamente i dati in arrivo — restituendo un errore dettagliato 400 in caso di fallimento, in modo che il handler riceva solo dati validi.

## How pipes fit in the request flow

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

Implementi il metodo `transform()` di `PipeTransform` per la logica di validazione/trasformazione personalizzata.

## Applying pipes at different levels

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

## Perché è importante

I pipe sono una feature chiave di NestJS per gestire l'input in sicurezza, e sono la base del **sistema di validazione** del framework.

Comprenderli è essenziale perché quasi ogni endpoint API ha bisogno di validare e trasformare l'input: i transformation pipe (`ParseIntPipe`, etc.) assicurano che i parametri siano del tipo corretto, e — soprattutto — il **`ValidationPipe`** combinato con i DTO fornisce una validazione automatica e dichiarativa dei request body rispetto alle regole di `class-validator`, rifiutando input non valido o malevolo con errori chiari *prima* che raggiunga la logica di business.

Questo è critico sia per la sicurezza (validare/sanitizzare input non attendibile, rimuovere proprietà inaspettate) che per la robustezza (i handler ricevono solo dati validi).

Sapere come abilitare il global validation pipe con opzioni sensate (`whitelist`, `transform`), usare i transformation pipe built-in, e scrivere pipe personalizzati è fondamentale per costruire API NestJS sicure e ben strutturate — i pipe e la validazione sono concetti di uso quotidiano e indispensabili nel framework.