Wat zijn decorators en hoe worden ze gebruikt?

Question

Accepted Answer

A **decorator** is een speciale declaratie (`@name`) die gedrag of metadata toevoegt aan een klasse, methode, eigenschap of parameter. Het is een functie die de runtime aanroept met het gedecoreerde doel, waarmee u declaratief kunt verpakken of annoteren.

```ts
// A simple method decorator that logs calls
function log(target: any, key: string, desc: PropertyDescriptor) {
  const original = desc.value;
  desc.value = function (...args: any[]) {     // wrap the original method
    console.log(`calling ${key} with`, args);
    return original.apply(this, args);
  };
}

class Service {
  @log
  fetch(id: number) { return { id }; }
}
new Service().fetch(1); // logs "calling fetch with [1]" then runs
```

De decorator ontving de methodedescriptor en verving deze met een wrapper — cross-cutting gedrag (logging, caching, timing) zonder de methodebody aan te raken.

## Waar u ze het meest ziet: frameworks

```ts
@Controller("users")          // NestJS — declares a route controller
export class UsersController {
  @Get(":id")                 // maps GET /users/:id
  findOne(@Param("id") id: string) { return id; } // param decorator injects the route param
}

@Entity()                     // TypeORM — maps a class to a DB table
class User { @Column() name: string; }
```

NestJS, Angular, TypeORM en class-validator zijn gebouwd rond decorators voor DI, routing, ORM-mapping en validatie.

## Twee smaken (belangrijk)

```json
{ "experimentalDecorators": true, "emitDecoratorMetadata": true }
```

De **legacy (experimentele)** decorators hierboven zijn wat Nest/Angular/TypeORM vandaag de dag gebruiken. Er zijn ook de nieuwere **TC39 Stage-3 decorators** (TS 5+) met een ander handtekening, die de toekomstige standaard zijn — maar de meeste bestaande frameworks gebruiken nog steeds de legacy-vorm.

## Waarom het belangrijk is

Decorators maken schoon, declaratief meta-programming mogelijk — de ruggengraat van server frameworks en ORMs.

Zowel het mechanisme (een functie die een doel omvat) als de legacy-versus-standard splitsing kennen is essentieel voor het werken in het NestJS/Angular-ecosysteem.