Hvordan lager du egendefinerte dekoratører?

Question

Accepted Answer

NestJS lar deg lage **egendefinerte dekoratører** for å kapsle inn gjenbrukbar logikk — oftest **parameterdekoratører** (for å trekke ut data fra forespørselen) og **metadatadekoratører** (for å legge til data som blir lest av guards/interceptors). De holder koden DRY og uttrykksrik.

## Egendefinert parameterdekoratør — trekk ut forespørselsdata

```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` bygger en parameterdekoratør: funksjonen mottaker `ExecutionContext`, trekker ut data, og returnerer verdien som skal injiseres. Dette erstatter repetitiv `@Req() req` + `req.user`-tilgang med en ren, gjenbrukbar `@CurrentUser()`.

## Parameterdekoratør med argumenter

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

## Egendefinert metadatadekoratør (for guards/interceptors å lese)

```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`-kombinasjonen — en metadatadekoratør som en guard leser via `Reflector` — er det kanoniske mønsteret for rollebasert autorisasjon.

## Sammensetning av dekoratører

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

## Hvorfor det betyr noe

Å lage egendefinerte dekoratører er en viktig NestJS-teknikk for å holde koden DRY, uttrykksrik og vedlikeholdbar. **Egendefinerte parameterdekoratører** (`createParamDecorator`) lar deg kapsle inn vanlig trekking av forespørselsdata (som `@CurrentUser()`) inn i rene, gjenbrukbare annoteringer — langt bedre enn å gjenta `@Req() req` og grave inn i forespørselsobjektet i hver handler. **Egendefinerte metadatadekoratører** (`SetMetadata`) er grunnlaget for NestJS's autentiseringsmønstre: den standard `@Roles()` + `RolesGuard`-tilnærmingen (lest via `Reflector`) for rollebasert tilgangskontroll avhenger helt og holdent av å forstå metadatadekoratører.

Og **sammensetning av dekoratører** (`applyDecorators`) lar deg samle relaterte dekoratører (f.eks. en `@Auth()` som bruker guards og metadata sammen) for knapp, konsekvent bruk.

Å forstå hvordan du lager disse er det som lar deg bygge uttrykksrike, idiomatiske NestJS API-er og implementere vanlige mønstre (current-user-injeksjon, RBAC) på den rammeverket-tiltenkte måten.

Det løfter deg fra bare å bruke innebygde dekoratører til å utvide rammeverkets deklarative stil for dine egne applikasjonsbehovet — en verdifull, hyppig brukt ferdighet i ekte NestJS-prosjekter.