რა არის DTOs NestJS-ში?

Question

Accepted Answer

**DTO (Data Transfer Object)** არის კლასი, რომელიც განსაზღვრავს **მონაცემების ფორმას**, რომელიც იგზავნება თქვენი API-ში ან მისგან — ჩვეულებრივ request body-ის სტრუქტურა. DTOs უზრუნველყოფენ type safety-ს, ემსახურებიან როგორც endpoint-ების გამართული ხელშეკრულება, და (validation decorators-ის საშუალებით) აფერხებენ ავტომატური input validation-ს.

## 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 არის ჩვეულებრივი კლასი, რომელიც აღწერს მოსალოდნელ მონაცემებს, **validation decorators**-ით (from `class-validator`) რომელიც განსაზღვრავს წესებს, რომელსაც ყველა ველი უნდა აკმაყოფილებდეს.

## DTO-ის გამოყენება 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);
}
```

`@Body() dto: CreateUserDto` აკრიფებს request body-ს და — validation pipe ჩართული უნდა იყოს — ავტომატურად აზოდზე კვლებს მას, სანამ თქვენი handler გაიქცეს.

## ავტომატური 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
}));
```

`ValidationPipe`-თან, NestJS ავტომატურად აზოდზე კვლებს შემომავალი bodies-ს DTO-ს decorators-ის წინააღმდეგ — 400 error-ს აბრუნებს დეტალებთან, თუ validation არ შედეგი აკეთებს, სანამ თქვენი კოდი გაიქცეს.

## 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 განზრახ განსხვავდებიან database entities-ისგან — ისინი წარმოადგენენ, რასაც API იღებს/დააბრუნებს, გამორთულია ინტერნული შენახვისგან.

## ვარიაციები და მხეთ გამოყენება

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

## რატომ მნიშვნელოვანი

DTOs არის მნიშვნელოვანი NestJS ნიმუში, რომელიც აღამცებს type safety-ს, მკაფიო API ხელშეკრულებებს და ავტომატური validation-ს თქვენი endpoint-ებზე.

ისინი განსაზღვრავენ ზუსტად, რა მონაცემი endpoint იღებს (request shape), რაც გიძლევთ compile-time typing-ს და ემსახურებიან თვითშენახემი დოკუმენტაციის ხელშეკრულებად.

კრიტიკულად მნიშვნელოვან, `class-validator` decorators და `ValidationPipe`-თან, ისინი აფერხებენ **ავტომატური input validation** — არასწორად ჩამოყალიბებული ან მავნე requests უარყო პირდაპირი შეცდომებით *თქვენი ბიზნეს ლოგიკამდე*, რაც არის უსაფრთხოების და გამძლეობისთვის აუცილებელი (`whitelist` ოპცია ასევე აფილტრებს მოულოდი თვისებებს).

DTOs-ის გაგება, როგორ დავამატოთ validation წესები, როგორ ჩავრთოთ validation pipe და მნიშვნელოვანი პრინციპი — **DTOs-ს ცალკე დაკავება database entities-ისგან** (API ხელშეკრულების გამორთვა ინტერნული შენახვისგან) არის ფუნდამენტური უსაფრთხო, კარგად სტრუქტურირებული, რომელიმე NestJS API-ების აგებისთვის.

DTOs ჩნდებიან ვირტუალურად ყველა endpoint-ში, რომელიც იღებს input-ს, რაც მათ ყოველდღიური, აუცილებელი ცოდნას ხდის.