आप custom decorators कैसे बनाते हैं?

Question

Accepted Answer

NestJS आपको पुनः प्रयोज्य logic को समाहित करने के लिए **custom decorators** बनाने देता है — सबसे आम रूप से **parameter decorators** (request से data निकालने के लिए) और **metadata decorators** (guards/interceptors द्वारा पढ़े जाने वाले data को जोड़ने के लिए)। वे code को DRY और अभिव्यंजक रखते हैं।

## 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 करने के लिए मान लौटाता है। यह दोहराव वाली `@Req() req` + `req.user` पहुँच को एक स्वच्छ, पुनः प्रयोज्य `@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` संयोजन — एक metadata decorator जिसे एक guard `Reflector` के माध्यम से पढ़ता है — role-आधारित authorization के लिए आदर्श pattern है।

## Decorators को संयोजित करना

```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, अभिव्यंजक और अनुरक्षणीय रखने के लिए एक महत्वपूर्ण NestJS तकनीक है। **Custom parameter decorators** (`createParamDecorator`) आपको आम request-data निष्कर्षण (जैसे `@CurrentUser()`) को स्वच्छ, पुनः प्रयोज्य annotations में समाहित करने देते हैं — जो हर handler में `@Req() req` दोहराने और request object में गहराई तक जाने से कहीं बेहतर है। **Custom metadata decorators** (`SetMetadata`) NestJS के authorization patterns की नींव हैं: role-आधारित access control के लिए मानक `@Roles()` + `RolesGuard` (`Reflector` के माध्यम से पढ़ा गया) दृष्टिकोण पूरी तरह metadata decorators को समझने पर निर्भर करता है।

और **decorators को संयोजित करना** (`applyDecorators`) आपको संबंधित decorators (जैसे एक `@Auth()` जो guards और metadata को एक साथ लागू करता है) को संक्षिप्त, सुसंगत अनुप्रयोग के लिए बंडल करने देता है।

इन्हें कैसे बनाएँ यह समझना ही वह चीज़ है जो आपको अभिव्यंजक, आदर्श NestJS APIs बनाने और आम patterns (current-user injection, RBAC) को framework-अभीष्ट तरीके से implement करने देती है।

यह आपको केवल बिल्ट-इन decorators का उपयोग करने से ऊपर उठाकर framework की declarative शैली को अपनी application की आवश्यकताओं के लिए विस्तारित करने तक ले जाता है — असली NestJS projects में एक मूल्यवान, बार-बार लागू होने वाला कौशल।