Hogyan hozol létre egyéni dekorátorokat?

Question

Accepted Answer

A NestJS lehetővé teszi **egyéni dekorátorok** létrehozását az újrafelhasználható logika beágyazásához — leggyakrabban **paraméter dekorátorok** (az adatok kinyeréséhez a kérésből) és **metaadat dekorátorok** (az adatok csatolásához, amelyeket guardok/interceptorok olvasnak). Ezek a kód DRY és kifejezően tartják.

## Egyéni paraméter dekorátor — kérésadatok kinyerése

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

A `createParamDecorator` egy paraméter dekorátort épít fel: a függvénye megkapja az `ExecutionContext`-et, kinyeri az adatokat, és visszaadja az injektálandó értéket. Ez lecseréli az ismétlődő `@Req() req` + `req.user` hozzáférést egy tiszta, újrafelhasználható `@CurrentUser()`-re.

## Paraméter dekorátor argumentumokkal

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

## Egyéni metaadat dekorátor (guardok/interceptorok számára, hogy olvassák)

```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));
  }
}
```

A `@Roles()` + `RolesGuard` kombináció — egy metaadat dekorátor, amelyet egy guard a `Reflector` segítségével olvas — a kanonikus minta a szerepalapú hitelesítéshez.

## Dekorátorok összekapcsolása

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

## Miért fontos ez

Az egyéni dekorátorok létrehozása egy fontos NestJS technika a kód DRY, kifejezően és karbantarthatóan tartásához. **Az egyéni paraméter dekorátorok** (`createParamDecorator`) lehetővé teszik a gyakori kérésadatok-kinyerés beágyazását (például `@CurrentUser()`) tiszta, újrafelhasználható annotációkba — sokkal jobb, mint az ismételt `@Req() req` és a kérés objektumba való merülés minden kezelőben. **Az egyéni metaadat dekorátorok** (`SetMetadata`) a NestJS hitelesítési mintáinak alapja: a szabványos `@Roles()` + `RolesGuard` (a `Reflector` által olvasott) megközelítés a szerepalapú hozzáférés-vezérléshez teljes mértékben a metaadat dekorátorok megértésétől függ.

Az **dekorátorok összekapcsolása** (`applyDecorators`) lehetővé teszi a kapcsolódó dekorátorok összecsomagolását (pl. egy `@Auth()`, amely guardokat és metaadatokat alkalmaz együtt) a tömör, konzisztens alkalmazáshoz.

Annak megértése, hogyan kell ezeket létrehozni, az, ami lehetővé teszi kifejezően, idiomatikus NestJS API-kat és gyakori mintákat (jelenlegi felhasználó injekciója, RBAC) a keretrendszer szándéka szerinti megvalósítást. Az Ön kódjának beépített dekorátoroktól való továbbhaladása az egyéni dekorátorok köré való kiterjesztéshez — értékes, gyakran alkalmazott készség a valódi NestJS projektekben.