NestJS

Framework progresivo de Node.js orientado a TypeScript para construir aplicaciones escalables del lado del servidor.

Instalación

Crear un Nuevo Proyecto

Comando	Descripción
npm i -g @nestjs/cli	Instalar NestJS CLI globalmente
nest new project-name	Crear un nuevo proyecto NestJS
nest new project-name --strict	Crear proyecto con TypeScript estricto
nest new project-name -p pnpm	Crear proyecto usando pnpm
nest new project-name -p yarn	Crear proyecto usando Yarn

Comandos de Desarrollo

Comando	Descripción
npm run start:dev	Iniciar servidor de desarrollo con recarga automática
npm run start:debug	Iniciar con modo debug y recarga automática
npm run start:prod	Iniciar servidor de producción
npm run build	Compilar el proyecto
npm run test	Ejecutar tests unitarios
npm run test:watch	Ejecutar tests en modo observación
npm run test:cov	Ejecutar tests con reporte de cobertura
npm run test:e2e	Ejecutar tests de extremo a extremo
npm run lint	Analizar código fuente con linter

Estructura del Proyecto

src/
├── app.controller.ts       # Controlador raíz
├── app.controller.spec.ts  # Test unitario del controlador
├── app.module.ts           # Módulo raíz
├── app.service.ts          # Servicio raíz
├── main.ts                 # Punto de entrada de la aplicación
├── users/
│   ├── users.module.ts     # Módulo de funcionalidad
│   ├── users.controller.ts # Controlador de funcionalidad
│   ├── users.service.ts    # Servicio de funcionalidad
│   ├── dto/
│   │   ├── create-user.dto.ts
│   │   └── update-user.dto.ts
│   ├── entities/
│   │   └── user.entity.ts
│   └── users.controller.spec.ts
├── auth/
│   ├── auth.module.ts
│   ├── auth.guard.ts
│   ├── auth.service.ts
│   └── strategies/
│       └── jwt.strategy.ts
└── common/
    ├── filters/
    │   └── http-exception.filter.ts
    ├── interceptors/
    │   └── logging.interceptor.ts
    └── pipes/
        └── validation.pipe.ts

Generación de Código CLI

Comandos de Generación

Comando	Descripción
nest generate module users	Generar un nuevo módulo
nest generate controller users	Generar un nuevo controlador
nest generate service users	Generar un nuevo servicio
nest generate resource users	Generar recurso CRUD completo (módulo + controlador + servicio + DTOs)
nest generate guard auth	Generar un guard de autenticación
nest generate pipe validation	Generar un pipe de validación
nest generate interceptor logging	Generar un interceptor
nest generate middleware logger	Generar middleware
nest generate filter http-exception	Generar filtro de excepciones
nest generate decorator roles	Generar un decorador personalizado
nest generate class user.entity	Generar una clase simple
nest generate interface user	Generar una interfaz
nest g res users --no-spec	Generar recurso sin archivos de test
nest g mo users --flat	Generar sin crear subcarpeta
nest info	Mostrar información del proyecto y dependencias

Generación de Recursos

# Recurso CRUD completo (flujo de trabajo más común)
nest g resource users

# El CLI solicita:
# ? What transport layer do you use? REST API
# ? Would you like to generate CRUD entry points? Yes

# Crea:
# src/users/users.module.ts
# src/users/users.controller.ts
# src/users/users.service.ts
# src/users/dto/create-user.dto.ts
# src/users/dto/update-user.dto.ts
# src/users/entities/user.entity.ts
# src/users/users.controller.spec.ts
# Actualiza: src/app.module.ts (importa UsersModule)

Módulos

Decoradores de Módulo

Comando	Descripción
@Module({ imports: [UsersModule] })	Importar otro módulo
@Module({ controllers: [UsersController] })	Registrar controladores
@Module({ providers: [UsersService] })	Registrar proveedores/servicios
@Module({ exports: [UsersService] })	Exportar proveedores para otros módulos
@Global()	Hacer módulo disponible globalmente (usar con moderación)

Módulos Dinámicos

