Kako kreirate prilagođene dekoratore?

Question

Accepted Answer

NestJS vam omogućava kreiranje **prilagođenih dekoratora** kako biste enkapsulirali ponovno iskoristivu logiku — najčešće **parametarske dekoratore** (za ekstrakciju podataka iz zahtjeva) i **dekoratore metapodataka** (za pridruživanje podataka koje čitaju guards/interceptors). Oni čuvaju kod DRY i ekspresivan.

## Prilagođeni parametarski dekorator — ekstrakcija podataka zahtjeva

```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 parametarski dekorator: njegova funkcija prima `ExecutionContext`, ekstrahira podatke i vraća vrijednost za injektiranje. Ovo zamjenjuje repetitivni `@Req() req` + `req.user` pristup čistim, ponovno iskoristivim `@CurrentUser()`.

## Parametarski dekorator s argumentima

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

## Prilagođeni dekorator metapodataka (za čitanje 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));
  }
}
```

Kombinacija `@Roles()` + `RolesGuard` — dekorator metapodataka koji guard čita preko `Reflectora` — je kanonski obrazac za autorizaciju temeljenu na ulogama.

## Komponiranje dekoratora

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

## Zašto je to važno

Kreiranje prilagođenih dekoratora je važna NestJS tehnika za održavanje koda DRY, ekspresivnog i održivog. **Prilagođeni parametarski dekoratori** (`createParamDecorator`) vam omogućavaju enkapsuliranje česte ekstrakcije podataka zahtjeva (kao što je `@CurrentUser()`) u čiste, ponovno iskoristive anotacije — daleko bolje nego ponavljanje `@Req() req` i raskopavanje objekta zahtjeva u svakom handleru. **Prilagođeni dekoratori metapodataka** (`SetMetadata`) su temelj NestJS obrazaca autorizacije: standard `@Roles()` + `RolesGuard` pristup (čitan preko `Reflectora`) za kontrolu pristupa temeljenu na ulogama u potpunosti zavisi od razumijevanja dekoratora metapodataka.

I **komponiranje dekoratora** (`applyDecorators`) vam omogućava skupljanje povezanih dekoratora (npr. `@Auth()` koji primjenjuje guards i metapodatke zajedno) za sažetu, konzistentnu primjenu.

Razumijevanje kako kreirati ove je ono što vam omogućava gradnju ekspresivnih, idiomatskih NestJS API-ja i primjenu čestih obrazaca (injekcija trenutnog korisnika, RBAC) na način zamišljen okvirom — vrijedna, često primjenjivana vještina u stvarnim NestJS projektima.

To vas podiže iz samo korištenja ugrađenih dekoratora na proširenje deklarativnog stila okvirima za potrebe vaše aplikacije — vrijedna vještina u stvarnom razvoju s NestJS-om.