Apa itu DTOs di NestJS?

Question

Accepted Answer

Sebuah **DTO (Data Transfer Object)** adalah sebuah class yang mendefinisikan **bentuk data** yang dikirim ke atau dari API Anda — biasanya struktur dari request body. DTOs menyediakan type safety, berfungsi sebagai kontrak yang jelas untuk endpoints, dan (dengan validation decorators) memungkinkan automatic input validation.

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

Sebuah DTO adalah sebuah plain class yang mendeskripsikan data yang diharapkan, dengan **validation decorators** (dari `class-validator`) yang menspesifikasikan rules yang harus dipenuhi setiap field.

## Menggunakan DTO dalam sebuah 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);
}
```

Decorator `@Body() dto: CreateUserDto` melakukan typing pada request body dan — dengan validation pipe yang diaktifkan — secara otomatis memvalidasinya sebelum handler Anda berjalan.

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

Dengan `ValidationPipe`, NestJS memvalidasi incoming bodies terhadap decorators DTO secara otomatis — mengembalikan error 400 dengan detail jika validasi gagal, sebelum kode Anda berjalan.

## 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 sengaja berbeda dari database entities — mereka merepresentasikan apa yang API terima/kembalikan, terpisah dari internal storage.

## Variasi dan reuse

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

## Mengapa ini penting

DTOs adalah pola NestJS yang penting yang membawa type safety, kontrak API yang jelas, dan automatic validation ke endpoints Anda.

Mereka mendefinisikan dengan tepat data apa yang diterima endpoint (bentuk request), memberikan Anda typing saat compile-time dan berfungsi sebagai kontrak yang self-documenting.

Yang paling penting, dikombinasikan dengan `class-validator` decorators dan `ValidationPipe`, mereka memungkinkan **automatic input validation** — request yang malformed atau malicious ditolak dengan error yang jelas *sebelum* mencapai business logic Anda, yang sangat penting untuk security dan robustness (opsi `whitelist` juga menghapus properti yang tidak terduga).

Memahami DTOs, cara menambahkan validation rules, cara mengaktifkan validation pipe, dan prinsip penting **menjaga DTOs terpisah dari database entities** (decoupling API contract dari internal storage) adalah fundamental untuk membangun NestJS APIs yang aman, well-structured, dan maintainable.

DTOs muncul di hampir setiap endpoint yang menerima input, menjadikan mereka everyday, essential knowledge.