Hoe gebruikt NestJS decorators?

Question

Accepted Answer

NestJS is gebouwd rond **TypeScript decorators** — speciale `@`-voorafgegane aantekeningen die **metadata** aan classes, methoden en parameters toevoegen. NestJS leest deze metadata (via reflectie) om routing, dependency injection, validatie en meer declaratief in te stellen. Decorators zijn overal in Nest.

## Class decorators — definieer de rol van een class

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

Class decorators verklaren wat een class *is* in de NestJS-architectuur (controller, provider, module) en configureren deze.

## Method decorators — map routes en pas gedrag toe

```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() {}
```

## Parameter decorators — extraheer request-gegevens

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

Parameter decorators halen declaratief precies de gegevens uit het request die u nodig hebt — geen handmatig `req`-parsing.

## Property/validation decorators (op DTOs)

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

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

## Waarom decorators? Declaratieve metadata

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

## Aangepaste decorators

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

## Waarom het belangrijk is

Decorators zijn de definiërende syntactische eigenschap van NestJS — het hele framework is eromheen georganiseerd, dus begrijpen hoe ze werken is essentieel voor het lezen en schrijven van NestJS-code.

Ze bieden een **declaratieve**, metadata-gestuurde benadering: in plaats van imperatieve configuratie annoteert u classes, methoden en parameters om routing (`@Controller`, `@Get`), dependency injection (`@Injectable`), cross-cutting gedrag (`@UseGuards`, `@UseInterceptors`) en validatie (`@IsEmail`) te declareren precies waar ze van toepassing zijn — beknopt en leesbaar.

Dit metadata-via-reflectie mechanisme (hetzelfde idee achter Angular en Java/Spring aantekeningen) is wat NestJS's schone, gestructureerde stijl mogelijk maakt.

Het herkennen van de categorieën (class-, methoden-, parameter-, propertydecorators), het kennen van de veelgebruikte en het kunnen creëren van aangepaste decorators is fundamentele NestJS-vlotheid — decorators zijn hoe bijna alle functies worden uitgedrukt, waardoor ze een van de eerste en belangrijkste dingen zijn die je moet begrijpen in het framework.