Co jsou to Pipes a jak funguje ověřování?

Question

Accepted Answer

**Pipes** jsou třídy, které **transformují nebo ověřují** vstupní data předtím, než dosáhnou obslužné funkce trasy. Fungují na argumentech metod kontroleru — buď je transformují (např. string → number), nebo je ověřují (odmítají neplatná data). Ověřování v NestJS je postaveno na pipes.

## Vestavěné transformační 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
```

Transformační pipes konvertují vstup na správný typ (parametry tras/dotazy jsou vždy řetězce), selžou s 400, pokud konverze není možná.

## ValidationPipe — automatické ověřování 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
}
```

`ValidationPipe` čte dekorátory `class-validator` DTO a automaticky ověřuje příchozí data — vrací podrobnou chybu 400 při selhání, takže vaša obslužná funkce obdrží pouze platná data.

## Jak se pipes vejdou do toku požadavku

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

## Vlastní pipes

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

Implementujete metodu `transform()` z `PipeTransform` pro vlastní logiku ověřování/transformace.

## Aplikování pipes na různých úrovních

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

## Proč je to důležité

Pipes jsou klíčovou vlastností NestJS pro bezpečné zpracování vstupu a jsou základem **ověřovacího systému** rámce.

Porozumění jim je nezbytné, protože téměř každý endpoint API potřebuje ověřit a transformovat vstup: transformační pipes (`ParseIntPipe` atd.) zajišťují, že jsou parametry správného typu, a — co je nejdůležitější — **`ValidationPipe`** v kombinaci s DTO poskytuje automatické, deklarativní ověřování těl požadavků proti pravidlům `class-validator`, odmítá neplatný nebo škodlivý vstup s jasnými chybami *předtím, než dosáhne vaší obchodní logiky*.

To je rozhodující pro bezpečnost (ověřování/sanitizace nedůvěryhodného vstupu, odstranění neočekávaných vlastností) i robustnost (obslužné funkce obdrží pouze platná data).

Znalost povolení globálního ověřovacího pipe s rozumnými možnostmi (`whitelist`, `transform`), používání vestavěných transformačních pipes a psaní vlastních pipes je zásadní pro vytváření bezpečných, dobře strukturovaných NestJS API — pipes a ověřování jsou každodenní, musíte-znát koncepce v rámci.