import { Module, DynamicModule } from '@nestjs/common'

@Module({})
export class DatabaseModule {
  static forRoot(options: DatabaseOptions): DynamicModule {
    return {
      module: DatabaseModule,
      global: true,
      providers: [
        { provide: 'DATABASE_OPTIONS', useValue: options },
        DatabaseService,
      ],
      exports: [DatabaseService],
    }
  }

  static forRootAsync(options: DatabaseAsyncOptions): DynamicModule {
    return {
      module: DatabaseModule,
      global: true,
      imports: options.imports || [],
      providers: [
        {
          provide: 'DATABASE_OPTIONS',
          useFactory: options.useFactory,
          inject: options.inject || [],
        },
        DatabaseService,
      ],
      exports: [DatabaseService],
    }
  }
}

// Uso en AppModule
@Module({
  imports: [
    DatabaseModule.forRootAsync({
      imports: [ConfigModule],
      useFactory: (config: ConfigService) => ({
        host: config.get('DB_HOST'),
        port: config.get('DB_PORT'),
      }),
      inject: [ConfigService],
    }),
  ],
})
export class AppModule {}

Controladores

Decoradores de Ruta

Comando	Descripción
@Controller('users')	Definir controlador con prefijo de ruta
@Get()	Manejar petición GET
@Post()	Manejar petición POST
@Put(':id')	Manejar petición PUT con parámetro
@Patch(':id')	Manejar petición PATCH
@Delete(':id')	Manejar petición DELETE
@All('*')	Manejar todos los métodos HTTP

Decoradores de Parámetros

Comando	Descripción
@Param('id') id: string	Extraer parámetro de ruta
@Param('id', ParseIntPipe) id: number	Extraer y parsear a entero
@Query('page') page: string	Extraer parámetro de consulta
@Query() query: PaginationDto	Extraer todos los parámetros de consulta como DTO
@Body() dto: CreateUserDto	Extraer y tipar el cuerpo de la petición
@Body('email') email: string	Extraer campo específico del cuerpo
@Headers('authorization') auth: string	Extraer encabezado de la petición
@Ip() ip: string	Extraer dirección IP del cliente
@Req() request: Request	Acceder al objeto request sin procesar
@Res() response: Response	Acceder al objeto response sin procesar
@HttpCode(201)	Establecer código de estado HTTP personalizado
@Header('Cache-Control', 'none')	Establecer encabezado de respuesta
@Redirect('/new-url', 301)	Redireccionar respuesta

Ejemplo de Controlador

import {
  Controller, Get, Post, Put, Delete, Param, Query, Body,
  HttpCode, HttpStatus, ParseIntPipe, UseGuards, UseInterceptors,
} from '@nestjs/common'
import { UsersService } from './users.service'
import { CreateUserDto } from './dto/create-user.dto'
import { UpdateUserDto } from './dto/update-user.dto'
import { JwtAuthGuard } from '../auth/jwt-auth.guard'
import { LoggingInterceptor } from '../common/interceptors/logging.interceptor'

@Controller('users')
@UseInterceptors(LoggingInterceptor)
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  @HttpCode(HttpStatus.CREATED)
  create(@Body() createUserDto: CreateUserDto) {
    return this.usersService.create(createUserDto)
  }

  @Get()
  findAll(
    @Query('page', new ParseIntPipe({ optional: true })) page = 1,
    @Query('limit', new ParseIntPipe({ optional: true })) limit = 10,
  ) {
    return this.usersService.findAll(page, limit)
  }

  @Get(':id')
  findOne(@Param('id', ParseIntPipe) id: number) {
    return this.usersService.findOne(id)
  }

  @Put(':id')
  @UseGuards(JwtAuthGuard)
  update(
    @Param('id', ParseIntPipe) id: number,
    @Body() updateUserDto: UpdateUserDto,
  ) {
    return this.usersService.update(id, updateUserDto)
  }

  @Delete(':id')
  @UseGuards(JwtAuthGuard)
  @HttpCode(HttpStatus.NO_CONTENT)
  remove(@Param('id', ParseIntPipe) id: number) {
    return this.usersService.remove(id)
  }
}

