Mi a DTO a NestJS-ben?

Question

Accepted Answer

A **DTO (Data Transfer Object)** egy olyan osztály, amely az API-nak küldött vagy onnan érkezett adatok **alakját** határozza meg — jellemzően egy kérés törzse szerkezetét. A DTO-k biztosítják a típusbiztonságot, világos szerződésként szolgálnak az endpoint-oknak, és (validációs dekorátorokkal) automatikus beviteli validálást tesznek lehetővé.

## DTO definiálása

```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 egy egyszerű osztály, amely az elvárt adatokat írja le, **validációs dekorátorokkal** (a `class-validator` csomagból), amelyek az egyes mezőknek meg kell felelniük.

## DTO használata egy kontrollerben

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

A `@Body() dto: CreateUserDto` típusként kezeli a kérés törzsét, és — ha a validációs csővezeték engedélyezve van — automatikusan validálja azt, mielőtt az Ön kezelője lefutna.

## Automatikus validálás engedélyezése

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

A `ValidationPipe` segítségével a NestJS automatikusan validálja a beérkező törzseketegy DTO dekorátorai alapján — 400-as hibával tér vissza részletekkel, ha a validálás sikertelen, mielőtt a kód futna.

## DTO-k és entitások

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

A DTO-k szándékosan eltérnek az adatbázis entitásoktól — azt reprezentálják, amit az API elfogad/visszaad, decentralizáltan az belső tárolástól.

## Variációk és újrafelhasználás

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

## Miért számít

A DTO-k egy fontos NestJS minta, amely típusbiztonságot, világos API-szerződéseket és automatikus validálást hoz az Ön endpoint-jaihoz.

Pontos módon meghatározzák, hogy egy endpoint milyen adatokat fogad el (a kérés alakja), compile-time gépelést biztosítva, és önmagában dokumentáló szerződésként szolgál.

Fondamentálisan, a `class-validator` dekorátorokkal és a `ValidationPipe` segítségével kombinálva **automatikus beviteli validálást** tesznek lehetővé — a rosszul formázott vagy rosszindulatú kérések világos hibákkal elutasításra kerülnek, *mielőtt* elérnék az üzleti logikáját, ami kritikus a biztonság és robusztusság szempontjából (a `whitelist` opció az előre nem jelzett tulajdonságokat is eltávolítja).

A DTO-k megértése, hogyan adjon hozzá validációs szabályokat, hogyan engedélyezze a validációs csövezeté, és a fontos elv — **a DTO-k elkülönítése az adatbázis entitásoktól** (az API-szerződés decentralizálása a belső tárolástól) — alapvető a biztonságos, jól strukturált, karbantartható NestJS API-k építéséhez.

A DTO-k gyakorlatilag minden endpoint-ban megjelennek, amely elfogad bemenetet, így mindennapi, alapvető tudás.