Wie verwendet NestJS Dekoratoren?

Question

Accepted Answer

NestJS ist um **TypeScript-Dekoratoren** herum aufgebaut — spezielle `@`-präfixierte Annotationen, die **Metadaten** an Klassen, Methoden und Parameter anhängen. NestJS liest diese Metadaten (über Reflection), um Routing, Dependency Injection, Validierung und vieles mehr deklarativ zu verbinden. Dekoratoren sind überall in Nest.

## Klassendekoratoren — definieren die Rolle einer Klasse

```ts
@Controller("users")     // this class is a CONTROLLER, prefix /users
export class UsersController {}

@Injectable()            // this class is a PROVIDER (injectable)
export class UsersService {}

@Module({ ... })         // this class is a MODULE
export class UsersModule {}
```

Klassendekoratoren deklarieren, was eine Klasse *in* der NestJS-Architektur ist (Controller, Provider, Module) und konfigurieren sie.

## Methodendekoratoren — ordnen Routen zu und wenden Verhalten an

```ts
@Get()                   // GET request handler
@Post()                  // POST handler
@Get(":id")              // GET /users/:id
@HttpCode(204)           // set the response status code
@UseGuards(AuthGuard)    // apply a guard to this route
@UseInterceptors(LoggingInterceptor)
findAll() {}
```

## Parameterdekoratoren — extrahieren Anfragedaten

```ts
findOne(
  @Param("id") id: string,       // route parameter
  @Query("sort") sort: string,   // query string
  @Body() dto: CreateUserDto,    // request body
  @Headers("auth") auth: string, // header
) {}
```

Parameterdekoratoren extrahieren deklarativ genau die Daten aus der Anfrage, die Sie benötigen — ohne manuelles `req`-Parsing.

## Eigenschafts-/Validierungsdekoratoren (auf DTOs)

```ts
export class CreateUserDto {
  @IsEmail()                     // validation rules (class-validator)
  email: string;

@IsString()
  @MinLength(8)
  password: string;
}
```

## Warum Dekoratoren? Deklarative Metadaten

```text
Decorators attach METADATA that NestJS reads at runtime (via reflection) to:
  ✓ Register routes (@Get, @Controller)
  ✓ Wire dependency injection (@Injectable, @Inject)
  ✓ Apply guards/interceptors/pipes (@UseGuards, etc.)
  ✓ Validate input (@IsEmail, @IsString)
→ Behavior is declared WHERE it applies, concisely and readably.
```

## Benutzerdefinierte Dekoratoren

```ts
// you can create your own — e.g. extract the current user from the request
export const CurrentUser = createParamDecorator((data, ctx) =>
  ctx.switchToHttp().getRequest().user
);
// usage: findProfile(@CurrentUser() user: User) {}
```

## Warum es wichtig ist

Dekoratoren sind das definierende syntaktische Merkmal von NestJS — das gesamte Framework ist um sie herum organisiert, daher ist das Verständnis ihrer Funktionsweise für das Lesen und Schreiben von NestJS-Code unerlässlich.

Sie bieten einen **deklarativen**, metadatengesteuerten Ansatz: Statt imperativer Konfiguration annotieren Sie Klassen, Methoden und Parameter, um Routing (`@Controller`, `@Get`), Dependency Injection (`@Injectable`), querschnittliches Verhalten (`@UseGuards`, `@UseInterceptors`) und Validierung (`@IsEmail`) genau dort zu deklarieren, wo sie gelten — prägnant und lesbar.

Dieser Metadaten-via-Reflection-Mechanismus (die gleiche Idee hinter Angular und Java/Spring-Annotationen) ist das, was NestJS's sauberen, strukturierten Stil ermöglicht.

Die Kategorien zu erkennen (Klassen-, Methoden-, Parameter-, Eigenschaftsdekoratoren), die häufigen zu kennen und benutzerdefinierte Dekoratoren erstellen zu können, ist grundlegende NestJS-Sprachkompetenz — Dekoratoren sind die Art und Weise, wie fast jedes Feature ausgedrückt wird, was sie zu einer der ersten und wichtigsten Dinge macht, um sie im Framework zu verstehen.