Servicios y Proveedores

Inyección de Dependencias

Comando	Descripción
@Injectable()	Marcar clase como proveedor inyectable
constructor(private usersService: UsersService)	Inyectar servicio vía constructor
@Inject('TOKEN') private config	Inyectar por token personalizado
{ provide: 'TOKEN', useValue: value }	Registrar proveedor de valor
{ provide: 'TOKEN', useFactory: () => ... }	Registrar proveedor de fábrica
{ provide: 'TOKEN', useClass: MyClass }	Registrar proveedor de clase
{ provide: 'TOKEN', useExisting: OtherService }	Alias de proveedor existente
@Optional() private service?: MyService	Inyección de dependencia opcional
{ provide: 'TOKEN', scope: Scope.REQUEST }	Proveedor con alcance por petición

Ejemplo de Servicio

import { Injectable, NotFoundException, ConflictException } from '@nestjs/common'
import { InjectRepository } from '@nestjs/typeorm'
import { Repository } from 'typeorm'
import { User } from './entities/user.entity'
import { CreateUserDto } from './dto/create-user.dto'
import { UpdateUserDto } from './dto/update-user.dto'

@Injectable()
export class UsersService {
  constructor(
    @InjectRepository(User)
    private readonly usersRepo: Repository<User>,
  ) {}

  async create(dto: CreateUserDto): Promise<User> {
    const exists = await this.usersRepo.findOneBy({ email: dto.email })
    if (exists) {
      throw new ConflictException('Email already registered')
    }
    const user = this.usersRepo.create(dto)
    return this.usersRepo.save(user)
  }

  async findAll(page: number, limit: number) {
    const [items, total] = await this.usersRepo.findAndCount({
      skip: (page - 1) * limit,
      take: limit,
      order: { createdAt: 'DESC' },
    })
    return { items, total, page, limit }
  }

  async findOne(id: number): Promise<User> {
    const user = await this.usersRepo.findOneBy({ id })
    if (!user) throw new NotFoundException(`User #${id} not found`)
    return user
  }

  async update(id: number, dto: UpdateUserDto): Promise<User> {
    const user = await this.findOne(id)
    Object.assign(user, dto)
    return this.usersRepo.save(user)
  }

  async remove(id: number): Promise<void> {
    const result = await this.usersRepo.delete(id)
    if (result.affected === 0) {
      throw new NotFoundException(`User #${id} not found`)
    }
  }
}

Validación y DTOs

Configuración de Class Validator

npm install class-validator class-transformer

// main.ts - habilitar validación global
import { ValidationPipe } from '@nestjs/common'

async function bootstrap() {
  const app = await NestFactory.create(AppModule)
  app.useGlobalPipes(new ValidationPipe({
    whitelist: true,           // eliminar propiedades desconocidas
    forbidNonWhitelisted: true, // lanzar error en propiedades desconocidas
    transform: true,           // auto-transformar payloads a tipos DTO
    transformOptions: {
      enableImplicitConversion: true, // convertir query strings a números/booleanos
    },
  }))
  await app.listen(3000)
}

Ejemplos de DTO

import {
  IsString, IsEmail, IsOptional, IsInt, Min, Max,
  MinLength, MaxLength, IsEnum, ValidateNested, IsArray,
} from 'class-validator'
import { Type } from 'class-transformer'
import { PartialType, OmitType, PickType, IntersectionType } from '@nestjs/mapped-types'

export class CreateUserDto {
  @IsString()
  @MinLength(2)
  @MaxLength(50)
  name: string

  @IsEmail()
  email: string

  @IsString()
  @MinLength(8)
  password: string

  @IsOptional()
  @IsEnum(Role)
  role?: Role

  @IsOptional()
  @ValidateNested()
  @Type(() => AddressDto)
  address?: AddressDto
}

// Auto-generar DTO de actualización (todos los campos opcionales)
export class UpdateUserDto extends PartialType(CreateUserDto) {}

// Seleccionar campos específicos
export class LoginDto extends PickType(CreateUserDto, ['email', 'password']) {}

