Cosa sono i controller in NestJS?

Question

Accepted Answer

**I controller** gestiscono le **richieste HTTP** in arrivo e restituiscono risposte. Definiscono le route della tua applicazione e agiscono come punto di ingresso — ricevendo richieste, estraendo dati, delegando ai servizi e restituendo risultati. Mantengono separate le problematiche di routing dalla logica di business.

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

## Come funziona: i decoratori mappano i metodi alle route

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

I decoratori collegano in modo dichiarativo i metodi della classe alle route HTTP — pulito e leggibile, senza registrazione manuale delle route.

## I decoratori di parametro estraggono i dati della richiesta

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

I decoratori di parametro di Nest (`@Param`, `@Query`, `@Body`, `@Headers`) estraggono in modo pulito esattamente i dati di cui hai bisogno — nessuna analisi manuale di `req`.

## I controller dovrebbero essere SOTTILI

```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 migliore pratica: mantieni i controller **sottili** — gestiscono le problematiche HTTP (routing, estrazione di dati, restituzione di risposte) e delegano tutta la logica di business ai **servizi**. Questa separazione mantiene il codice testabile e organizzato.

## Perché è importante

I controller sono un blocco costruttivo fondamentale di NestJS — il punto di ingresso per tutte le richieste HTTP e dove sono definite le route della tua API.

Comprendere come i decoratori (`@Controller`, `@Get`/`@Post`, `@Param`/`@Body`/`@Query`) mappano i metodi alle route e estraggono i dati della richiesta in modo dichiarativo è una conoscenza essenziale di NestJS quotidiana — è così che costruisci qualsiasi endpoint.

Equalmente importante è il principio di mantenere i controller **sottili** (gestendo solo le problematiche HTTP e delegando la logica di business ai servizi iniettati), che incarna la filosofia di separazione dei compiti di NestJS e mantiene il codice mantenibile e testabile.

I controller, insieme ai servizi e ai moduli, formano la struttura centrale di ogni applicazione NestJS, rendendoli essenziali da comprendere fin dall'inizio.