Wat zijn DTO's in NestJS?

Question

Accepted Answer

A **DTO (Data Transfer Object)** is a class that defines the **shape of data** sent to or from your API — typically the structure of a request body. DTO's provide type safety, serve as a clear contract for endpoints, and (with validation decorators) enable automatic input validation.

## Waarom het belangrijk is

```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;
}
```

A DTO is a plain class describing the expected data, with **validation decorators** (from `class-validator`) specifying the rules each field must satisfy.

## Using a DTO in a 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);
}
```

The `@Body() dto: CreateUserDto` types the request body and — with the validation pipe enabled — automatically validates it before your handler runs.

## Enabling automatic validation

```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
}));
```

With the `ValidationPipe`, NestJS validates incoming bodies against the DTO's decorators automatically — returning a 400 error with details if validation fails, before your code runs.

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

DTO's deliberately differ from database entities — they represent what the API accepts/returns, decoupled from internal storage.

## Variations and reuse

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

## Waarom het belangrijk is

DTO's zijn een belangrijk NestJS-patroon dat type safety, duidelijke API-contracten en automatische validatie aan uw endpoints brengt.

Ze definiëren precies welke gegevens een endpoint accepteert (de aanvraagvorm), wat u compile-time typing geeft en als zelf-documenterende contracten fungeert.

Belangrijk is dat zij, in combinatie met `class-validator` decorators en de `ValidationPipe`, **automatische inputvalidatie** inschakelen — slecht geformuleerde of kwaadwillige aanvragen worden geweigerd met duidelijke fouten *voordat* zij uw bedrijfslogica bereiken, wat essentieel is voor beveiliging en robuustheid (de `whitelist` optie verwijdert ook onverwachte eigenschappen).
": Het begrijpen van DTO's, hoe validatieregels toe te voegen, hoe de validatiepijp in te schakelen, en het belangrijke principe van **het gescheiden houden van DTO's van database-entiteiten** (ontkoppeling van het API-contract van interne opslag) is fundamenteel voor het bouwen van veilige, goed gestructureerde, onderhoudbare NestJS API's.

DTO's verschijnen in vrijwel elk endpoint dat invoer accepteert, wat ze tot dagelijks, essentieel inzicht maakt.