// Omitir campos específicos
export class PublicUserDto extends OmitType(CreateUserDto, ['password']) {}

Guards y Autenticación

Configuración de Guards

Comando	Descripción
@UseGuards(AuthGuard)	Aplicar guard a controlador o ruta
@UseGuards(AuthGuard, RolesGuard)	Encadenar múltiples guards
app.useGlobalGuards(new AuthGuard())	Registrar guard global
canActivate(context: ExecutionContext)	Implementar lógica del guard
@SetMetadata('roles', ['admin'])	Establecer metadatos personalizados para guards
Reflector	Leer metadatos en guards

Autenticación JWT

npm install @nestjs/jwt @nestjs/passport passport passport-jwt
npm install -D @types/passport-jwt

// auth/auth.module.ts
@Module({
  imports: [
    UsersModule,
    JwtModule.registerAsync({
      imports: [ConfigModule],
      useFactory: (config: ConfigService) => ({
        secret: config.get('JWT_SECRET'),
        signOptions: { expiresIn: '1h' },
      }),
      inject: [ConfigService],
    }),
  ],
  providers: [AuthService, JwtStrategy],
  controllers: [AuthController],
  exports: [AuthService],
})
export class AuthModule {}

// auth/jwt.strategy.ts
import { Injectable } from '@nestjs/common'
import { PassportStrategy } from '@nestjs/passport'
import { ExtractJwt, Strategy } from 'passport-jwt'

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor(config: ConfigService) {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: config.get('JWT_SECRET'),
    })
  }

  validate(payload: { sub: number; email: string }) {
    return { id: payload.sub, email: payload.email }
  }
}

// auth/jwt-auth.guard.ts
import { Injectable } from '@nestjs/common'
import { AuthGuard } from '@nestjs/passport'

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {}

// Uso
@Controller('profile')
@UseGuards(JwtAuthGuard)
export class ProfileController {
  @Get()
  getProfile(@Req() req) {
    return req.user // inyectado por JwtStrategy.validate()
  }
}

Control de Acceso Basado en Roles

// roles.decorator.ts
import { SetMetadata } from '@nestjs/common'
export const Roles = (...roles: string[]) => SetMetadata('roles', roles)

// roles.guard.ts
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common'
import { Reflector } from '@nestjs/core'

@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    const requiredRoles = this.reflector.getAllAndOverride<string[]>('roles', [
      context.getHandler(),
      context.getClass(),
    ])
    if (!requiredRoles) return true
    const { user } = context.switchToHttp().getRequest()
    return requiredRoles.some(role => user.roles?.includes(role))
  }
}

// Uso
@Controller('admin')
@UseGuards(JwtAuthGuard, RolesGuard)
export class AdminController {
  @Get('dashboard')
  @Roles('admin')
  getDashboard() {
    return { message: 'Admin dashboard' }
  }

  @Delete('users/:id')
  @Roles('admin', 'superadmin')
  removeUser(@Param('id', ParseIntPipe) id: number) {
    return this.usersService.remove(id)
  }
}

Middleware, Interceptors y Pipes

Middleware

import { Injectable, NestMiddleware } from '@nestjs/common'
import { Request, Response, NextFunction } from 'express'

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    const start = Date.now()
    res.on('finish', () => {
      const duration = Date.now() - start
      console.log(`${req.method} ${req.path} ${res.statusCode} ${duration}ms`)
    })
    next()
  }
}

// Registrar en módulo
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes('*')
  }
}

Interceptores

import {
  Injectable, NestInterceptor, ExecutionContext, CallHandler,
} from '@nestjs/common'
import { Observable, map, tap } from 'rxjs'

// Transformar forma de la respuesta
@Injectable()
export class TransformInterceptor<T> implements NestInterceptor<T, { data: T }> {
  intercept(context: ExecutionContext, next: CallHandler): Observable<{ data: T }> {
    return next.handle().pipe(
      map(data => ({ data, timestamp: new Date().toISOString() })),
    )
  }
}

