Co jsou DTOs v NestJS?

Question

Accepted Answer

**DTO (Data Transfer Object)** je třída, která definuje **tvar dat** odesílaných do nebo z vašeho API — obvykle strukturu těla požadavku. DTOs poskytují bezpečnost typů, slouží jako jasný kontrakt pro endpointy a (s validačními dekorátory) umožňují automatickou validaci vstupu.

## Definování 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;
}
```

DTO je prostá třída popisující očekávaná data s **validačními dekorátory** (z `class-validator`) specifikujícími pravidla, která musí každé pole splňovat.

## Použití DTO v kontroleru

```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` typuje tělo požadavku a — s povoleným validačním potrubím — jej před spuštěním vaší obsluhy automaticky validuje.

## Povolení automatické validace

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

S `ValidationPipe` NestJS automaticky validuje příchozí těla proti dekorátorům DTO — při selhání validace vrací chybu 400 s podrobnostmi, ještě než se váš kód spustí.

## DTOs vs Entity

```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 se záměrně liší od entit databáze — představují, co API přijímá/vrací, odděleno od interního úložiště.

## Variace a opětovné použití

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

## Proč na tom záleží

DTOs jsou důležitý vzor NestJS, který přináší bezpečnost typů, jasné API kontrakty a automatickou validaci do vašich endpointů.

Definují přesně, jaká data endpoint přijímá (tvar požadavku), což vám dává typování v čase kompilace a slouží jako samodokumentující se kontrakty.

Klíčově, v kombinaci s dekorátory `class-validator` a `ValidationPipe`, umožňují **automatickou validaci vstupu** — nesprávně formátované nebo škodlivé požadavky jsou zamítnuty s jasnými chybami *ještě než* se dostanou do vaší obchodní logiky, což je nezbytné pro bezpečnost a robustnost (možnost `whitelist` také odstraňuje neočekávané vlastnosti).

Porozumění DTOs, jak přidávat validační pravidla, jak povolit validační potrubí a důležitému principu **oddělení DTOs od entit databáze** (oddělení API kontraktu od interního úložiště) je zásadní pro vytváření bezpečných, dobře strukturovaných a udržitelných NestJS API.

DTOs se objevují prakticky v každém endpointu, který přijímá vstup, což je každodenní a nezbytné znalosti.