Manipulación de Relaciones Muchos a Muchos en Controladores

Clase 23 de 36 • Curso de NestJS: Persistencia de Datos con TypeORM

Resumen

¿Cómo gestionar relaciones muchos a muchos en un controlador?

Para aquellos que buscan manejar relaciones muchos a muchos en sus bases de datos, comprender cómo hacerlo en los controladores es clave para una aplicación robusta. En este contenido, vamos a desglosar el proceso paso a paso y compartir algunas prácticas para optimizar la manipulación de estas relaciones.

¿Cómo se define y valida el DTO para manejar categorías en un producto?

Definición del campo nuevo: Al crear un producto y querer relacionarlo a varias categorías, debemos incluir un nuevo campo en el DTO llamado categoriesIDs. Este será un array de IDs que representa las categorías asociadas.
Validación del DTO: Es obligatorio que el DTO verifique que el campo categoriesIDs no esté vacío y que sea efectivamente un array. Para esto, usaremos validadores de class-validator, asegurando que nuestro DTO solo acepte datos válidos.

¿Cómo se resuelven múltiples relaciones en servicios?

En lugar de resolver cada relación individualmente, TimeWareM ofrece métodos que ayudan a buscar múltiples IDs con una sola consulta, lo que es eficiente y efectivo.

Inyección de servicios: Aunque podrías agregar métodos para buscar múltiples IDs en un servicio, es aconsejable inyectar directamente el InjectRepository para manipular las tablas, evitando redundancias innecesarias.
Uso del repositorio directo: Al inyectar directamente el repositorio (en este caso, CategoryRepo), puedes utilizar métodos eficientes como FindByIDs, que te permitirán asignar directamente un grupo de categorías a un nuevo producto.

¿Cómo asegurar una respuesta optimizada al crear productos?

Es crucial evitar que el controlador devuelva datos innecesarios, ya que esto puede hacer que las solicitudes sean más pesadas y lentas.

Control de la respuesta: Evita reutilizar métodos de servicio que incluyan relaciones innecesarias. Si una relación no es necesaria para la respuesta, es mejor hacer consultas directas al repositorio.
Optimización de las solicitudes: Evalúa la necesidad de las relaciones devueltas. Por ejemplo, al mostrar el detalle de un producto, podrías querer información adicional como las relaciones, mientras que en una lista resumida esto podría ser innecesario.

¿Qué hacer para resolver relaciones en detalle?

Cuando se trata de mostrar los detalles de un producto, especialmente si tu aplicación manejará datos que dependen de muchas relaciones, asegúrate de estar preparado para responder con toda la información relevante:

Detallado de productos: Al obtener los detalles de un producto específico, podemos enriquecer la respuesta mostrando relaciones detalladas como la marca y las categorías asociadas, optimizando así la experiencia del usuario.
Mostrar productos por categoría: En una consulta basada en categoría, también es válido devolver un array de productos asociados a una categoría específica, aprovechando la relación muchos a muchos y proporcionándole al usuario una vista clara de las asociaciones.

¿Cómo resolver cambios en las relaciones?

Finalmente, un tema a menudo ignorado es cómo manejar cambios en relaciones existentes, como agregar o quitar una categoría asociada a un producto.

Modificaciones dinámicas: Las operaciones para modificar estas relaciones, como agregar o quitar categorías de un producto, pueden llevarse a cabo a través de la lógica implementada en el controlador, que se verá en detalle en futuras clases.

Este contenido te prepara mejor para manejar relaciones complejas en una aplicación utilizando controladores y servicios, optimizando tanto la creación como la respuesta al cliente. ¡Ahora es el momento perfecto para poner todo esto en práctica y continuar tu aprendizaje!

Mónica Paola Parra López

student•

El .findByIds esta deprecated por lo cual se debe usar

import { In } from 'typeorm';

this.categoryRepo.findBy({id: In([1, 2, 3, 4])})

fernando alzate

student•

A mi solo me funciono asi:

