Ce sunt controlerii în NestJS?

Question

Accepted Answer

**Controlerii** gestionează **cereri HTTP** primite și returnează răspunsuri. Aceștia definesc rutele aplicației și acționează ca punct de intrare — primind cereri, extragând date, delegând la servicii și returnând rezultate. Ei mențin separarea problemelor de rutare de logica de afaceri.

## Definirea unui controller

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

## Cum funcționează: decoratorii mapează metodele la rute

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

Decoratorul leagă declarativ metodele clasei la rutele HTTP — curat și lizibil, fără înregistrare manuală a rutelor.

## Decoratorii de parametru extrag date din cerere

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

Decoratorul de parametru ai Nest (`@Param`, `@Query`, `@Body`, `@Headers`) extrag curat exact datele de care aveți nevoie — fără parsare manuală a `req`.

## Controlerii ar trebui să fie SUBȚIRI

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

Cea mai bună practică: mențineți controlerii **subțiri** — ei gestionează preocupări HTTP (rutare, extragere de date, returnare de răspunsuri) și delegă toată logica de afaceri către **servicii**. Această separare menține codul testabil și organizat.

## De ce este important

Controlerii sunt o componentă fundamentală a NestJS — punctul de intrare pentru toate cererile HTTP și locul unde sunt definite rutele API-ului dvs.

Înțelegerea modului în care decoratori (`@Controller`, `@Get`/`@Post`, `@Param`/`@Body`/`@Query`) mapează metodele la rute și extrag datele cererii în mod declarat este cunoaștere esențială zilnică a NestJS — aceasta este modul în care construiți orice punct final.

La fel de important este principiul menținerii controlerii **subțiri** (gestionând doar preocupări HTTP și delegând logica de afaceri la serviciile injectate), care înglobează filosofia NestJS de separare a responsabilităților și menține codul ușor de întreținut și testabil.

Controlerii, alături de servicii și module, formează structura centrală a fiecărei aplicații NestJS, ceea ce le face esențiale pentru a înțelege din început.