Hvordan opretter du custom decorators?

Question

Accepted Answer

NestJS lader dig oprette **custom decorators** for at indkapsle genanvendelig logik — oftest **parameter decorators** (for at udtrække data fra requestet) og **metadata decorators** (for at knytte data, der læses af guards/interceptors). De holder koden DRY og udtryksfuld.

## Custom parameter decorator — udtrække request data

```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 parameter decorator: dens funktion modtager `ExecutionContext`, udtrækker data og returnerer værdien, der skal injiceres. Dette erstatter repetitiv `@Req() req` + `req.user` adgang med en ren, genanvendelig `@CurrentUser()`.

## Parameter decorator 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
```

## Custom metadata decorator (for guards/interceptors til at læse)

```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` kombinationen — en metadata decorator, som en guard læser via `Reflector` — er det kanoniske mønster for rollebaseret autorisering.

## Sammensætning af decorators

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

At oprette custom decorators er en vigtig NestJS-teknik for at holde koden DRY, udtryksfuld og vedligeholdelsesvenlig. **Custom parameter decorators** (`createParamDecorator`) lader dig indkapsle almindelig request-data udtrækning (som `@CurrentUser()`) i rene, genanvendelige annoterigner — langt bedre end at gentage `@Req() req` og grave i request-objektet i enhver handler. **Custom metadata decorators** (`SetMetadata`) er fundamentet for NestJS's autorisationsmønstre: den standard `@Roles()` + `RolesGuard` (læst via `Reflector`) tilgang til rollebaseret adgangskontrol afhænger helt og holdent af at forstå metadata decorators.

Og **sammensætning af decorators** (`applyDecorators`) lader dig bundtere relaterede decorators (f.eks. en `@Auth()`, der anvender guards og metadata sammen) for prægnant, konsistent anvendelse.

At forstå, hvordan man opretter disse, er det, der lader dig bygge udtryksfulde, idiomatiske NestJS API'er og implementere almindelige mønstre (current-user injicering, RBAC) på den framework-påtænkte måde.

Det løfter dig fra blot at bruge built-in decorators til at udvide frameworkets deklarative stil til dine egne applications behov — en værdifuld, hyppigt anvendt færdighed i rigtige NestJS-projekter.