O que são pipes e como funciona a validação?

Question

Accepted Answer

**Pipes** são classes que **transformam ou validam** dados de entrada antes de chegarem a um manipulador de rota. Elas operam nos argumentos dos métodos do controlador — transformando-os (por exemplo, string → número) ou validando-os (rejeitando dados inválidos). A validação no NestJS é construída sobre 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
```

Os pipes de transformação convertem entrada para o tipo correto (parâmetros de rota/query são sempre strings), falhando com um 400 se a conversão não for possível.

## The ValidationPipe — validação automática de 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
}
```

O `ValidationPipe` lê os decoradores `class-validator` do DTO e valida dados de entrada automaticamente — retornando um erro 400 detalhado em caso de falha, para que seu manipulador receba apenas dados válidos.

## Por que isso importa

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

Você implementa o método `transform()` do `PipeTransform` para lógica personalizada de validação/transformação.

## Aplicando pipes em diferentes níveis

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

## Por que isso importa

Pipes são um recurso chave do NestJS para lidar com entrada de forma segura, e são a base do **sistema de validação** do framework.

Compreendê-los é essencial porque praticamente todo endpoint de API precisa validar e transformar entrada: pipes de transformação (`ParseIntPipe`, etc.) garantem que os parâmetros sejam do tipo correto, e — mais importante — o **`ValidationPipe`** combinado com DTOs fornece validação automática e declarativa de corpos de solicitação contra regras `class-validator`, rejeitando entrada inválida ou maliciosa com erros claros *antes* de chegar à sua lógica de negócio.

Isso é crítico tanto para segurança (validar/sanitizar entrada não confiável, remover propriedades inesperadas) quanto para robustez (manipuladores recebem apenas dados válidos).

Saber como ativar o pipe de validação global com opções sensatas (`whitelist`, `transform`), usar pipes de transformação integrados e escrever pipes personalizados é fundamental para construir APIs NestJS seguras e bem estruturadas — pipes e validação são conceitos obrigatórios e diários no framework.