Vad är pipes och hur fungerar validering?

Question

Accepted Answer

**Pipes** är klasser som **transformerar eller validerar** inmatningsdata innan den når en route handler. De opererar på argumenten för controller-metoder — antingen transformerar dem (t.ex. sträng → nummer) eller validerar dem (avvisar invalid data). Validering i NestJS är byggt på pipes.

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

Transformations-pipes konverterar inmatning till rätt typ (route params/query är alltid strängar), och misslyckas med en 400 om konvertering inte är möjlig.

## ValidationPipe — automatisk DTO-validering

```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` läser DTOs `class-validator` dekoratörer och validerar inkommande data automatiskt — returnerar en detaljerad 400-fel vid misslyckande, så din handler mottar endast valid data.

## Hur pipes passar in i request-flödet

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

## Anpassade pipes

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

Du implementerar `PipeTransform`s `transform()` metod för anpassad validerings-/transformationslogik.

## Applicera pipes på olika nivåer

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

## Varför det spelar roll

Pipes är en nyckelfunktion i NestJS för att hantera inmatning säkert, och de är grunden för ramverkets **valideringssystem**.

Att förstå dem är väsentligt eftersom nästan varje API-endpoint behöver validera och transformera inmatning: transformations-pipes (`ParseIntPipe` osv.) säkerställer att parametrar är rätt typ, och — viktigast — **`ValidationPipe`** tillsammans med DTOs ger automatisk, deklarativ validering av request bodies mot `class-validator` regler, avvisa invalid eller skadlig inmatning med tydliga fel *innan* den når din affärslogik.

Detta är kritiskt både för säkerhet (validering/sanering av opålitlig inmatning, borttagning av oväntade egenskaper) och robusthet (handlers mottar endast valid data).

Att veta hur man aktiverar global validation pipe med rimliga alternativ (`whitelist`, `transform`), använder inbyggda transformations-pipes och skriver anpassade pipes är grundläggande för att bygga säkra, väl-strukturerade NestJS API:er — pipes och validering är vardagliga, must-know koncept i ramverket.