Que sont les contrôleurs dans NestJS ?

Question

Accepted Answer

**Controllers** gèrent les **HTTP requests** entrantes et retournent des réponses. Ils définissent les routes de votre application et servent de point d'entrée — en recevant les demandes, en extrayant les données, en déléguant aux services et en retournant les résultats. Ils maintiennent les préoccupations de routage séparées de la logique métier.

## Pourquoi c'est important

```ts
import { Controller, Get, Post, Body, Param } from "@nestjs/common";

@Controller("users")          // the route PREFIX → all routes start with /users
export class UsersController {
  constructor(private usersService: UsersService) {}   // inject a service via DI

@Get()                       // GET /users
  findAll() {
    return this.usersService.findAll();
  }

@Get(":id")                  // GET /users/:id
  findOne(@Param("id") id: string) {        // extract the route param
    return this.usersService.findOne(id);
  }

@Post()                      // POST /users
  create(@Body() dto: CreateUserDto) {       // extract the request body
    return this.usersService.create(dto);
  }
}
```

## Comment ça marche : les décorateurs mappent les méthodes aux routes

```text
@Controller("users") → route prefix /users
@Get() / @Post() / @Put() / @Patch() / @Delete() → HTTP method + sub-path
Combined: @Get(":id") inside @Controller("users") → GET /users/:id
```

Les décorateurs lient de manière déclarative les méthodes de classe aux routes HTTP — propre et lisible, pas d'enregistrement manuel de routes.

## Les décorateurs de paramètres extraient les données de la demande

```ts
@Get(":id")
example(
  @Param("id") id: string,        // route parameter (/users/:id)
  @Query("sort") sort: string,    // query string (?sort=name)
  @Body() body: CreateUserDto,    // request body
  @Headers("authorization") auth: string,  // a header
  @Req() req: Request,            // the raw request object (rarely needed)
) {}
```

Les décorateurs de paramètres de Nest (`@Param`, `@Query`, `@Body`, `@Headers`) extraient proprement exactement les données dont vous avez besoin — pas de parsing manuel de `req`.

## Les contrôleurs doivent être FINS

```ts
// ✅ controller delegates to a service — stays thin
@Post()
create(@Body() dto: CreateUserDto) {
  return this.usersService.create(dto);   // business logic lives in the SERVICE
}
// ❌ don't put database queries / business logic directly in the controller
```

La meilleure pratique : gardez les contrôleurs **fins** — ils gèrent les préoccupations HTTP (routage, extraction de données, retour de réponses) et délèguent toute la logique métier aux **services**. Cette séparation maintient le code testable et organisé.

## Pourquoi c'est important

Les contrôleurs sont un élément fondamental de NestJS — le point d'entrée pour toutes les HTTP requests et où les routes de votre API sont définies.

Comprendre comment les décorateurs (`@Controller`, `@Get`/`@Post`, `@Param`/`@Body`/`@Query`) mappent les méthodes aux routes et extraient les données de demande de manière déclarative est une connaissance NestJS essentielle au quotidien — c'est comment vous construisez n'importe quel endpoint.

Également important est le principe de garder les contrôleurs **fins** (gérant uniquement les préoccupations HTTP et déléguant la logique métier aux services injectés), qui incarne la philosophie de séparation des préoccupations de NestJS et maintient le code maintenable et testable.

Les contrôleurs, ainsi que les services et modules, forment la structure principale de chaque application NestJS, ce qui les rend essentiels à comprendre dès le départ.