Manual NestJS - CRUD de Inventario

1. Configuración del Proyecto

Instalación y Estructura

Terminal

# Instalar CLI de NestJS globalmente
npm install -g @nestjs/cli

# Crear nuevo proyecto
nest new inventario-api

# Instalar dependencias principales
cd inventario-api
npm install @nestjs/sequelize sequelize sequelize-typescript mysql2
npm install @nestjs/jwt @nestjs/passport passport passport-jwt
npm install @nestjs/swagger swagger-ui-express
npm install bcrypt dotenv cors

Estructura de Directorios

src/
├── auth/                   # Autenticación JWT
│   ├── auth.module.ts
│   ├── auth.service.ts
│   ├── auth.controller.ts
│   ├── strategies/         # Estrategias Passport
│   └── interfaces/         # Interfaces de autenticación
├── products/               # Módulo de productos
│   ├── products.module.ts
│   ├── products.service.ts
│   ├── products.controller.ts
│   ├── entities/           # Entidades de Sequelize
│   └── dto/                # Data Transfer Objects
├── users/                  # Módulo de usuarios
├── database/               # Configuración de base de datos
├── shared/                 # Utilidades compartidas
├── app.module.ts           # Módulo raíz
├── main.ts                 # Punto de entrada
.env                        # Variables de entorno

2. Configuración de Sequelize

Módulo de Base de Datos

src/database/database.module.ts

import { Module } from '@nestjs/common';
import { SequelizeModule } from '@nestjs/sequelize';
import { ConfigModule, ConfigService } from '@nestjs/config';
import * as models from '../products/entities/product.entity';

@Module({
  imports: [
    SequelizeModule.forRootAsync({
      imports: [ConfigModule],
      useFactory: (configService: ConfigService) => ({
        dialect: 'mysql',
        host: configService.get('DB_HOST'),
        port: +configService.get('DB_PORT'),
        username: configService.get('DB_USER'),
        password: configService.get('DB_PASSWORD'),
        database: configService.get('DB_NAME'),
        models: Object.values(models),
        autoLoadModels: true,
        synchronize: true, // Solo para desarrollo
        logging: configService.get('NODE_ENV') === 'development',
      }),
      inject: [ConfigService],
    }),
  ],
  exports: [SequelizeModule],
})
export class DatabaseModule {}

Entidad de Producto

src/products/entities/product.entity.ts

import { Table, Column, Model, DataType, ForeignKey, BelongsTo } from 'sequelize-typescript';
import { Category } from './category.entity';

@Table({ tableName: 'products', timestamps: true })
export class Product extends Model {
  @Column({
    type: DataType.INTEGER,
    primaryKey: true,
    autoIncrement: true,
  })
  id: number;

  @Column({
    type: DataType.STRING(100),
    allowNull: false,
    validate: {
      notEmpty: true,
      len: [3, 100],
    },
  })
  name: string;

  @Column({
    type: DataType.TEXT,
    allowNull: true,
  })
  description: string;

  @Column({
    type: DataType.DECIMAL(10, 2),
    allowNull: false,
    validate: {
      min: 0,
    },
  })
  price: number;

  @Column({
    type: DataType.INTEGER,
    defaultValue: 0,
    validate: {
      min: 0,
    },
  })
  stock: number;

  @ForeignKey(() => Category)
  @Column({
    type: DataType.INTEGER,
    allowNull: false,
  })
  categoryId: number;

  @BelongsTo(() => Category)
  category: Category;
}

🔍 Configuración de Sequelize con NestJS

SequelizeModule: Integración nativa con NestJS
Decoradores: @Table, @Column para definir modelos
Relaciones: @ForeignKey y @BelongsTo para asociaciones
Validaciones: Directamente en el modelo

3. Implementación del CRUD

Módulo de Productos

src/products/products.module.ts

import { Module } from '@nestjs/common';
import { SequelizeModule } from '@nestjs/sequelize';
import { ProductsService } from './products.service';
import { ProductsController } from './products.controller';
import { Product } from './entities/product.entity';
import { Category } from './entities/category.entity';

@Module({
  imports: [SequelizeModule.forFeature([Product, Category])],
  controllers: [ProductsController],
  providers: [ProductsService],
  exports: [ProductsService],
})
export class ProductsModule {}

Servicio de Productos

src/products/products.service.ts

