Wie erstellen Sie benutzerdefinierte Decorators?

Question

Accepted Answer

NestJS ermöglicht es Ihnen, **benutzerdefinierte Decorators** zu erstellen, um wiederverwendbare Logik zu kapseln — am häufigsten **Parameter-Decorators** (zum Extrahieren von Daten aus der Anfrage) und **Metadata-Decorators** (zum Anfügen von Daten, die von Guards/Interceptors gelesen werden). Sie halten Code DRY und ausdrucksstark.

## Custom parameter decorator — extract 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` erstellt einen Parameter-Decorator: Die Funktion erhält den `ExecutionContext`, extrahiert Daten und gibt den Wert zur Injektion zurück. Dies ersetzt wiederholtes `@Req() req` + `req.user`-Zugreifen durch einen sauberen, wiederverwendbaren `@CurrentUser()`.

## Parameter decorator with arguments

```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 to read)

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

Die `@Roles()` + `RolesGuard`-Kombination — ein Metadata-Decorator, den ein Guard über `Reflector` liest — ist das kanonische Muster für rollenbasierte Autorisierung.

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

## Warum es wichtig ist

Das Erstellen benutzerdefinierter Decorators ist eine wichtige NestJS-Technik, um Code DRY, ausdrucksstark und wartbar zu halten. **Custom Parameter-Decorators** (`createParamDecorator`) ermöglichen es Ihnen, häufige Request-Daten-Extraktion (wie `@CurrentUser()`) in saubere, wiederverwendbare Annotationen zu kapseln — weit besser als das wiederholte `@Req() req` und das Durchwühlen des Request-Objekts in jedem Handler. **Custom Metadata-Decorators** (`SetMetadata`) sind die Grundlage von NestJS-Autorisierungsmustern: Der standardmäßige `@Roles()` + `RolesGuard`-Ansatz (gelesen über `Reflector`) für rollenbasierte Zugriffskontrolle hängt vollständig davon ab, Metadata-Decorators zu verstehen.

Und **Composing Decorators** (`applyDecorators`) ermöglicht es Ihnen, verwandte Decorators zu bündeln (z. B. ein `@Auth()`, das Guards und Metadata zusammen anwendet), um prägnante und konsistente Anwendung zu erreichen.

Das Verständnis, wie man diese erstellt, ermöglicht es Ihnen, ausdrucksstarke, idiomatische NestJS-APIs zu bauen und häufige Muster (Current-User-Injektion, RBAC) auf die vom Framework vorgesehene Weise zu implementieren.

Es hebt Sie vom bloßen Verwenden von Built-in-Decorators bis zum Erweitern des deklarativen Stils des Frameworks für die Anforderungen Ihrer eigenen Anwendung — eine wertvolle, häufig angewendete Fähigkeit in echten NestJS-Projekten.