Comment NestJS utilise-t-il les décorateurs ?

Question

Accepted Answer

NestJS est construit autour des **décorateurs TypeScript** — des annotations spéciales préfixées par `@` qui attachent des **métadonnées** aux classes, méthodes et paramètres. NestJS lit ces métadonnées (via la réflexion) pour configurer le routage, l'injection de dépendances, la validation, et bien d'autres choses de manière déclarative. Les décorateurs sont omniprésents dans Nest.

## Décorateurs de classe — définir le rôle d'une classe

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

Les décorateurs de classe déclarent ce qu'une classe *est* dans l'architecture NestJS (contrôleur, fournisseur, module) et la configure.

## Décorateurs de méthode — mapper les routes et appliquer un comportement

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

## Décorateurs de paramètre — extraire les données de la requête

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

Les décorateurs de paramètre extraient déclarativement exactement les données dont vous avez besoin hors de la requête — pas d'analyse manuelle de `req`.

## Décorateurs de propriété/validation (sur les DTOs)

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

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

## Pourquoi les décorateurs ? Une approche déclarative avec métadonnées

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

## Décorateurs personnalisés

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

## Pourquoi c'est important

Les décorateurs sont la caractéristique syntaxique définissante de NestJS — l'ensemble du framework est organisé autour d'eux, donc comprendre comment ils fonctionnent est essentiel pour lire et écrire n'importe quel code NestJS.

Ils fournissent une approche **déclarative** basée sur les métadonnées : au lieu d'une configuration impérative, vous annotez les classes, méthodes et paramètres pour déclarer le routage (`@Controller`, `@Get`), l'injection de dépendances (`@Injectable`), les comportements transversaux (`@UseGuards`, `@UseInterceptors`) et la validation (`@IsEmail`) exactement là où ils s'appliquent — concis et lisible.

Ce mécanisme de métadonnées-via-réflexion (la même idée derrière les annotations Angular et Java/Spring) est ce qui permet au style clean et structuré de NestJS.

Reconnaître les catégories (décorateurs de classe, méthode, paramètre, propriété), connaître les courants, et être capable de créer des décorateurs personnalisés est une maîtrise fondamentale de NestJS — les décorateurs sont la manière dont presque chaque fonctionnalité est exprimée, ce qui en fait l'une des premières choses et des plus importantes à comprendre dans le framework.