import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectModel } from '@nestjs/sequelize';
import { Product } from './entities/product.entity';
import { CreateProductDto } from './dto/create-product.dto';
import { UpdateProductDto } from './dto/update-product.dto';
import { Op } from 'sequelize';

@Injectable()
export class ProductsService {
  constructor(
    @InjectModel(Product)
    private productModel: typeof Product,
  ) {}

  async create(createProductDto: CreateProductDto): Promise {
    return this.productModel.create(createProductDto);
  }

  async findAll(query: any): Promise {
    const { search, minPrice, maxPrice, categoryId } = query;
    
    const where: any = {};
    
    if (search) {
      where.name = { [Op.like]: `%${search}%` };
    }
    
    if (minPrice || maxPrice) {
      where.price = {};
      if (minPrice) where.price[Op.gte] = minPrice;
      if (maxPrice) where.price[Op.lte] = maxPrice;
    }
    
    if (categoryId) {
      where.categoryId = categoryId;
    }
    
    return this.productModel.findAll({ where });
  }

  async findOne(id: number): Promise {
    const product = await this.productModel.findByPk(id);
    if (!product) {
      throw new NotFoundException(`Product with ID ${id} not found`);
    }
    return product;
  }

  async update(id: number, updateProductDto: UpdateProductDto): Promise {
    const product = await this.findOne(id);
    return product.update(updateProductDto);
  }

  async remove(id: number): Promise {
    const product = await this.findOne(id);
    await product.destroy();
  }
}

Controlador de Productos

src/products/products.controller.ts

import { Controller, Get, Post, Body, Param, Put, Delete, Query } from '@nestjs/common';
import { ProductsService } from './products.service';
import { Product } from './entities/product.entity';
import { CreateProductDto } from './dto/create-product.dto';
import { UpdateProductDto } from './dto/update-product.dto';
import { ApiTags, ApiOperation, ApiResponse, ApiBearerAuth } from '@nestjs/swagger';

@ApiTags('products')
@ApiBearerAuth()
@Controller('products')
export class ProductsController {
  constructor(private readonly productsService: ProductsService) {}

  @Post()
  @ApiOperation({ summary: 'Create a new product' })
  @ApiResponse({ status: 201, description: 'Product created', type: Product })
  create(@Body() createProductDto: CreateProductDto): Promise {
    return this.productsService.create(createProductDto);
  }

  @Get()
  @ApiOperation({ summary: 'Get all products' })
  @ApiResponse({ status: 200, description: 'List of products', type: [Product] })
  findAll(@Query() query: any): Promise {
    return this.productsService.findAll(query);
  }

  @Get(':id')
  @ApiOperation({ summary: 'Get product by ID' })
  @ApiResponse({ status: 200, description: 'Product found', type: Product })
  @ApiResponse({ status: 404, description: 'Product not found' })
  findOne(@Param('id') id: string): Promise {
    return this.productsService.findOne(+id);
  }

  @Put(':id')
  @ApiOperation({ summary: 'Update product' })
  @ApiResponse({ status: 200, description: 'Product updated', type: Product })
  update(@Param('id') id: string, @Body() updateProductDto: UpdateProductDto): Promise {
    return this.productsService.update(+id, updateProductDto);
  }

  @Delete(':id')
  @ApiOperation({ summary: 'Delete product' })
  @ApiResponse({ status: 200, description: 'Product deleted' })
  remove(@Param('id') id: string): Promise {
    return this.productsService.remove(+id);
  }
}

📌 Patrones Implementados

Inyección de Dependencias: Servicios inyectados en controladores
DTOs (Data Transfer Objects): Para validación de entrada
Repository Pattern: Acceso a datos encapsulado en servicios
Excepciones HTTP: Manejo adecuado de errores

4. Autenticación con JWT

Módulo de Autenticación

src/auth/auth.module.ts

import { Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt';
import { PassportModule } from '@nestjs/passport';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { AuthService } from './auth.service';
import { AuthController } from './auth.controller';
import { JwtStrategy } from './strategies/jwt.strategy';
import { UsersModule } from '../users/users.module';

@Module({
  imports: [
    UsersModule,
    PassportModule,
    JwtModule.registerAsync({
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService) => ({
        secret: configService.get('JWT_SECRET'),
        signOptions: { expiresIn: configService.get('JWT_EXPIRES_IN') },
      }),
      inject: [ConfigService],
    }),
  ],
  controllers: [AuthController],
  providers: [AuthService, JwtStrategy],
  exports: [JwtStrategy, PassportModule],
})
export class AuthModule {}

