Hoe maak je aangepaste decorators?

Question

Accepted Answer

NestJS laat je **aangepaste decorators** creëren om herbruikbare logica in te kapselen — meestal **parameter decorators** (om gegevens uit het request te extraheren) en **metadata decorators** (om gegevens toe te voegen die guards/interceptors lezen). Ze houden code DRY en expressief.

## Aangepaste parameter decorator — request gegevens extraheren

```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` bouwt een parameter decorator: de functie ontvangt de `ExecutionContext`, extraheert gegevens, en retourneert de waarde om in te injecteren. Dit vervangt repetitieve `@Req() req` + `req.user` toegang met een schone, herbruikbare `@CurrentUser()`.

## Parameter decorator met argumenten

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

## Aangepaste metadata decorator (voor guards/interceptors om te lezen)

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

De `@Roles()` + `RolesGuard` combinatie — een metadata decorator die een guard leest via `Reflector` — is het canonieke patroon voor op rollen gebaseerde autorisatie.

## Decorators samenstellen

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

## Waarom het belangrijk is

Het creëren van aangepaste decorators is een belangrijke NestJS-techniek om code DRY, expressief en onderhoudbaar te houden. **Aangepaste parameter decorators** (`createParamDecorator`) laten je veelvoorkomende request-data extractie (zoals `@CurrentUser()`) in schone, herbruikbare annotaties inkapsulen — veel beter dan het herhalen van `@Req() req` en in elk handler in het request object graven. **Aangepaste metadata decorators** (`SetMetadata`) zijn de basis van NestJS's autorisatiepatronen: de standaard `@Roles()` + `RolesGuard` (gelezen via `Reflector`) aanpak voor op rollen gebaseerde toegangscontrole hangt volledig af van het begrijpen van metadata decorators.

En **decorators samenstellen** (`applyDecorators`) laat je gerelateerde decorators bundelen (bijv. een `@Auth()` die guards en metadata samen toepast) voor beknopte, consistente toepassing.

Begrijpen hoe je deze maakt, laat je expressieve, idiomatische NestJS API's bouwen en veelvoorkomende patronen (current-user injectie, RBAC) op de door het framework bedoelde manier implementeren.

Het brengt je van louter het gebruiken van ingebouwde decorators naar het uitbreiden van de declaratieve stijl van het framework voor je eigen applicatie's behoeften — een waardevolle, frequent toegepaste vaardigheid in echte NestJS-projecten.