Kako ustvarite po meri narejene dekoratorje?

Question

Accepted Answer

NestJS vam omogoči ustvarjanje **po meri narejenih dekoratorjev**, da enkapsalirate ponovno uporabno logiko — najpogosteje **parametrske dekoratorje** (za ekstrakcijo podatkov iz zahtevka) in **metapodatkovno dekoratorje** (za prilaganje podatkov, ki jih berejo varnostni postopki/interceptorji). Ohranijo kodo DRY in izrazno.

## Lastni parametrski dekorator — ekstrakcija podatkov zahtevka

```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` gradi parametrski dekorator: njegovima funkcija prejme `ExecutionContext`, ekstrahira podatke in vrne vrednost za injiciranje. To nadomesti ponavljajoče se `@Req() req` + `req.user` dostope s čistim, ponovno uporabnim `@CurrentUser()`.

## Parametrski dekorator z argumenti

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

## Lastni metapodatkovni dekorator (da ga varnostni postopki/interceptorji berejo)

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

Kombinacija `@Roles()` + `RolesGuard` — metapodatkovna dekorator, ki ga varnostni postopek bere prek `Reflector` — je kanoničen vzorec za avtorizacijo na osnovi vlog.

## Sestavljanje dekoratorjev

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

## Zakaj je to pomembno

Ustvarjanje po meri narejenih dekoratorjev je pomembna NestJS tehnika za ohranitev kode DRY, izrazne in vzdrževane. **Lastni parametrski dekoratorji** (`createParamDecorator`) vam omogočijo enkapsulacijo običajne ekstrakcije podatkov zahtevka (kot je `@CurrentUser()`) v čiste, ponovno uporabne anotacije — veliko boljše kot ponavljanje `@Req() req` in kopanje v objekt zahtevka v vsakem upravljalniku. **Lastni metapodatkovno dekoratorji** (`SetMetadata`) so temelj avtorizacijskih vzorcev NestJS: standardni pristop `@Roles()` + `RolesGuard` (bran prek `Reflector`) za nadzor dostopa na osnovi vlog je v celoti odvisen od razumevanja metapodatkovno dekoratorjev.

In **sestavljanje dekoratorjev** (`applyDecorators`) vam omogoči zbiranje povezanih dekoratorjev (npr. `@Auth()`, ki uporablja varnostne postopke in metapodatke skupaj) za jedrnat, dosledan aplikacijo.

Razumevanje, kako te ustvariti, je tisto, kar vam omogoči gradnjo izraznih, idiomatskih NestJS API-jev in implementacijo običajnih vzorcev (injiciranje trenutnega uporabnika, RBAC) na način, ki ga ima okvir v mislih.

To vas dvigne od zgolj uporabljanja vgrajenih dekoratorjev do razširitve deklarativnega sloga ogrodja za lastne potrebe aplikacije — dragocena, pogosto uporabljena veščina v resničnih NestJS projektih.