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

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