// Medir tiempo de ejecución
@Injectable()
export class TimingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const start = Date.now()
    return next.handle().pipe(
      tap(() => {
        const duration = Date.now() - start
        const response = context.switchToHttp().getResponse()
        response.setHeader('X-Response-Time', `${duration}ms`)
      }),
    )
  }
}

Integración con Base de Datos

Configuración de TypeORM

Comando	Descripción
npm install @nestjs/typeorm typeorm pg	Instalar TypeORM con PostgreSQL
TypeOrmModule.forRoot({ type: 'postgres', ... })	Configurar conexión en AppModule
TypeOrmModule.forFeature([User])	Registrar entidad en módulo de funcionalidad
@InjectRepository(User) private repo: Repository<User>	Inyectar repositorio

Configuración de Prisma

npm install @prisma/client
npm install -D prisma
npx prisma init

// prisma/prisma.service.ts
import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common'
import { PrismaClient } from '@prisma/client'

@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
  async onModuleInit() {
    await this.$connect()
  }

  async onModuleDestroy() {
    await this.$disconnect()
  }
}

// prisma/prisma.module.ts
@Global()
@Module({
  providers: [PrismaService],
  exports: [PrismaService],
})
export class PrismaModule {}

// Uso en un servicio
@Injectable()
export class UsersService {
  constructor(private prisma: PrismaService) {}

  findAll() {
    return this.prisma.user.findMany()
  }

  findOne(id: number) {
    return this.prisma.user.findUniqueOrThrow({ where: { id } })
  }
}

Manejo de Excepciones

Excepciones Integradas

Comando	Descripción
throw new BadRequestException('Invalid input')	400 Bad Request
throw new UnauthorizedException('Login required')	401 Unauthorized
throw new ForbiddenException('Access denied')	403 Forbidden
throw new NotFoundException('User not found')	404 Not Found
throw new ConflictException('Email taken')	409 Conflict
throw new UnprocessableEntityException('Validation failed')	422 Unprocessable
throw new InternalServerErrorException()	500 Internal Server Error

Filtro de Excepciones Personalizado

import {
  ExceptionFilter, Catch, ArgumentsHost, HttpException, HttpStatus,
} from '@nestjs/common'
import { Request, Response } from 'express'

@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp()
    const response = ctx.getResponse<Response>()
    const request = ctx.getRequest<Request>()

    const status = exception instanceof HttpException
      ? exception.getStatus()
      : HttpStatus.INTERNAL_SERVER_ERROR

    const message = exception instanceof HttpException
      ? exception.getResponse()
      : 'Internal server error'

    response.status(status).json({
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
      message: typeof message === 'string' ? message : (message as any).message,
    })
  }
}

// Registrar globalmente en main.ts
app.useGlobalFilters(new AllExceptionsFilter())

Configuración

Configuración de Entorno

npm install @nestjs/config

// app.module.ts
import { ConfigModule, ConfigService } from '@nestjs/config'

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
      envFilePath: ['.env.local', '.env'],
      validationSchema: Joi.object({
        NODE_ENV: Joi.string().valid('development', 'production', 'test').default('development'),
        PORT: Joi.number().default(3000),
        DATABASE_URL: Joi.string().required(),
        JWT_SECRET: Joi.string().required(),
      }),
    }),
  ],
})
export class AppModule {}

// Uso en cualquier servicio
@Injectable()
export class AppService {
  constructor(private config: ConfigService) {}

  getPort(): number {
    return this.config.get<number>('PORT', 3000)
  }
}

Testing

Tests Unitarios

import { Test, TestingModule } from '@nestjs/testing'
import { UsersService } from './users.service'
import { getRepositoryToken } from '@nestjs/typeorm'
import { User } from './entities/user.entity'

