CRUD de órdenes de compra y gestión de ítems en NestJS

Curso de NestJS: Persistencia de Datos con TypeORM

Contenido del curso

Introducción

Database

TypeORM

Migraciones

Relaciones

Consultas

Migración a NestJS 9 y TypeORM 0.3

Próximos pasos

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0030:07

CRUD de órdenes de compra y gestión de ítems en NestJS

Curso de NestJS: Persistencia de Datos con TypeORM

Clase 26 de 36

Clase 26 / 36

Recursos

¿Cómo gestionar la agregación de órdenes en NestJS?

En el desarrollo de aplicaciones con NestJS, la gestión de órdenes de compra puede simplificarse creando un servicio y un controlador dedicados. Este proceso se inicia utilizando el Nest CLI para generar los componentes necesarios. Vamos a explorar cómo se hace.

¿Cómo generamos el servicio y el controlador?

Para iniciar, en la terminal empleamos el comando nest generate, especificando que queremos un servicio (s) y un controlador. La estructura se ubicará bajo el módulo de usuarios, dado su contexto en la aplicación:

nest generate service users/service/ordered --flat
nest generate controller users/controllers/ordered --flat

Con estos pasos se crean los archivos básicos y se agregan al UserModule sin necesidad de ningún ajusto adicional.

¿Qué es un DTO y cómo se crea?

El DTO (Data Transfer Object) delimita los datos que serán transferidos al momento de crear una orden. Creamos una clase CreateOrderDTO:

export class CreateOrderDTO {
  @IsPositive()
  @IsNotEmpty()
  @ApiProperty()
  readonly customerId: number;
}

Este DTO identifica al cliente relacionado, validando que la información sea positiva y no vacía, integrándose con la documentación Swagger.

¿Cómo desarrollamos las funciones CRUD?

En el OrderedService, implementamos las funciones básicas CRUD: "crear", "actualizar" y "eliminar", apoyándonos en dos repositorios: OrderRepo y CustomerRepo. Utilizamos InjectRepository:

@Injectable()
export class OrderedService {
  constructor(
    @InjectRepository(Order) private orderRepo: Repository<Order>,
    @InjectRepository(Customer) private customerRepo: Repository<Customer>
  ) {}

  // Funciones CRUD aquí...
}

Para crear una orden, solo es necesario el CustomerID, y la instancia de la orden se guarda en el repositorio correspondiente.

Incorporación de ítems en la orden

Una vez establecida la orden de compra, el siguiente paso es gestionar la inclusión de productos, tratados como ítems en una entidad ternaria. Esta sección detalla cómo se procede.

¿Cómo creamos el DTO para los ítems?

Para gestionar los ítems, creamos un DTO OrderItemDTO que detalla los elementos necesarios:

export class CreateOrderItemDTO {
  @IsPositive()
  @IsNotEmpty()
  @ApiProperty()
  readonly orderId: number;

  @IsPositive()
  @IsNotEmpty()
  @ApiProperty()
  readonly productId: number;

  @IsPositive()
  @IsNotEmpty()
  @ApiProperty()
  readonly quantity: number;
}

Este DTO especifica la orden y el producto a los que se añaden los ítems, incluyendo la cantidad.

¿Cómo se estructura el servicio y controlador para los ítems de la orden?

Al crear ítems, se replican el servicio y controlador, asegurando que el servicio maneje la lógica de negocio:

@Injectable()
export class OrderItemService {
  constructor(
    @InjectRepository(OrderItem) private itemsRepo: Repository<OrderItem>,
    @InjectRepository(Order) private orderRepo: Repository<Order>,
    @InjectRepository(Product) private productRepo: Repository<Product>
  ) {}

  async createItem(data: CreateOrderItemDTO): Promise<OrderItem> {
    const { orderId, productId, quantity } = data;
    const order = await this.orderRepo.findOne(orderId);
    const product = await this.productRepo.findOne(productId);
    const item = this.itemsRepo.create({ order, product, quantity });
    return this.itemsRepo.save(item);
  }
}

Además, en el OrdersController se implementa un POST para agregar ítems:

@Post('/order-items')
async addItem(@Body() dto: CreateOrderItemDTO): Promise<OrderItem> {
  return this.orderItemService.createItem(dto);
}

Comprobación y optimización

Finalmente, revisamos la gestión mediante herramientas como Insomnia y pgAdmin para verificar la correcta inserción de datos y resolver inconvenientes de inyección de dependencias mediante la exportación correcta de módulos. Validamos las relaciones complejas en entidades y garantizamos que los endpoints expongan toda la información necesaria.

