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

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

Resumen

¿Cómo manejar relaciones entre entidades en un controller?

Cuando trabajamos con estructuras de datos que tienen relaciones entre entidades, la clave es poder gestionarlas efectivamente dentro de los controladores. En este caso, exploraremos cómo desde una marca se pueden obtener todos los productos relacionados a ella y viceversa. Abordaremos ejemplos precisos sobre cómo manipular estas relaciones usando el controlador.

¿Cómo configurar una relación ante creación de un producto?

Al crear un producto, es crucial especificar a qué marca pertenece. Para lograrlo, es necesario solicitar el Brand ID, el cual no puede ser nulo ya que establece la relación entre el producto y la marca.

// En el controlador de productos
export class CreateProductDto {
    @ApiProperty({ description: 'Brand ID al que pertenece el producto' })
    readonly brandId: number;
}

Validación de la entrada: Asegúrate de validar brandId para que sea positivo y no esté vacío.
Uso de servicios: Reutiliza métodos en los servicios para verificar que este ID exista usando, por ejemplo, BrandService.findOne().
Asignación de la marca al producto: Una vez verificado, asigna la marca al producto antes de guardarlo.

¿Cómo actualizar la relación de un producto?

Para cambiar la marca a la que pertenece un producto, primero verifica si el Brand ID fue actualizado. De ser así, asigna el nuevo valor al producto.

Recepción de cambios: Usa un objeto de cambios que permita identificar qué atributos se desean actualizar.
Validaciones necesarias: Valida si brandId está presente; si no es así, no lo actualices.
Relación y asignación: Si brandId está presente, busca la nueva marca y asóciala al producto.

¿Cómo visualizar las relaciones en las respuestas?

Para que las respuestas de las consultas contengan las relaciones, es esencial especificar que se deben incluir al realizar los llamados a las bases de datos.

// Ejemplo en el controlador de Productos para incluir relaciones
products = await this.productService.findAll({
    relations: ['brand'],
});

¿Cómo gestionar la relación de uno a muchos dentro de las marcas?

En ciertas ocasiones, necesitarás obtener no solo la información básica de una marca, sino también todos los productos asociados. Esto es especialmente útil para representar la relación de uno a muchos.

Controladores enfocados: Realiza esta lógica en el controlador de marcas, especialmente útil cuando cargas detalles específicos.
Optimización de respuestas: Evita cargar relaciones innecesarias en llamadas globales para disminuir la pesadez de los datos.
Implementación de queries: Usa parámetros de relaciones para extraer los productos relacionados a la marca solicitada.

Consejos prácticos para manejar errores y mejoras

Manejo de errores: Siempre debe tener una gestión adecuada de errores, especialmente para situaciones como intentos de duplicación de datos, donde dos productos tienen el mismo nombre.

Práctica constante: La habilidad de gestionar relaciones efectivas entre entidades es clave en cualquier aplicación robusta. Experimenta con varias configuraciones para encontrar estructuras eficientes para tus proyectos.

Incorporando estos pasos y técnicas, podrás gestionar relaciones entre entidades de manera efectiva y optimizada, mejorando así las funcionalidades de tus aplicaciones y la calidad del código. ¿Listo para seguir avanzando? La gestión de las relaciones entre entidades es esencial y una práctica constante te permitirá dominarla. ¡Sigue aprendiendo y perfeccionando tus proyectos!

Carlos Vallejo

student•

En el servicio para una marca por Id, falta colocar la condición (where) para que busque el Id que enviamos. Quedaría así:

const product = await this.brandsRepo.findOne({
      relations: ['products'],
      where: {
        id,
      },
});

Juan Caballero

student•

Pero en la consulta se usa el metodo finOne con el id como parametro

const brand = await this.brandRepo.findOne(id,{
      relations: ['products']
    });

Walter Lensinas

student•

Gracias Carlos! iba justo a ver como mandarle el id en ese objeto.

Genio!

Lucas Heim

student•

Dejo una pequeña validacion para manejar los errores del create:

async create(payload: CreateProductDto) {
    const newProduct = this.productRepo.create(payload);
    if (payload.brandId) {
      const brand = await this.brandService.findOne(payload.brandId);
      newProduct.brand = brand;
    }
    const product = this.productRepo
      .save(newProduct)
      .then((res) => {
        return res;
      })
      .catch((err) => {
        throw new BadRequestException(`${err.message || 'Unexpected Error'}`);
      });

    return product;
  }

Juan Camilo Noreña López

student•

Así hice el findOne de brands para que me muestre los productos, ya que como lo hace el profe no me funcionaba.

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

Fabian Siatama

student•

estuve buscando en la documentación de TypeOrm y no encontré como seleccionar las columnas que quiero mostrar de las relaciones, así que después de varios intentos finalmente pude resolverlo así, por si le sirve a alguien…

findByUser(id: number) {
    return this.suscriptionRepo.find({
      relations: ['user'],
      where: {
        user: {
          id,
        },
      },
      select: {
        initialDate: true,
        user: { username: true },
      },
    });
  }

