Apa kuwi DTOs ing NestJS?

Question

Accepted Answer

A **DTO (Data Transfer Object)** minangka klas sing nemtokake **wujud data** sing dikirim menyang utawa saka API amu — biasane struktur saka request body. DTOs nyedhiyakake type safety, dadi kontrak sing jelas kanggo endpoints, lan (karo validation decorators) ngaktifake automatic input validation.

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

A DTO yaiku klas biasa sing nerangake data sing dikarepake, karo **validation decorators** (saka `class-validator`) sing nemtokake aturan sing kudu ditepati saben field.

## Nggunakake DTO ing 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);
}
```

Kang `@Body() dto: CreateUserDto` nemtokake tipe request body lan — karo validation pipe sing diaktifake — automatic validasi kabeh sadurunge handler amu.

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

Karo `ValidationPipe`, NestJS validasi incoming bodies nglawan DTO decorators automatic — bali 400 error karo detail yen validation gagal, sadurunge code amu.

## DTOs lawan 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 beda-beda karo database entities — mrepresentasi apa sing API terima/bali, decoupled saka internal storage.

## Variasi lan reuse

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

## Dene kuwi penting

DTOs yaiku pola penting NestJS sing ngebawa type safety, API contracts sing jelas, lan automatic validation menyang endpoints amu.

Menur nemtokake persis apa data sing endpoint terima (request shape), menehi amu compile-time typing lan dadi kontrak sing self-documenting.

Crucially, digabung karo `class-validator` decorators lan `ValidationPipe`, mbenere **automatic input validation** — requests sing malformed utawa malicious ditolak karo error sing jelas *sadurunge* tekan business logic amu, apa penting kanggo security lan robustness (opsi `whitelist` uga nyisihake properties sing ora dikarepake).

Paham DTOs, cara nambah validation rules, cara ngaktifake validation pipe, lan prinsip penting **tetep DTOs pisah saka database entities** (decoupling API contract saka internal storage) yaiku fundamental kanggo awak safe, well-structured, maintainable NestJS APIs.

DTOs muncul ing virtually saben endpoint sing terima input, making maka everyday, essential knowledge.