तपाईंले कस्तो कस्टम डेकोरेटर कसरी बनाउनुहुन्छ?

Question

Accepted Answer

NestJS ले तपाईंलाई **कस्टम डेकोरेटर** बनाउन दिन्छ जसले पुनः प्रयोग योग्य तर्क समेट्छ — सबैभन्दा सामान्य **प्यारामिटर डेकोरेटर** (अनुरोध बाट डेटा निकाल्न) र **मेटाडेटा डेकोरेटर** (गार्डहरू/इन्टरसेप्टरहरू द्वारा पढिने डेटा संलग्न गर्न)। तिनीहरूले कोड DRY र अभिव्यक्तिशील राख्छन्।

## कस्टम प्यारामिटर डेकोरेटर — अनुरोध डेटा निकाल्नुहोस्

```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` ले प्यारामिटर डेकोरेटर बनाउँछ: यसको प्रकार्यले `ExecutionContext` प्राप्त गर्छ, डेटा निकाल्छ, र इन्जेक्ट गर्न मान फर्काउँछ। यसले दोहोरिने `@Req() req` + `req.user` पहुँचलाई सफा, पुनः प्रयोग योग्य `@CurrentUser()` को साथ प्रतिस्थापन गर्छ।

## तर्कको साथ प्यारामिटर डेकोरेटर

```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
```

## कस्टम मेटाडेटा डेकोरेटर (गार्डहरू/इन्टरसेप्टरहरूले पढ्नको लागि)

```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` संयोजन — एक मेटाडेटा डेकोरेटर जो गार्डले `Reflector` को माध्यमबाट पढ्छ — भूमिका-आधारित अधिकृतताको लागि विहित प्रतिमान हो।

## डेकोरेटरहरू रचना गर्दै

```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
```

## किन यो महत्त्वपूर्ण छ

कस्टम डेकोरेटर बनाउनु NestJS को कोड DRY, अभिव्यक्तिशील, र रक्षणीय राख्न एक महत्त्वपूर्ण गरविधि हो। **कस्टम प्यारामिटर डेकोरेटर** (`createParamDecorator`) ले तपाईंलाई सामान्य अनुरोध-डेटा निष्कर्षण (जस्तै `@CurrentUser()`) को सफा, पुनः प्रयोग योग्य एनोटेशनमा समेट्न दिन्छ — प्रत्येक ह्यान्डलरमा `@Req() req` दोहोर्याउनु र अनुरोध वस्तुमा खोदिनु भन्दा धेरै राम्रो। **कस्टम मेटाडेटा डेकोरेटर** (`SetMetadata`) NestJS को अधिकृतता प्यात्टर्नको आधार हो: मानक `@Roles()` + `RolesGuard` (Reflector को माध्यमबाट पढ्ने) भूमिका-आधारित पहुँच नियन्त्रणको लागि पूर्ण रूपमा मेटाडेटा डेकोरेटरहरूको समझमा निर्भर गर्छ।

र **डेकोरेटरहरू रचना गर्दै** (`applyDecorators`) ले तपाईंलाई सम्बन्धित डेकोरेटरहरू (उदा. `@Auth()` जो गार्डहरू र मेटाडेटा एकै साथ लागू गर्छ) को संक्षिप्त, सुसंगत अनुप्रयोगको लागि बण्डल गर्न दिन्छ।

यी कसरी बनाउने भन्ने कुरा समझ्नु तपाईंलाई अभिव्यक्तिशील, आदर्श NestJS API हरू बनाउन र सामान्य प्यात्टर्नहरू (वर्तमान-उपयोगकर्ता इन्जेक्सन, RBAC) फ्रेमवर्क-इच्छित तरिकामा लागू गर्न दिन्छ।

यो तपाईंलाई केवल निर्मित डेकोरेटरहरू प्रयोग गर्न गर्न्छु भन्ने अवस्थाबाट तपाईंको आवेदनको आवश्यकताहरूको लागि फ्रेमवर्कको घोषणात्मक शैली विस्तार गर्न उन्नत गर्छ — वास्तविक NestJS परियोजनाहरूमा एक मूल्यवान, बारम्बार-लागू गरिने कौशल।