Este enfoque facilita el manejar relaciones muchos a muchos en bases de datos utilizando una estructura de módulos bien definida, inyecciones de dependencias y validaciones de DTO que protegen y estructuran la integridad de nuestros datos, ofreciendo una manera eficiente de administrar las operaciones de la aplicación.

Ángel David Roque Ayala

Hace 5 años

Mis apuntes

nest g s users/services/orders --flat
nest g co users/controllers/orders --flat
nest g co users/services/order-item --flat
nest g co users/controllers/order-item --flat

// src\users\dtos\order.dto.ts
import { ApiProperty, PartialType } from "@nestjs/swagger";
import { IsNotEmpty, IsPositive } from "class-validator";

export class CreateOrderDto {
  @IsPositive()
  @IsNotEmpty()
  @ApiProperty()
  readonly customerId: number;

}

export class UpdateOrderDto extends PartialType(CreateOrderDto){}

// src\users\services\orders.service.ts
import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { CreateOrderDto, UpdateOrderDto } from '../dtos/order.dto';
import { Customer } from '../entities/customer.entity';
import { Order } from '../entities/order.entity';

@Injectable()
export class OrdersService {
  constructor(
    @InjectRepository(Order) private orderRepo:Repository<Order>,
    @InjectRepository(Customer) private customerRepo:Repository<Customer>
  ){}

  findAll(){
    return this.orderRepo.find();
  }

  async findOne(id: number){
    const order = await this.orderRepo.findOne(id);
    if(!order) {
      throw new NotFoundException(`order ${id} not found`);
    } 
    return order;
  }

  async create(data: CreateOrderDto){
    const order = new Order();
    if (data.customerId) {
      const customer = await this.customerRepo.findOne(data.customerId);
      order.customer = customer;
    }
    return this.orderRepo.save(order);
  }

  async update(id:number, changes:UpdateOrderDto){
    const order = await this.orderRepo.findOne(id);
    if (changes.customerId) {
      const customer = await this.customerRepo.findOne(changes.customerId);
      order.customer = customer;
    }
    return this.orderRepo.save(order);
  }

  delete(id:number){
    return this.orderRepo.delete(id);
  }
}

// src\users\controllers\orders.controller.ts
import { Body, Controller, Delete, Get, Param, ParseIntPipe, Post, Put } from '@nestjs/common';
import { CreateOrderDto, UpdateOrderDto } from '../dtos/order.dto';
import { OrdersService } from '../services/orders.service';

@Controller('orders')
export class OrdersController {
  
  constructor(private ordersService: OrdersService){}

  @Get('')
  findAll(){
    return this.ordersService.findAll();
  }

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

  @Post('')
  create(@Body() payload: CreateOrderDto){
    return this.ordersService.create(payload);
  }

  @Put(':id')
  update(
    @Param('id', ParseIntPipe) id:number,
    @Body() payload: UpdateOrderDto
  ){
    return this.ordersService.update(id, payload);
  }

  @Delete(':id')
  delete(@Param('id') id: number){
    return this.ordersService.delete(id);
  }
}

// src\users\dtos\order-item.dto.ts
import { ApiProperty, PartialType } from "@nestjs/swagger";
import { IsNotEmpty, IsNumber, IsPositive } from "class-validator";

export class CreateOrderItemDto {
  @IsNumber()
  @IsPositive()
  @IsNotEmpty()
  @ApiProperty()
  readonly orderId: number;

  @IsNumber()
  @IsPositive()
  @IsNotEmpty()
  @ApiProperty()
  readonly productId: number;

  @IsNumber()
  @IsPositive()
  @IsNotEmpty()
  @ApiProperty()
  readonly quantity: number;
}

export class UpdateOrderItemDto extends PartialType(CreateOrderItemDto){}

// src\products\products.module.ts
@Module({
  ...
  exports: [..., TypeOrmModule], // export TypeOrmModule
})
export class ProductsModule {}

// src\users\services\order-item.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Product } from 'src/products/entities/product.entity';
import { Repository } from 'typeorm';
import { CreateOrderItemDto, UpdateOrderItemDto } from '../dtos/order-item.dto';
import { OrderItem } from '../entities/order-item.entity';
import { Order } from '../entities/order.entity';

@Injectable()
export class OrderItemService {
  constructor(
    @InjectRepository(Product) private productRepo:Repository<Product>,
    @InjectRepository(Order) private orderRepo:Repository<Order>,
    @InjectRepository(OrderItem) private orderItemRepo: Repository<OrderItem>
  ){}

