Vad är DTOs i NestJS?

Question

Accepted Answer

En **DTO (Data Transfer Object)** är en klass som definierar **formen på data** som skickas till eller från ditt API — vanligtvis strukturen på en request body. DTOs ger typsäkerhet, fungerar som ett tydligt kontrakt för endpoints och möjliggör (med valideringsdekoratörer) automatisk indatavalidering.

## Definiera 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 är en enkel klass som beskriver förväntad data, med **valideringsdekoratörer** (från `class-validator`) som specificerar reglerna som varje fält måste uppfylla.

## Använda 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` typsäkrar request bodyn och — med valideringspipeline aktiverad — validerar den automatiskt innan din handler körs.

## Aktivera 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` validerar NestJS inkommande bodies mot DTOns dekoratörer automatiskt — och returnerar ett 400-fel med detaljer om valideringen misslyckas, innan din kod körs.

## DTOs vs Entities

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

DTOs skiljer sig medvetet från databasentiteter — de representerar vad API:et accepterar/returnerar, frånkopplat från intern lagring.

## Variationer och återanvändning

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

## Varför det är viktigt

DTOs är ett viktigt NestJS-mönster som ger typsäkerhet, tydliga API-kontrakt och automatisk validering till dina endpoints.

De definierar exakt vilken data en endpoint accepterar (request-formen), vilket ger dig compile-time-typning och fungerar som självdokumenterande kontrakt.

Oftast, kombinerat med `class-validator`-dekoratörer och `ValidationPipe`, möjliggör de **automatisk indatavalidering** — felaktig eller skadlig data avvisas med tydliga fel *innan* de når din affärslogik, vilket är väsentligt för säkerhet och robusthet (`whitelist`-alternativet tar också bort oväntade egenskaper).

Att förstå DTOs, hur man lägger till valideringsregler, hur man aktiverar valideringspipeline och principen om **att hålla DTOs separata från databasentiteter** (att koppla från API-kontraktet från intern lagring) är grundläggande för att bygga säkra, välstrukturerade, underhållbara NestJS-API:er.

DTOs förekommer i praktiskt taget varje endpoint som accepterar indata, vilket gör dem till daglig, väsentlig kunskap.