Hva er DTOer i NestJS?

Question

Accepted Answer

En **DTO (Data Transfer Object)** er en klasse som definerer **formen på data** som sendes til eller fra APIet ditt — typisk strukturen på en request body. DTOer gir typesikkerhet, fungerer som en klar kontrakt for endepunkter, og gjør det mulig (med valideringsdekorer) å aktivere automatisk inndatavalidering.

## Definere en DTO

```ts
import { IsEmail, IsString, MinLength, IsOptional, IsInt, Min } from "class-validator";

export class CreateUserDto {
  @IsEmail()                    // must be a valid email
  email: string;

@IsString()
  @MinLength(8)                 // password at least 8 chars
  password: string;

@IsOptional()                 // optional field
  @IsInt()
  @Min(0)
  age?: number;
}
```

En DTO er en enkel klasse som beskriver forventet data, med **valideringsdekorer** (fra `class-validator`) som spesifiserer reglene som hvert felt må oppfylle.

## Bruke en DTO i en controller

```ts
@Post()
create(@Body() dto: CreateUserDto) {     // the body is typed AND validated as CreateUserDto
  // dto is guaranteed to be valid here (with the validation pipe enabled)
  return this.usersService.create(dto);
}
```

`@Body() dto: CreateUserDto` skriver request body, og — når valideringspipe er aktivert — validerer det automatisk før handleren din kjører.

## Aktivere automatisk validering

```ts
// main.ts — turn on the global validation pipe
app.useGlobalPipes(new ValidationPipe({
  whitelist: true,              // strip properties NOT in the DTO (security)
  forbidNonWhitelisted: true,   // reject requests with extra unknown properties
  transform: true,              // auto-transform payloads to DTO instances + convert types
}));
```

Med `ValidationPipe` validerer NestJS innkommende bodies mot DTOens dekorer automatisk — og returnerer en 400-feil med detaljer hvis valideringen mislykkes, før koden din kjører.

## DTOer vs entiteter

```text
DTO    → the shape of data crossing the API boundary (request/response contract)
Entity → the database model (e.g. a TypeORM entity / Prisma model)
→ Keep them SEPARATE: the API contract shouldn't be coupled to the DB schema.
  (A CreateUserDto has password+email; the User entity has id, timestamps, etc.)
```

DTOer er med vilje forskjellige fra databaseentiteter — de representerer hva APIet aksepterer/returnerer, atskilt fra internt lagring.

## Variasjoner og gjenbruk

```ts
import { PartialType } from "@nestjs/mapped-types";
// derive an UpdateUserDto where all fields are optional — no duplication
export class UpdateUserDto extends PartialType(CreateUserDto) {}
```

## Hvorfor det betyr noe

DTOer er et viktig NestJS-mønster som bringer typesikkerhet, klare API-kontrakter og automatisk validering til endepunktene dine.

De definerer nøyaktig hvilken data et endepunkt aksepterer (request-formen), og gir deg kompileringstidstyping og fungerer som selvdokumenterende kontrakter.

Avgjørende, kombinert med `class-validator`-dekorer og `ValidationPipe`, muliggjør de **automatisk inndatavalidering** — malformet eller ondsinnet forespørsler blir avvist med klare feil *før* de når forretningslogikken din, noe som er essensielt for sikkerhet og robusthet (`whitelist`-alternativet fjerner også uventede egenskaper).

Å forstå DTOer, hvordan du legger til valideringsregler, hvordan du aktiverer valideringspipe, og det viktige prinsippet om **å holde DTOer atskilt fra databaseentiteter** (atskille API-kontrakten fra internt lagring) er grunnleggende for å bygge sikre, velstrukturerte, vedlikeholdbare NestJS-APIer.

DTOer vises i praktisk talt hvert endepunkt som aksepterer inndata, noe som gjør dem til dagligdags, essensiell kunnskap.