  async create(data: CreateOrderItemDto){
    const order = await this.orderRepo.findOne(data.orderId);
    const product = await this.productRepo.findOne(data.productId);
    const newOrderItem = new OrderItem();
    newOrderItem.order = order;
    newOrderItem.product = product;
    newOrderItem.quantity = data.quantity;
    return this.orderItemRepo.save(newOrderItem)
  }
}

// src\users\controllers\order-item.controller.ts
import { Body, Controller, Post } from '@nestjs/common';
import { CreateOrderItemDto } from '../dtos/order-item.dto';
import { OrderItemService } from '../services/order-item.service';

@Controller('order-item')
export class OrderItemController {
  
  constructor(private orderItemService: OrderItemService){}
  
  @Post('')
  create(@Body() payload: CreateOrderItemDto){
    return this.orderItemService.create(payload);
  }
}

// src\users\services\orders.service.ts
async findOne(id: number){
    const order = await this.orderRepo.findOne(id, {
      relations: ["items", "items.product"] // Agregamos relacion
    });
    if(!order) {
      throw new NotFoundException(`order ${id} not found`);
    } 
    return order;
  }

Renato Renzo Luna Herrera

Hace 5 años

nest g s users/services/order-item --flat

Comentarios (18)18 comentarios

Miguel Mendoza

JOSE ALCIVAR GARCIA

Jose Daniel Barría Reyes

Edward Trigos Lopez

Luis Berenguer

Jose Luis Ospino Cueva

Hace 4 años

Nahuel Soma

andrstejada12

Ricardo Tribaldos Hernández

Gerardo Guevara

Carlos Diaz

Jhon Stiven Granada Acevedo

Omar Blanco

Hace 3 años

Jorge Blanco

Brandon Lee Aguero Fernandez

Carlos Alberto Cabrera Quiroga

Gustavo Restrepo

Gonzalo Chaparro

Heyner Javier Marmol Verbel

Ivan Camilo Buitrago Buitrago

Hace un año

Introducción

Conexiones a Bases de Datos con Time OEM y NetsGIS

Integración de Datos con Next.js y Time ORM en Proyectos E-commerce

Database

Instalación de Docker en Windows, macOS y Ubuntu

Configuración de Postgres en Docker Compose

Conexión a Postgres en Docker: Terminal y PgAdmin

Conexión de NestJS a Postgres con Node Postgres

Inyección de Dependencias en NETJS: Conexión a PostgreSQL

Conexión a Bases de Datos con Variables de Entorno en Node.js

TypeORM

Implementación de TypeORM con NestJS en Proyectos Node.js

Creación de Entidades en ORM para Tiendas Virtuales

Implementación del Patrón Repository en NestJS con TypeORM

Operaciones CRUD en ProductService usando TypeORM y Postgres

Cambio de Postgres a MySQL en Docker para CRUD de Productos

Migraciones

Configuración de Migraciones en Bases de Datos con TimeORM

Configuración y uso de migraciones con TimeORM y TypeScript

Ejecución y gestión de migraciones con Time1M en Node.js

Migraciones en bases de datos: agregar campos automáticamente

Relaciones

Relaciones 1 a 1 en Bases de Datos con TimeORM

Manipulación de Relaciones Uno a Uno en Controladores y Servicios

Relaciones Uno a Muchos en Bases de Datos con TypeORM

Gestión de Relaciones Uno a Muchos en Controladores de API

Relaciones Muchos a Muchos en Time1M: Creación y Manejo Práctico

Manipulación de Relaciones Muchos a Muchos en Controladores

Manipulación de Relaciones Muchos a Muchos con TimeORM en JavaScript

Relaciones Muchos a Muchos con Campos Agregados en TimeWareM

CRUD de órdenes de compra y gestión de ítems en NestJS

Consultas

Paginación de Productos con Limit y Offset en Controladores API

Filtrado de Precios con Rango Usando Between en Time Wareham

Indexación de Parámetros en Bases de Datos: Uso y Precauciones

Buenas prácticas de nombramiento en JavaScript y bases de datos

Serialización y Transformación de Datos en APIs con ClassTransformer

Migración a NestJS 9 y TypeORM 0.3

Actualización de dependencias en NEST y TimeWareM

Migración y ajustes en TimewareM 0.3: Cambios en métodos y servicios

Actualización de Migraciones en TimeWareM 0.3

Próximos pasos

Soluciones a referencias circulares en módulos NestJS

Persistencia de Datos con Time Ware M: Conexiones y Buenas Prácticas

CRUD de órdenes de compra y gestión de ítems en NestJS