Nicolas Mendoza

student•

Saben si usando consultas sql o typeorm seria encesario poner el relations?

Renato Renzo Luna Herrera

student•

me parece o ese findOne() deberia tener un id en el primer parámetro?, es decir:

const product = await this.brandRepo.findOne(id, {
            relations: ['products']
        });

Renato Renzo Luna Herrera

student•

Hola, tengo una duda, espero puedan ayudarme. Como hago para resolver relaciones uno a muchos o uno a uno entre módulos distintos, es decir, digamos productos y usuarios, dejo un posible ejemplo:

Será así?

// src\users\users.module.ts

import { User } from './entities/user.entity';

@Module({
  imports: [TypeOrmModule.forFeature([ User ])],
  // ...
})
exportclassUsersModule{}

// src\products\products.module.ts

import { Product } from './entities/product.entity';

@Module({
    imports: [TypeOrmModule.forFeature([ Product ])],
    // ...
})
exportclassProductsModule{}

O tal vez así?

// src\products\products.module.ts

import { Product } from'./entities/product.entity';
import { User } from'src/users/entities/user.entity';

@Module({
    imports: [TypeOrmModule.forFeature([Product, User])],
    // ...
})
exportclassProductsModule{}

Espero puedan ayudarme. Muchas gracias.

Juan Camilo Noreña López

student•

La funcion para actualizar brands desde la ruta de products no me funciona, como se debería hacer?

Jenniffer Paola Orjuela

student•

Estoy obteniendo un error al tratar de guardar lo que consulto del rol en mi campo de rol en la entidad de user, porque como le decimos que devuelva el tipo rol o una exception. Como puedo solucionar esto?

El tipo 'Rol | HttpException' no se puede asignar al tipo 'Rol'. Al tipo "HttpException" le faltan las propiedades siguientes del tipo "Rol": id, userst

async create(user: CreateUserDto) {
    const userFound = await this.userRepository.findOne({
      where: {
        username: user.username,
      },
    });

    if (userFound) {
      return new HttpException(
        `The user with that username already exists.`,
        HttpStatus.CONFLICT,
      );
    }

    const newUser: User = this.userRepository.create(user);

    if (user.rolId) {
      const rolFind = await this.rolesServices.findOne(user.rolId);
      newUser.rol = rolFind;
    }

    const createdUser = this.userRepository
      .save(newUser)
      .then((res) => {
        return res;
      })
      .catch((err) => {
        throw new BadRequestException(`${err.message || 'Unexpected Error'}`);
      });

    return createdUser;
  }

Jenniffer Paola Orjuela

student•

I found a way to solve my problem.

if (user.rolId) {
	const rolFind: Rol | HttpException = await this.rolesServices.findOne(user.rolId);
      if (rolFind instanceof Rol) {
        newUser.rol = rolFind;
      } else {
        return new HttpException(
          `The rol assigned to the user doesn't exists.`,
          HttpStatus.CONFLICT,
        );
      }
    }

FABIO COLAN WONG

student•

Hola, tengo una duda, espero me puedan ayudar, como hago para obtener columnas especificas de la relación y no todo los atributos.

Miguel Angel Reyes Moreno

student•

De nuevo, la clase se debería llamar "Resolviendo la relación uno a muchos en el SERVICIO" porque ahí es donde hacemos la instrucción.

Andrés Aguirre

student•

Por algún motivo los errores que lanzaba la base de datos no podian ser manejados con un try/catch, por lo que decidí buscar activamente el nombre primero y si se encontraba, lanzaba el error.

async create(data: CreateProductDto) {
    const existingName = await this.productRepo.findOne({
      where: { name: data.name }, //Busca si hay una coincidencia con el nombre
    }); //Si el query no encuentra nada, devuelve null

 //Por lo que si existingName NO es null, significa que hubo una coincidencia y debemos lanzar el error
    if (!(existingName === null)) {
		throw new BadRequestException('El nombre ya existe, cambielo')} //Lanzamos el error y detiene el resto del codigo


    const newProduct: Product = this.productRepo.create(data);
    if (data.brandId) {
      const brand = await this.brandsService.findOne(data.brandId);
      newProduct.brand = brand;
    }
    this.productRepo.save(newProduct);
    return newProduct;
  }

Mónica Paola Parra López

student•

Lo pude manejar con try/catch y me funciono

    try {
      const product = await this.productRepo.save(newProduct);
      return product;
    } catch (error) {
      throw new BadRequestException(`${error.message || 'Unexpected Error'}'`)
    }```

Cristhian Holguin Carrillo

student•

Una consulta cual seria la diferencia entre usar QueryBuilder, o hacer los query como muestra en el video, o cual recomiendan.

Nicolas Molina

teacher•

Eso depende el QueryBuilder es otra forma de hacer consultas sobre todo si son más complejas, pero esto lo usuaria como último recurso o consultas muy complejas para todo lo de más la API de los repositorios es genial.