NestJS decorators-ஐ எவ்வாறு பயன்படுத்துகிறது?

Question

Accepted Answer

NestJS **TypeScript decorators**-ஐ சுற்றி கட்டமைக்கப்பட்டுள்ளது — classes, methods, மற்றும் parameters-உடன் **metadata**-ஐ இணைக்கும் சிறப்பு `@`-prefixed annotations. NestJS இந்த metadata-ஐ (reflection மூலம்) படித்து routing, dependency injection, validation, மற்றும் பலவற்றை declarative முறையில் இணைக்கிறது. Decorators Nest-இல் எங்கும் உள்ளன.

## Class decorators — ஒரு class-இன் பங்கை வரையறுக்கின்றன

```ts
@Controller("users")     // this class is a CONTROLLER, prefix /users
export class UsersController {}

@Injectable()            // this class is a PROVIDER (injectable)
export class UsersService {}

@Module({ ... })         // this class is a MODULE
export class UsersModule {}
```

Class decorators NestJS architecture-இல் ஒரு class *என்ன* என்பதை அறிவித்து (controller, provider, module) அதை configure செய்கின்றன.

## Method decorators — routes-ஐ map செய்து behavior-ஐ பயன்படுத்துகின்றன

```ts
@Get()                   // GET request handler
@Post()                  // POST handler
@Get(":id")              // GET /users/:id
@HttpCode(204)           // set the response status code
@UseGuards(AuthGuard)    // apply a guard to this route
@UseInterceptors(LoggingInterceptor)
findAll() {}
```

## Parameter decorators — request data-ஐ எடுக்கின்றன

```ts
findOne(
  @Param("id") id: string,       // route parameter
  @Query("sort") sort: string,   // query string
  @Body() dto: CreateUserDto,    // request body
  @Headers("auth") auth: string, // header
) {}
```

Parameter decorators உங்களுக்கு தேவையான data-ஐ மட்டும் request-இலிருந்து declarative முறையில் எடுக்கின்றன — manual `req` parsing இல்லை.

## Property/validation decorators (DTOs-இல்)

```ts
export class CreateUserDto {
  @IsEmail()                     // validation rules (class-validator)
  email: string;

@IsString()
  @MinLength(8)
  password: string;
}
```

## Decorators ஏன்? Declarative metadata

```text
Decorators attach METADATA that NestJS reads at runtime (via reflection) to:
  ✓ Register routes (@Get, @Controller)
  ✓ Wire dependency injection (@Injectable, @Inject)
  ✓ Apply guards/interceptors/pipes (@UseGuards, etc.)
  ✓ Validate input (@IsEmail, @IsString)
→ Behavior is declared WHERE it applies, concisely and readably.
```

## Custom decorators

```ts
// you can create your own — e.g. extract the current user from the request
export const CurrentUser = createParamDecorator((data, ctx) =>
  ctx.switchToHttp().getRequest().user
);
// usage: findProfile(@CurrentUser() user: User) {}
```

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

Decorators என்பது NestJS-இன் வரையறுக்கும் syntactic feature — முழு framework-ம் அவற்றை சுற்றி ஒழுங்கமைக்கப்பட்டுள்ளது, அதனால் அவை எவ்வாறு செயல்படுகின்றன என்பதை புரிந்துகொள்வது எந்த NestJS code-ஐயும் படிக்கவும் எழுதவும் அத்தியாவசியம்.

அவை ஒரு **declarative**, metadata-driven அணுகுமுறையை வழங்குகின்றன: imperative configuration-க்கு பதிலாக, நீங்கள் classes, methods, மற்றும் parameters-ஐ annotate செய்து routing (`@Controller`, `@Get`), dependency injection (`@Injectable`), cross-cutting behavior (`@UseGuards`, `@UseInterceptors`), மற்றும் validation (`@IsEmail`)-ஐ அவை பயன்படும் இடத்திலேயே அறிவிக்கிறீர்கள் — சுருக்கமாகவும் படிக்கக்கூடியதாகவும்.

இந்த metadata-via-reflection mechanism (Angular மற்றும் Java/Spring annotations-க்கு பின்னால் உள்ள அதே யோசனை) தான் NestJS-இன் சுத்தமான, கட்டமைக்கப்பட்ட பாணியை இயலச்செய்கிறது.

வகைகளை (class, method, parameter, property decorators) அடையாளம் காண்பது, பொதுவானவற்றை அறிவது, மற்றும் custom decorators-ஐ உருவாக்க முடிவது அடிப்படை NestJS தேர்ச்சி — decorators தான் கிட்டத்தட்ட ஒவ்வொரு feature-ம் வெளிப்படுத்தப்படும் விதம், அவற்றை framework-இல் புரிந்துகொள்ள வேண்டிய முதல் மற்றும் மிக முக்கியமான விஷயங்களில் ஒன்றாக ஆக்குகிறது.