Estrategia JWT

src/auth/strategies/jwt.strategy.ts

import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { ExtractJwt, Strategy } from 'passport-jwt';
import { ConfigService } from '@nestjs/config';

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

  async validate(payload: any) {
    return { userId: payload.sub, username: payload.username, role: payload.role };
  }
}

Guard de Autenticación

src/auth/guards/jwt-auth.guard.ts

import { Injectable } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

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

🔐 Buenas Prácticas de Seguridad

Usar HttpOnly y Secure para cookies JWT
Implementar refresh tokens para renovación segura
Limitar el tiempo de vida de los tokens
Proteger rutas sensibles con roles (RBAC)

5. Documentación Automática

Configuración de Swagger

src/main.ts

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  // Configuración de Swagger
  const config = new DocumentBuilder()
    .setTitle('Inventory API')
    .setDescription('The inventory management API description')
    .setVersion('1.0')
    .addBearerAuth(
      { type: 'http', scheme: 'bearer', bearerFormat: 'JWT' },
      'JWT',
    )
    .build();
  
  const document = SwaggerModule.createDocument(app, config);
  SwaggerModule.setup('api-docs', app, document);

  await app.listen(3000);
}
bootstrap();

Ejemplo de Documentación en Controlador

src/products/products.controller.ts (fragmento)

@ApiTags('products')
@ApiBearerAuth()
@Controller('products')
export class ProductsController {
  constructor(private readonly productsService: ProductsService) {}

  @Post()
  @ApiOperation({ summary: 'Create a new product' })
  @ApiResponse({ 
    status: 201, 
    description: 'The product has been successfully created.',
    type: Product,
  })
  @ApiResponse({ status: 400, description: 'Bad request' })
  @ApiResponse({ status: 401, description: 'Unauthorized' })
  @UseGuards(JwtAuthGuard)
  create(@Body() createProductDto: CreateProductDto): Promise {
    return this.productsService.create(createProductDto);
  }
}

📚 Documentación Generada

Accede a la documentación interactiva en:

GET http://localhost:3000/api-docs

6. Configuración Completa

Módulo Principal

src/app.module.ts

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { DatabaseModule } from './database/database.module';
import { ProductsModule } from './products/products.module';
import { AuthModule } from './auth/auth.module';
import { UsersModule } from './users/users.module';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
      envFilePath: '.env',
    }),
    DatabaseModule,
    ProductsModule,
    AuthModule,
    UsersModule,
  ],
})
export class AppModule {}

Variables de Entorno

.env

# Database
DB_HOST=localhost
DB_PORT=3306
DB_USER=root
DB_PASSWORD=secret
DB_NAME=inventory_db

# JWT
JWT_SECRET=superSecretKey123!
JWT_EXPIRES_IN=3600s

# App
PORT=3000
NODE_ENV=development

Scripts de package.json

package.json

"scripts": {
  "start": "nest start",
  "start:dev": "nest start --watch",
  "start:prod": "node dist/main",
  "build": "nest build",
  "migrate": "npx sequelize-cli db:migrate",
  "seed": "npx sequelize-cli db:seed:all",
  "test": "jest",
  "test:watch": "jest --watch",
  "test:cov": "jest --coverage"
}

7. Despliegue en Producción

Configuración para Producción

.env.production

NODE_ENV=production
PORT=8080

DB_HOST=production-db.example.com
DB_USER=prod_user
DB_PASSWORD=complex_password_123
DB_NAME=inventory_prod

JWT_SECRET=veryComplexSecretKey!987
JWT_EXPIRES_IN=1h

Dockerfile

FROM node:16-alpine

WORKDIR /usr/src/app

COPY package*.json ./

RUN npm install --only=production

COPY . .

RUN npm run build

EXPOSE 8080

CMD ["node", "dist/main"]

🚨 Consideraciones para Producción

Usar HTTPS con certificados SSL válidos
Implementar rate limiting
Configurar CORS adecuadamente
Monitorear la aplicación (Prometheus, Grafana)
Usar un proceso manager como PM2

Manual Completo de NestJS

🚀 Introducción a NestJS

🔍 ¿Por qué NestJS?

Arquitectura del Proyecto