మీరు ఎలా కస్టమ్ డెకోరేటర్‌లను సృష్టిస్తారు?

Question

Accepted Answer

NestJS మీకు **కస్టమ్ డెకోరేటర్‌లను** సృష్టించడానికి అనుమతిస్తుంది — అవి పునర్వినియోగపడే లాజిక్‌ను సంకేతీకరించడానికి సహాయపడతాయి. అవి సాధారణంగా **parameter decorators** (అభ్యర్థనից డేటాను సంగ్రహించడానికి) మరియు **metadata decorators** (guards/interceptors ద్వారా చదవబడే డేటాను జత చేయడానికి). ఇవి కోడ్‌ను DRY మరియు వ్యక్తీకరణాత్మకంగా ఉంచుతాయి.

## కస్టమ్ parameter decorator — అభ్యర్థన డేటాను సంగ్రహించండి

```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 ను నిర్మిస్తుంది: దానికి ఫంక్షన్ `ExecutionContext`ను స్వీకరిస్తుంది, డేటాను సంగ్రహిస్తుంది మరియు inject చేయడానికి విలువను అందిస్తుంది. ఇది పునరావృత్తమైన `@Req() req` + `req.user` యాక్సెస్‌ను శుభ్రమైన, పునర్వినియోగపడే `@CurrentUser()`తో భర్తీ చేస్తుంది.

## ఆర్గ్యుమెంట్‌లతో 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
```

## కస్టమ్ 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-based authorization కోసం కానోనికల్ నమూనా.

## డెకోరేటర్‌లను కూపిజ్ చేయడం

```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 పద్ధతి. **కస్టమ్ parameter decorators** (`createParamDecorator`) సాధారణ request-data extraction (like `@CurrentUser()`) ను శుభ్రమైన, పునర్వినియోగపడే annotations లో సంకేతీకరించడానికి మీకు అనుమతిస్తుంది — ప్రతి handler లో `@Req() req` ను పునరావృత్తం చేయడం మరియు request object లోకి త్రవ్వడం కంటే చాలా మంచిది. **కస్టమ్ metadata decorators** (`SetMetadata`) NestJS యొక్క authorization patterns యొక్క ఆధారం: role-based access control కోసం స్ట్యాండర్డ్ `@Roles()` + `RolesGuard` (read via `Reflector`) విధానం పూర్తిగా metadata decorators ను అర్థం చేసుకోవడపై ఆధారపడి ఉంటుంది.

మరియు **composing decorators** (`applyDecorators`) సంబంధిత decorators (e.g. ఒక `@Auth()` దీనిగార్డ్‌లు మరియు metadata ను కలిసి వర్తింపజేస్తుంది) ను సంక్షిప్త, స్థిరమైన అనువర్తనం కోసం కట్టిపడతాయి.

ఈ విషయాలను ఎలా సృష్టించాలో అర్థం చేసుకోవడం మీకు వ్యక్తీకరణాత్మక, idiomatic NestJS APIs ను నిర్మించడానికి మరియు సాధారణ నమూనాలను (current-user injection, RBAC) framework-intended విధానంలో అమలు చేయడానికి అనుమతిస్తుంది.

ఇది మిమ్మల్ని కేవలం నిర్మించిన decorators ను ఉపయోగించడం నుండి మీ సంపత్కి యొక్క declarative style ను పొడిగించేందుకు — ఒక విలువైన, తరచుగా-వర్తించిన నైపుణ్యం వాస్తవ NestJS projects లో.