NestJS-இல் DTOs என்றால் என்ன?

Question

Accepted Answer

ஒரு **DTO (Data Transfer Object)** என்பது உங்கள் API-க்கு அனுப்பப்படும் அல்லது அதிலிருந்து வரும் **data-இன் வடிவத்தை** வரையறுக்கும் ஒரு class ஆகும் — பொதுவாக ஒரு request body-இன் கட்டமைப்பு. DTOs type safety-ஐ வழங்குகின்றன, endpoints-க்கான தெளிவான contract ஆக செயல்படுகின்றன, மற்றும் (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 என்பது எதிர்பார்க்கப்படும் data-ஐ விவரிக்கும் ஒரு plain class, ஒவ்வொரு field-ம் பூர்த்தி செய்ய வேண்டிய விதிகளை குறிப்பிடும் **validation decorators**-உடன் (`class-validator`-இலிருந்து).

## ஒரு controller-இல் ஒரு DTO-ஐ பயன்படுத்துதல்

```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-ஐ type செய்கிறது மற்றும் — validation pipe enable செய்யப்பட்டால் — உங்கள் handler இயங்குவதற்கு முன் அதை தானாகவே validate செய்கிறது.

## தானியங்கி validation-ஐ enable செய்தல்

```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-க்கு எதிராக தானாகவே validate செய்கிறது — validation தோல்வியடைந்தால் உங்கள் code இயங்குவதற்கு முன்பே விவரங்களுடன் ஒரு 400 error-ஐ திருப்பி அனுப்புகிறது.

## 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 ஏற்றுக்கொள்ளும்/திருப்பி அனுப்பும் விஷயத்தை குறிக்கின்றன, internal storage-இலிருந்து decouple செய்யப்பட்டுள்ளன.

## மாறுபாடுகள் மற்றும் மறுபயன்பாடு

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

## இது ஏன் முக்கியம்

DTOs என்பது உங்கள் endpoints-க்கு type safety, தெளிவான API contracts, மற்றும் தானியங்கி validation-ஐ கொண்டுவரும் ஒரு முக்கியமான NestJS pattern.

அவை ஒரு endpoint எந்த data-ஐ ஏற்றுக்கொள்கிறது (request வடிவம்) என்பதை சரியாக வரையறுக்கின்றன, உங்களுக்கு compile-time typing-ஐ வழங்கி self-documenting contracts ஆக செயல்படுகின்றன.

முக்கியமாக, `class-validator` decorators மற்றும் `ValidationPipe`-உடன் இணைந்து, அவை **தானியங்கி input validation**-ஐ இயலச்செய்கின்றன — தவறான அல்லது தீங்கிழைக்கும் requests உங்கள் business logic-ஐ அடைவதற்கு *முன்* தெளிவான errors-உடன் நிராகரிக்கப்படுகின்றன, இது security மற்றும் robustness-க்கு அத்தியாவசியம் (`whitelist` option எதிர்பாராத properties-ஐயும் strip செய்கிறது).

DTOs-ஐ புரிந்துகொள்வது, validation விதிகளை எவ்வாறு சேர்ப்பது, validation pipe-ஐ எவ்வாறு enable செய்வது, மற்றும் **DTOs-ஐ database entities-இலிருந்து தனியாக வைத்திருக்கும்** முக்கியமான கொள்கை (API contract-ஐ internal storage-இலிருந்து decoupling) என்பது பாதுகாப்பான, நன்கு கட்டமைக்கப்பட்ட, maintainable NestJS APIs-ஐ உருவாக்க அடிப்படை.

DTOs input ஏற்றுக்கொள்ளும் கிட்டத்தட்ட ஒவ்வொரு endpoint-இலும் தோன்றுகின்றன, அவற்றை தினசரி, அத்தியாவசிய அறிவாக ஆக்குகின்றன.