Hur skapar du anpassade dekoratörer?

Question

Accepted Answer

NestJS låter dig skapa **anpassade dekoratörer** för att kapsla in återanvändbar logik — mest vanligt **parameterdekoratörer** (för att extrahera data från requesten) och **metadatadekoratörer** (för att bifoga data som läses av guards/interceptors). De håller koden DRY och uttrycksfull.

## Anpassad parameterdekoratör — extrahera requestdata

```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: dess funktion tar emot `ExecutionContext`, extraherar data och returnerar värdet som ska injiceras. Detta ersätter repetitivt `@Req() req` + `req.user`-åtkomst med en ren, återanvändbar `@CurrentUser()`.

## Parameterdekoratör med argument

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

## Anpassad metadatadekoratör (för guards/interceptors att läsa)

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

Kombinationen `@Roles()` + `RolesGuard` — en metadatadekoratör som en guard läser via `Reflector` — är det kanoniska mönstret för rollbaserad auktorisering.

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

## Varför det är viktigt

Att skapa anpassade dekoratörer är en viktig NestJS-teknik för att hålla koden DRY, uttrycksfull och underhållbar. **Anpassade parameterdekoratörer** (`createParamDecorator`) låter dig kapsla in vanlig requestdataextrahering (som `@CurrentUser()`) i rena, återanvändbara annotationer — mycket bättre än att upprepa `@Req() req` och gräva i requestobjektet i varje handler. **Anpassade metadatadekoratörer** (`SetMetadata`) är grunden för NestJS:s auktoriseringsmönster: standard `@Roles()` + `RolesGuard`-metoden (läst via `Reflector`) för rollbaserad åtkomstkontroll beror helt och hållet på att förstå metadatadekoratörer.

Och **komponering av dekoratörer** (`applyDecorators`) låter dig bunta relaterade dekoratörer (t.ex. en `@Auth()` som applicerar guards och metadata tillsammans) för koncis, konsekvent tillämpning.

Att förstå hur man skapar dessa är vad som låter dig bygga uttrycksfulla, idiomatiska NestJS-API:er och implementera vanliga mönster (current-user-injicering, RBAC) på det sätt som ramen är avsedd för. Det höjer dig från att bara använda inbyggda dekoratörer till att utöka ramverkels deklarativa stil för dina egna behov — en värdefull, ofta använd färdighet i verkliga NestJS-projekt.