NestJS API REST

NestJS representa una evolución natural en el desarrollo de aplicaciones Node.js, combinando la flexibilidad de JavaScript con la robustez de TypeScript y los patrones arquitectónicos más sólidos del desarrollo backend.

Este framework ha ganado reconocimiento en la industria por su capacidad para crear APIs REST escalables y mantenibles, adoptando principios de diseño que facilitan tanto el desarrollo inicial como el crecimiento a largo plazo de las aplicaciones.

Arquitectura y filosofía de diseño

La arquitectura modular de NestJS se inspira en frameworks como Angular, implementando un sistema de decoradores que permite definir la funcionalidad de manera declarativa y clara. Esta aproximación facilita la comprensión del código y reduce significativamente la curva de aprendizaje para desarrolladores que provienen de otros ecosistemas.

El framework adopta el patrón Modelo-Vista-Controlador (MVC) de forma nativa, proporcionando una separación clara de responsabilidades que mejora la organización del código. Los controladores manejan las peticiones HTTP, los servicios contienen la lógica de negocio, y los módulos actúan como contenedores que organizan y conectan estos componentes.

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

  @Get()
  findAll(): Promise<User[]> {
    return this.usersService.findAll();
  }
}

Gestión de peticiones HTTP

NestJS proporciona decoradores específicos para cada método HTTP, simplificando la definición de endpoints REST. Los métodos @Get(), @Post(), @Put() y @Delete() permiten crear APIs que siguen las convenciones REST de manera intuitiva y expresiva.

La gestión de parámetros se realiza mediante decoradores como @Param(), @Body() y @Query(), que extraen automáticamente los datos de las peticiones y los tipan correctamente cuando se utiliza TypeScript.

@Controller('products')
export class ProductsController {
  @Post()
  create(@Body() createProductDto: CreateProductDto): Promise<Product> {
    return this.productsService.create(createProductDto);
  }

  @Put(':id')
  update(
    @Param('id') id: string,
    @Body() updateProductDto: UpdateProductDto
  ): Promise<Product> {
    return this.productsService.update(id, updateProductDto);
  }
}

Validación y transformación de datos

El framework integra un sistema de validación robusto mediante pipes, que actúan como interceptores que procesan los datos antes de que lleguen a los controladores. Los pipes pueden validar, transformar y sanitizar los datos de entrada, garantizando que la aplicación reciba únicamente información válida.

La validación declarativa se implementa utilizando decoradores de class-validator, permitiendo definir reglas de validación directamente en los DTOs (Data Transfer Objects). Este enfoque centraliza las reglas de validación y las hace reutilizables en toda la aplicación.

export class CreateUserDto {
  @IsEmail()
  @IsNotEmpty()
  email: string;

  @IsString()
  @MinLength(8)
  @Matches(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)/, {
    message: 'La contraseña debe contener al menos una mayúscula, una minúscula y un número'
  })
  password: string;

  @IsOptional()
  @IsString()
  @MaxLength(100)
  name?: string;
}

Manejo de errores y excepciones

NestJS implementa un sistema de manejo de errores centralizado que captura automáticamente las excepciones y las transforma en respuestas HTTP apropiadas. El framework proporciona excepciones predefinidas para los códigos de estado HTTP más comunes, facilitando la creación de APIs que comunican errores de manera consistente.

Los filtros de excepción personalizados permiten implementar lógica específica para el manejo de errores, incluyendo logging, notificaciones y transformación de mensajes de error según las necesidades de la aplicación.

@Injectable()
export class UsersService {
  async findOne(id: string): Promise<User> {
    const user = await this.userRepository.findById(id);
    
    if (!user) {
      throw new NotFoundException(`Usuario con ID ${id} no encontrado`);
    }
    
    return user;
  }

  async create(userData: CreateUserDto): Promise<User> {
    try {
      return await this.userRepository.create(userData);
    } catch (error) {
      if (error.code === 'DUPLICATE_EMAIL') {
        throw new ConflictException('El email ya está registrado');
      }
      throw new InternalServerErrorException('Error al crear el usuario');
    }
  }
}

Procesamiento de archivos multimedia

El framework facilita la gestión de archivos mediante interceptores especializados que manejan la carga, validación y almacenamiento de contenido multimedia. Esta funcionalidad es esencial para APIs que necesitan procesar imágenes, documentos u otros tipos de archivos.

La validación de archivos incluye verificación de tipos MIME, tamaños máximos y otras restricciones de seguridad, garantizando que la aplicación procese únicamente contenido válido y seguro.

@Controller('uploads')
export class UploadsController {
  @Post('image')
  @UseInterceptors(FileInterceptor('file', {
    fileFilter: (req, file, callback) => {
      if (!file.mimetype.match(/\/(jpg|jpeg|png|gif)$/)) {
        return callback(new BadRequestException('Solo se permiten imágenes'), false);
      }
      callback(null, true);
    },
    limits: { fileSize: 5 * 1024 * 1024 } // 5MB
  }))
  uploadImage(@UploadedFile() file: Express.Multer.File): Promise<string> {
    return this.uploadsService.saveImage(file);
  }
}