તમે કસ્ટમ ડેકોરેટર્સ કેવી રીતે બનાવો છો?

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 APIs બનાવવા અને સામાન્ય પેટર્ન (વર્તમાન-વપરાશી ઇનજેક્શન, RBAC) ફ્રેમવર્ક-ઇચ્છનીય અભિગમ સાથે લાગુ કરવા દે છે.

તે તમને ફક્ત બિલ્ટ-ઇન ડેકોરેટર્સ ઉપયોગ કરતા પાસેથી આગળ લઈ જાય છે તમારા પોતાના એપ્લીકેશનની જરૂરિયાતો માટે ફ્રેમવર્કની ઘોષણાત્મક શૈલી વિસ્તૃત કરવા માટે — વાસ્તવિક NestJS પ્રોજેક્ટ્સમાં એક મૂલ્યવાન, વારંવાર-લાગુ કરાયેલ કુશળતા.