describe('UsersService', () => {
  let service: UsersService

  const mockRepository = {
    create: jest.fn(),
    save: jest.fn(),
    findOneBy: jest.fn(),
    findAndCount: jest.fn(),
    delete: jest.fn(),
  }

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        UsersService,
        { provide: getRepositoryToken(User), useValue: mockRepository },
      ],
    }).compile()

    service = module.get<UsersService>(UsersService)
  })

  it('should create a user', async () => {
    const dto = { name: 'Alice', email: 'alice@example.com', password: 'secret123' }
    mockRepository.findOneBy.mockResolvedValue(null)
    mockRepository.create.mockReturnValue(dto)
    mockRepository.save.mockResolvedValue({ id: 1, ...dto })

    const result = await service.create(dto)
    expect(result.id).toBe(1)
    expect(mockRepository.save).toHaveBeenCalled()
  })
})

Tests E2E

import { Test, TestingModule } from '@nestjs/testing'
import { INestApplication, ValidationPipe } from '@nestjs/common'
import * as request from 'supertest'
import { AppModule } from '../src/app.module'

describe('UsersController (e2e)', () => {
  let app: INestApplication

  beforeAll(async () => {
    const moduleFixture: TestingModule = await Test.createTestingModule({
      imports: [AppModule],
    }).compile()

    app = moduleFixture.createNestApplication()
    app.useGlobalPipes(new ValidationPipe({ whitelist: true }))
    await app.init()
  })

  afterAll(async () => {
    await app.close()
  })

  it('/users (POST) creates a user', () => {
    return request(app.getHttpServer())
      .post('/users')
      .send({ name: 'Alice', email: 'alice@example.com', password: 'secret123' })
      .expect(201)
      .expect((res) => {
        expect(res.body.name).toBe('Alice')
        expect(res.body.id).toBeDefined()
      })
  })

  it('/users (GET) returns paginated list', () => {
    return request(app.getHttpServer())
      .get('/users?page=1&limit=10')
      .expect(200)
      .expect((res) => {
        expect(res.body.items).toBeInstanceOf(Array)
        expect(res.body.total).toBeDefined()
      })
  })
})

Mejores Prácticas

1. Usa el generador de recursos — nest g resource crea todo el scaffold CRUD (módulo, controlador, servicio, DTOs, entidad, test) en segundos y mantiene tu proyecto consistente.

2. Habilita ValidationPipe global con whitelist — establece whitelist: true y forbidNonWhitelisted: true para eliminar o rechazar automáticamente campos inesperados de todas las peticiones.

3. Usa tipos mapeados para DTOs — PartialType, PickType, OmitType e IntersectionType mantienen tus DTOs DRY derivando DTOs de actualización/consulta del DTO de creación.

4. Prefiere inyección por constructor — deja que NestJS maneje la inyección de dependencias a través de constructores en lugar de usar tokens @Inject() manuales a menos que necesites proveedores personalizados.

5. Mantén los controladores delgados — los controladores solo deben parsear la entrada y devolver la salida. Mueve toda la lógica de negocio a los servicios para testabilidad y reutilización.

6. Usa ConfigModule para todo acceso al entorno — nunca leas process.env directamente en los servicios. Usa ConfigService con esquemas de validación para que las variables faltantes fallen rápido al inicio.

7. Aplica guards e interceptores apropiadamente — aplícalos a nivel de controlador o ruta con decoradores en lugar de globalmente, a menos que realmente apliquen en todas partes.

8. Escribe tests unitarios y e2e — testea unitariamente los servicios con dependencias mockeadas usando Test.createTestingModule(), y testea los endpoints HTTP de extremo a extremo con supertest.

9. Usa Prisma o TypeORM consistentemente — elige un ORM y úsalo en todo el proyecto. Prisma ofrece mejor seguridad de tipos; TypeORM ofrece más flexibilidad con decoradores.

10. Estructura por funcionalidad, no por tipo — agrupa archivos por dominio (users/, auth/, orders/) en lugar de por tipo (controllers/, services/). Esto mantiene el código relacionado junto y los módulos autocontenidos.

11. Maneja errores con excepciones — lanza excepciones HTTP integradas (NotFoundException, ConflictException) desde los servicios. Usa filtros de excepciones para formateo personalizado de errores.

12. Usa async/await consistentemente — NestJS maneja promesas nativamente. Retorna valores async desde los métodos de servicio y deja que el framework serialice la respuesta.