Hva er pipes og hvordan fungerer validering?

Question

Accepted Answer

**Pipes** er klasser som **transformerer eller validerer** inndatadata før det når en route handler. De opererer på argumentene til controllemetoder — enten ved å transformere dem (f.eks. string → tall) eller validere dem (avvise ugyldige data). Validering i NestJS er bygget på 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 konverterer inndata til riktig type (ruteparametere/spørringer er alltid strenger), mislykkes med en 400 hvis konvertering ikke er mulig.

## The 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` leser DTO-ens `class-validator` dekoratører og validerer innkommende data automatisk — returnerer en detaljert 400-feil ved feil, slik at handleren din bare mottar gyldige data.

## Hvordan pipes passer inn i forespørselsflyten

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

Du implementerer `transform()` metoden til `PipeTransform` for egendefinert validerings-/transformasjonslogikk.

## Bruke pipes på ulike nivåer

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

## Hvorfor dette er viktig

Pipes er en nøkkelfunksjon i NestJS for å håndtere inndata sikkert, og de er grunnlaget for frameworkets **valideringssystem**.

Å forstå dem er essensielt fordi praktisk talt alle API-endepunkter må validere og transformere inndata: transformationspipes (`ParseIntPipe`, osv.) sikrer at parametere har riktig type, og — viktigst av alt — **`ValidationPipe`** kombinert med DTO-er gir automatisk, deklarativ validering av forespørselstekster mot `class-validator` regler, som avviser ugyldig eller ondsinnet inndata med tydelige feil *før* den når forretningslogikken din.

Dette er kritisk for både sikkerhet (validere/rengjøre upålitelig inndata, fjerne uventede egenskaper) og robusthet (handlere mottar bare gyldige data).

Å vite hvordan du aktiverer den globale valideringspipeen med fornuftige alternativer (`whitelist`, `transform`), bruker innebygde transformationspipes, og skriver egendefinerte pipes, er grunnleggende for å bygge sikre, velstrukturerte NestJS API-er — pipes og validering er hverdags-, must-know konsepter i rammeverket.