¿Cómo usa NestJS los decoradores?

Question

Accepted Answer

NestJS está construido alrededor de **decoradores de TypeScript** — anotaciones especiales con prefijo `@` que adjuntan **metadatos** a clases, métodos y parámetros. NestJS lee estos metadatos (a través de reflexión) para conectar declarativamente el enrutamiento, la inyección de dependencias, la validación y mucho más. Los decoradores están en todas partes en Nest.

## Decoradores de clase — definen el rol de una clase

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

Los decoradores de clase declaran qué *es* una clase en la arquitectura de NestJS (controlador, proveedor, módulo) y la configuran.

## Decoradores de método — mapean rutas y aplican comportamiento

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

## Decoradores de parámetro — extraen datos de solicitud

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

Los decoradores de parámetro extraen declarativamente exactamente los datos que necesita de la solicitud — sin análisis manual de `req`.

## Decoradores de propiedad/validación (en DTO)

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

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

## ¿Por qué decoradores? Metadatos declarativos

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

## Decoradores personalizados

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

## Por qué es importante

Los decoradores son la característica sintáctica definitoria de NestJS — el marco completo está organizado alrededor de ellos, por lo que comprender cómo funcionan es esencial para leer y escribir cualquier código de NestJS.

Proporcionan un enfoque **declarativo** impulsado por metadatos: en lugar de una configuración imperativa, anota clases, métodos y parámetros para declarar enrutamiento (`@Controller`, `@Get`), inyección de dependencias (`@Injectable`), comportamiento transversal (`@UseGuards`, `@UseInterceptors`) y validación (`@IsEmail`) exactamente donde se aplican — conciso y legible.

Este mecanismo de metadatos a través de reflexión (la misma idea detrás de las anotaciones de Angular y Java/Spring) es lo que permite el estilo limpio y estructurado de NestJS.

Reconocer las categorías (decoradores de clase, método, parámetro, propiedad), conocer los comunes y ser capaz de crear decoradores personalizados es fluidez fundamental de NestJS — los decoradores son la forma en que se expresa casi todas las características, lo que los convierte en una de las primeras y más importantes cosas para entender en el marco.