¿Qué son los Controllers en NestJS?

Question

Accepted Answer

**Controllers** manejan **requests HTTP** entrantes y devuelven respuestas. Definen las rutas de tu aplicación y actúan como el punto de entrada — reciben solicitudes, extraen datos, delegan a services y devuelven resultados. Mantienen las preocupaciones de enrutamiento separadas de la lógica empresarial.

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

## Cómo funciona: los decoradores mapean métodos a rutas

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

Los decoradores vinculan de forma declarativa los métodos de clase a rutas HTTP — limpio y legible, sin registro manual de rutas.

## Los decoradores de parámetros extraen datos de la solicitud

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

Los decoradores de parámetros de Nest (`@Param`, `@Query`, `@Body`, `@Headers`) extraen limpiamente exactamente los datos que necesitas — sin análisis manual de `req`.

## Los Controllers deben ser DELGADOS

```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 mejor práctica: mantén los controllers **delgados** — manejan preocupaciones HTTP (enrutamiento, extracción de datos, devolución de respuestas) y delegan toda la lógica empresarial a **services**. Esta separación mantiene el código comprobable y organizado.

## Por qué es importante

Los Controllers son un componente fundamental de NestJS — el punto de entrada para todas las solicitudes HTTP y donde se definen las rutas de tu API.

Comprender cómo los decoradores (`@Controller`, `@Get`/`@Post`, `@Param`/`@Body`/`@Query`) mapean métodos a rutas y extraen datos de solicitud de forma declarativa es conocimiento esencial de NestJS día a día — así es como construyes cualquier endpoint.

Igualmente importante es el principio de mantener los controllers **delgados** (manejar solo preocupaciones HTTP y delegar la lógica empresarial a services inyectados), que encarna la filosofía de separación de responsabilidades de NestJS y mantiene el código mantenible y comprobable.

Los Controllers, junto con services y modules, forman la estructura principal de toda aplicación NestJS, lo que los hace esenciales de entender desde el principio.