ਤੁਸੀਂ ਕਸਟਮ ਡੇਕੋਰੇਟਰ ਕਿਵੇਂ ਬਣਾਉਂਦੇ ਹੋ?

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

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

ਕਸਟਮ ਡੇਕੋਰੇਟਰ ਬਣਾਉਣਾ ਕੋਡ ਨੂੰ DRY, ਸਪਸ਼ਟ, ਅਤੇ ਰਖ-ਭਾਲ ਲਈ ਸਮਰੱਥ ਬਣਾਣ ਲਈ ਇੱਕ ਮਹੱਤਵਪੂਰਨ NestJS ਤਕਨੀਕ ਹੈ। **ਕਸਟਮ ਪੈਰਾਮੀਟਰ ਡੇਕੋਰੇਟਰ** (`createParamDecorator`) ਆਮ ਬੇਨਤੀ-ਡਾਟਾ ਕੱਢਣ (ਜਿਵੇਂ `@CurrentUser()`) ਨੂੰ ਸਾਫ, ਮੁੜ ਵਰਤੋ ਜਾਣ ਵਾਲੇ ਐਨੋਟੇਸ਼ਨ ਵਿੱਚ ਬੰਦ ਕਰਨ ਦਿੰਦੇ ਹਨ — ਹਰ ਹ੍ਰੈਂਡਲਰ ਵਿੱਚ `@Req() req` ਦੁਹਰਾਉਣ ਅਤੇ ਬੇਨਤੀ ਵਸਤੂ ਵਿੱਚ ਖੋਦਣ ਨਾਲੋਂ ਬਹੁਤ ਬਿਹਤਰ। **ਕਸਟਮ ਮੈਟਾਡੇਟਾ ਡੇਕੋਰੇਟਰ** (`SetMetadata`) NestJS ਦੇ ਅਧਿਕਾਰ ਪੈਟਰਨ ਦੀ ਬੁਨਿਆਦ ਹਨ: ਮਾਨਕ `@Roles()` + `RolesGuard` (ਦੁਆਰਾ ਪੜ੍ਹਿਆ `Reflector`) ਰੋਲ-ਅਧਾਰਿਤ ਲਾਗੂ ਕਰਨ ਦਾ ਢੰਗ ਪੂਰੀ ਤਰ੍ਹਾਂ ਮੈਟਾਡੇਟਾ ਡੇਕੋਰੇਟਰ ਨੂੰ ਸਮਝਣ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।

ਅਤੇ **ਡੇਕੋਰੇਟਰ ਬਣਾਉਣਾ** (`applyDecorators`) ਤੁਹਾਨੂੰ ਸੰਬੰਧਿਤ ਡੇਕੋਰੇਟਰ (ਜਿਵੇਂ ਇੱਕ `@Auth()` ਜੋ ਗਾਰਡ ਅਤੇ ਮੈਟਾਡੇਟਾ ਇਕਾਈ ਲਾਗੂ ਕਰਦਾ ਹੈ) ਬੰਡਲ ਕਰਨ ਦਿੰਦਾ ਹੈ ਸੰਖੇਪ, ਸਥਿਰ ਅਨੁਪ੍ਰਯੋਗ ਲਈ।
urgh ਹਸ ਤੁਹਾਨੂੰ ਬਸ ਬਿਲਟ-ਇਨ ਡੇਕੋਰੇਟਰ ਵਰਤਣ ਤੋਂ ਆਪਣੇ ਐਪਲੀਕੇਸ਼ਨ ਦੀਆਂ ਲੋੜਾਂ ਲਈ ਫ੍ਰੇਮਵਰਕ ਦੀ ਘੋਸ਼ਣਾ ਸ਼ੈਲੀ ਵਧਾਉਣ ਤੱਕ ਲਿਆਉਂਦਾ ਹੈ — ਅਸਲ NestJS ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਇੱਕ ਕੀਮਤੀ, ਅਕਸਰ-ਲਾਗੂ ਕੀਤੀ ਹੁਨਰ।