Custom decorators-ஐ எவ்வாறு உருவாக்குகிறீர்கள்?

Question

Accepted Answer

NestJS reusable logic-ஐ உள்ளடக்க **custom decorators**-ஐ உருவாக்க அனுமதிக்கிறது — மிகவும் பொதுவாக **parameter decorators** (request-இலிருந்து data-ஐ எடுக்க) மற்றும் **metadata decorators** (guards/interceptors-ஆல் படிக்கப்படும் data-ஐ இணைக்க). அவை code-ஐ DRY ஆகவும் expressive ஆகவும் வைத்திருக்கின்றன.

## Custom parameter decorator — request data-ஐ எடுத்தல்

```ts
import { createParamDecorator, ExecutionContext } from "@nestjs/common";

// extract the authenticated user (attached to the request by an auth guard)
export const CurrentUser = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    return request.user;        // return whatever you want injected
  },
);

// usage — clean and readable
@Get("profile")
getProfile(@CurrentUser() user: User) {     // instead of @Req() req and req.user
  return user;
}
```

`createParamDecorator` ஒரு parameter decorator-ஐ உருவாக்குகிறது: அதன் function `ExecutionContext`-ஐ பெற்று, data-ஐ எடுத்து, inject செய்ய வேண்டிய value-ஐ திருப்பி அனுப்புகிறது. இது மீண்டும் மீண்டும் வரும் `@Req() req` + `req.user` அணுகலை ஒரு சுத்தமான, reusable `@CurrentUser()`-உடன் மாற்றுகிறது.

## arguments-உடன் parameter decorator

```ts
// extract a specific property: @CurrentUser("email")
export const CurrentUser = createParamDecorator(
  (data: string, ctx: ExecutionContext) => {
    const user = ctx.switchToHttp().getRequest().user;
    return data ? user?.[data] : user;   // `data` is the argument passed to the decorator
  },
);
// @CurrentUser("email") email: string  → injects just user.email
```

## Custom metadata decorator (guards/interceptors படிக்க)

```ts
import { SetMetadata } from "@nestjs/common";

// a @Roles() decorator that ATTACHES metadata to a route
export const Roles = (...roles: string[]) => SetMetadata("roles", roles);

// usage
@Roles("admin", "editor")
@Get("users")
listUsers() {}
```

```ts
// a guard reads the metadata via Reflector
@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector) {}
  canActivate(ctx: ExecutionContext): boolean {
    const roles = this.reflector.get<string[]>("roles", ctx.getHandler());   // read it
    const { user } = ctx.switchToHttp().getRequest();
    return !roles || roles.some(r => user.roles?.includes(r));
  }
}
```

`@Roles()` + `RolesGuard` இணைப்பு — ஒரு guard `Reflector` மூலம் படிக்கும் ஒரு metadata decorator — role-based authorization-க்கான canonical pattern.

## decorators-ஐ composing செய்தல்

```ts
import { applyDecorators } from "@nestjs/common";
// bundle multiple decorators into one reusable decorator
export function Auth(...roles: string[]) {
  return applyDecorators(SetMetadata("roles", roles), UseGuards(AuthGuard, RolesGuard));
}
// usage: @Auth("admin")  — applies metadata + guards in one decorator
```

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

Custom decorators-ஐ உருவாக்குவது code-ஐ DRY, expressive, மற்றும் maintainable ஆக வைத்திருக்கும் ஒரு முக்கியமான NestJS நுட்பம். **Custom parameter decorators** (`createParamDecorator`) பொதுவான request-data எடுத்தலை (`@CurrentUser()` போன்றது) சுத்தமான, reusable annotations ஆக உள்ளடக்க அனுமதிக்கின்றன — ஒவ்வொரு handler-இலும் `@Req() req`-ஐ மீண்டும் மீண்டும் சொல்லி request object-ஐ தோண்டுவதை விட மிகவும் சிறந்தது. **Custom metadata decorators** (`SetMetadata`) NestJS-இன் authorization patterns-இன் அடித்தளம்: role-based access control-க்கான standard `@Roles()` + `RolesGuard` (`Reflector` மூலம் படிக்கப்படும்) அணுகுமுறை முழுவதும் metadata decorators-ஐ புரிந்துகொள்வதை சார்ந்துள்ளது.

மற்றும் **decorators-ஐ composing செய்தல்** (`applyDecorators`) தொடர்புடைய decorators-ஐ (எ.கா. guards மற்றும் metadata-ஐ ஒன்றாக பயன்படுத்தும் ஒரு `@Auth()`) சுருக்கமான, ஒத்திசைவான பயன்பாட்டிற்காக bundle செய்ய அனுமதிக்கிறது.

இவற்றை எவ்வாறு உருவாக்குவது என்பதை புரிந்துகொள்வது தான் expressive, idiomatic NestJS APIs-ஐ உருவாக்கவும் பொதுவான patterns-ஐ (current-user injection, RBAC) framework விரும்பிய வழியில் implement செய்யவும் உங்களை அனுமதிக்கிறது.

இது built-in decorators-ஐ வெறுமனே பயன்படுத்துவதிலிருந்து framework-இன் declarative பாணியை உங்கள் சொந்த application-இன் தேவைகளுக்கு நீட்டிப்பதற்கு உங்களை உயர்த்துகிறது — உண்மையான NestJS projects-இல் மதிப்புமிக்க, அடிக்கடி பயன்படுத்தப்படும் திறன்.