if(data.categoriesIds){ const categories = await this.categoryRepo.findBy({ categoryId: Any([data.categoriesIds])
})

David Hilera

student•

Así me funciono.

 if (payload.categoriesdIds) {
      const categories = await this.categoryRepo.findBy({
        id: In(payload.categoriesdIds),
      });

      newProduct.categories = categories;
    }

Jairo Campos Ruiz

student•

Buenas la forma correcta de revisar categoriesId en el dto es

@ApiProperty()
  @IsArray()
  @ArrayMinSize(1)
  @IsNumber({}, { each: true })
  readonly categoriesId: number[];

De esta manera te revisa que tenga al menos 1 elemento el arrray y que los elementos sean numbers

Robinson De La Cruz

student•

También se puede usar el decorador @ArrayNotEmpty() en vez de @ArrayMinSize(1)

Ángel David Roque Ayala

student•

Apuntes

modificamos el dto

import {
  IsString,
  IsNumber,
  IsUrl,
  IsNotEmpty,
  IsPositive,
  IsArray,
} from 'class-validator';
import { PartialType, ApiProperty } from '@nestjs/swagger';

export class CreateProductDto {
	...

  // Agregamos este campo
  @IsArray()
  @IsNotEmpty()
  @ApiProperty()
  readonly categoriesIds: number[];

}

export class UpdateProductDto extends PartialType(CreateProductDto) {}

Create

Modificaremos el metodo para crear un producto

// src\products\services\products.service.ts
async create(data: CreateProductDto) {
    const newProduct = this.productRepo.create(data);
    if (data.brandId) {
      const brand = await this.brandRepo.findOne(data.brandId);
      newProduct.brand = brand;
    }

	// Aqui resolvemos la categoria
    if (data.categoriesIds) {
      const categories = await this.categoryRepo.findByIds(data.categoriesIds);
      newProduct.categories = categories
    }

    return this.productRepo.save(newProduct);
  }

Find

// src\products\services\products.service.ts
async findOne(id: number) {
    const product = await this.productRepo.findOne(id,{
      relations: ['brand', 'categories']
    });
    if (!product) {
      throw new NotFoundException(`Product #${id} not found`);
    }
    return product;
  }

Find of categories

// src\products\services\categories.service.ts
async findOne(id: number) {
    const category = await this.categoryRepo.findOne(id,{
      relations: ['products']
    });
    if (!category) {
      throw new NotFoundException(`Category #${id} not found`);
    }
    return category;
  }

Andres Prieto

student•

Según este pedazo de clean code para JS; la mejor manera para hacer la parte de la consulta sin relaciones es como lo muestra Nico; pero según este pedazo, que habla sobre SOLID, es mejor tratar de dejar el servicio de productos sin inyecciones externas de código (Es decir, el repositorio); por lo que pienso que la mejor aproximación sería usar un método en el servicio Brand

Gustavo Rodolfo Jimenez Jaramillo

student•

Tengo una duda respecto a la forma en la cual se inserta brands, ¿es necesario buscar toda la entidad? o bastaría con crear una entidad brands y setearle solo el id para luego setearlo en el products

Nicolas Molina

teacher•

Con TypeOrm se base en POO entonces la mejor práctica es traer la entidad para poder relacionarlo de por sí hay issue para ver lo agregan en el issue hay hacks para lograrlo con el ID.

Axel Gabriel Valles Guerrero

student•

Lo logré de esta forma:

const categories = await this.categoryRepository.find({
where: data.categoriesIds.map((categoryId) => ({ id: categoryId })),
});

Ya que al pasar un array en el where le estás diciendo que utilice el operador or, así no tenemos por qué importar "In" de typeorm y además podemos controlar de mejor forma la consulta.

Juan Camilo Noreña López

student•

Así tengo mi create product y me funciona bien:

  async create(data: CreateProductDto) {
    // const product = new Product();
    // product.name = data.name;
    // product.description = data.description;
    // product.price = data.price;
    // product.stock = data.stock;
    // product.image = data.image;
    // return this.productRepo.save(product);
    const product = this.productRepo.create(data);
    product.brand = await this.brandRepo.findOneBy({ id: data.brandId });
    const categories = await this.categoryRepo.findBy({
      id: In(data.categoriesIds),
    });
    product.categories = categories;
    return this.productRepo.save(product);
  }

Ahora el update no me funciona como al profe ya que algunos métodos están obsoletos, como lo puedo resolver al día de hoy

Juan Camilo Noreña López

student•

Este es el error que me da:

ERROR [ExceptionsHandler] Class constructor PartialTypeClass cannot be invoked without 'new'
TypeError: Class constructor PartialTypeClass cannot be invoked without 'new'
    at new UpdateProductDto 
    at TransformOperationExecutor.transform 
    at ClassTransformer.plainToInstance 
    at Object.plainToClass 
    at ValidationPipe.transform 
    /nestjs/nestjs-typeorm/node_modules/@nestjs/core/pipes/pipes-consumer.js:16:33
    at processTicksAndRejections (node:internal/process/task_queues:95:5)

Juan Camilo Noreña López

student•

El error es porque en el momento no esta funcionando PartialType ni de swagger ni de mapped-types, entonces lo resolvi creando el UpdateDto manualmente.

import {
  IsNumber,
  IsString,
  IsUrl,
  IsNotEmpty,
  IsPositive,
  IsOptional,
  Min,
  ValidateIf,
  IsArray,
} from 'class-validator';
import { ApiProperty } from '@nestjs/swagger';
// import { CreateCategoryDto } from './categories.dtos';
export class CreateProductDto {
  @ApiProperty({ description: 'name of product' })
  @IsNotEmpty()
  @IsString()
  readonly name: string;
  @ApiProperty()
  @IsNotEmpty()
  @IsString()
  readonly description: string;
  @ApiProperty()
  @IsNotEmpty()
  @IsNumber()
  @IsPositive()
  readonly price: number;
  @ApiProperty()
  @IsNotEmpty()
  @IsNumber()
  @IsPositive()
  readonly stock: number;
  @ApiProperty()
  @IsNotEmpty()
  @IsUrl()
  readonly image: string;
  @IsNotEmpty()
  @ApiProperty()
  @IsPositive()
  readonly brandId: number;
  @IsNotEmpty()
  @ApiProperty()
  @IsArray()
  readonly categoriesIds: number[];
  // @ApiProperty()
  // @ValidateNested()
  // @IsNotEmpty()
  // readonly category: CreateCategoryDto;
  // @IsNotEmpty()
  // @IsMongoId()
  // readonly brand: string;
}

export class UpdateProductDto {
  @ApiProperty({ description: 'name of product' })
  @IsOptional()
  @IsString()
  readonly name: string;
  @ApiProperty()
  @IsOptional()
  @IsString()
  readonly description: string;
  @ApiProperty()
  @IsOptional()
  @IsNumber()
  @IsPositive()
  readonly price: number;
  @ApiProperty()
  @IsOptional()
  @IsNumber()
  @IsPositive()
  readonly stock: number;
  @ApiProperty()
  @IsOptional()
  @IsUrl()
  readonly image: string;
  @IsOptional()
  @ApiProperty()
  @IsPositive()
  readonly brandId: number;
  @IsOptional()
  @ApiProperty()
  @IsArray()
  readonly categoriesIds: number[];
}

Y así queda el update:

  async update(id: number, changes: UpdateProductDto) {
    const product = await this.productRepo.findOneBy({ id });
    if (!product) {
      throw new NotFoundException(`Product #${id} not found`);
    }
    if (changes.brandId) {
      const brand = await this.brandRepo.findOneBy({ id: changes.brandId });
      if (!brand) {
        throw new NotFoundException(`Brand #${changes.brandId} not found`);
      }
      product.brand = brand;
    }
    this.productRepo.merge(product, changes);
    return this.productRepo.save(product);
  }

David Amador

student•

Para el brand.service he resuelto esto; Así no importamos todo el repositorio completo nuevamente desde product.service.


async findOne(id: number, withRelations: boolean = true) {

&#x20; const options = this.getFindOptions(withRelations)

&#x20; const document = await this.repo.findOne(id, options)



&#x20; if (!document) {

&#x20;   this.throwDocumentNotFoundException(id)

&#x20; }



&#x20; return document

}



private getFindOptions(withRelations: boolean) {

&#x20; return withRelations ? { relations: \['products'] } : undefined

}



private throwDocumentNotFoundException(id: number): never {

&#x20; throw new NotFoundException(`Document #${id} not found`)

}

Miguel Angel Reyes Moreno

student•

Este cambio de código:

async findOne(id: number) {
    const category = await this.categoryRepo.findOne(id, {
      relations: ['products'],
    });
    if (!category) {
      throw new NotFoundException(`Category #${id} not found`);
    }
    return category;
  }

Lo hicimos en el SERVICIO, no en el controlador, la clase debería cambiar su título.

Jhon Stiven Granada Acevedo

student•

lo pueden hacer de esta manera TypeORM ha cambiado cositas

this.categoryRepo.findOne({ where: { id }, relations: ['products'], })

Robinson De La Cruz

student•

En caso tal estén haciendo cambios y no los vean reflejados al hacer las peticiones, deben hacer build npm run build y luego volver a correr el proyecto. Otra solución es eliminar la carpeta dist y volver a correr el proyecto.