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

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

Resumen

¿Cómo manipular una relación uno a uno en el controlador?

En la programación, manipular relaciones de base de datos de una manera efectiva es esencial para crear aplicaciones robustas y funcionales. Vamos a explorar cómo implementar y manejar una relación uno a uno en un controlador, específicamente en la parte de creación de usuarios con un Customer ID opcional en una base de datos.

¿Qué cambios hacer en el Data Transfer Object (DTO)?

Cuando se crea un usuario, a menudo necesitamos enviar datos adicionales más allá de simplemente un correo electrónico y contraseña. Por eso, es importante modificar el DTO para recibir y manejar un nuevo atributo, el Customer ID. Este campo es opcional, por lo que al no ser enviado, no generará errores.

Código para el DTO:

export class CreateUserDTO {
  @ApiProperty()
  email: string;

  @ApiProperty()
  password: string;

  @ApiProperty()
  role: string;

  @ApiProperty({ required: false })
  @IsPositive()
  customerID?: number;
}

¿Cómo trabajar la lógica de la relación?

El siguiente paso consiste en la creación del usuario mediante el servicio adecuado – en este caso, el CustomerService. Si se proporciona un Customer ID, se debe buscar en la base de datos y establecer la relación.

Implementación en el controlador:

Inyección del CustomerService: Para reutilizar las funciones del servicio.
Validación: Verificar si se envía el Customer ID.
Relationship Setting: Buscar el Customer usando el ID y establecer la relación.

¿Qué sucede si hay errores en la base de datos?

Al implementar relaciones, es común enfrentar errores si las llaves primarias no están configuradas como autoincrementales. Esto evita que la base de datos genere automáticamente identificadores únicos.

Solución del error de autoincremento:

Modificar las entidades para incluir el decorador correcto para que las llaves primarias sean autogeneradas.

@Entity()
export class UserEntity {
  @PrimaryGeneratedColumn()
  id: number;

  // otros campos...
}

¿Por qué es importante generar una migración?

Los cambios en la estructura de las entidades requieren una migración de base de datos para sincronizar los cambios de manera controlada y segura.

Generar migración: Ejecutar npm run migrations:generate -- fixid.
Ejecutar migración: Use npm run migrations para aplicar los cambios.

¿Cómo probar la relación en el entorno real?

Luego de realizar los cambios, es esencial probar el endpoint. Usando una herramienta como Insomnia, se puede verificar el flujo al crear un usuario y asociarlo con un cliente.

Probar el endpoint de creación: Verificar que el identifier sea autogenerado y que el Customer ID sea opcional.
Relacionar usuario y cliente: Introducir un Customer ID existente para establecer la relación.

¿Cómo visualizar la relación en las respuestas?

Finalmente, para listar usuarios y ver sus relaciones en un solo paso, es fundamental modificar el servicio para incluir las relaciones cuando se obtengan los datos.

Modificación en el servicio:

findAll() {
  return this.userRepository.find({ relations: ['customer'] });
}

Al aplicar estos pasos, se puede listar todos los usuarios y sus correspondientes relaciones de manera efectiva. Dominar estos conceptos es crucial para la manipulación avanzada de bases de datos. ¡Sigue explorando y aprendiendo!

Ángel David Roque Ayala

student•

Cambiando el dto user

// src/users/dtos/user.dto
export class CreateUserDto {
  ...

	// Agregamos atributo
  @IsOptional()
  @IsNotEmpty()
  @ApiProperty() 
  readonly customerId: number; 
}

export class UpdateUserDto extends PartialType(CreateUserDto) {}

Modificando la funcion crear

Si el objeto contiene un customerId traemos los datos usando el servicio de customer

//src/users/services/user.service

async create(data: CreateUserDto) {
    const newUser = this.userRepo.create(data);
    if(data.customerId){
      const customer = await this.customerService.findOne(data.customerId);
      newUser.customer = customer;
    }
    return await this.userRepo.save(newUser);
  }

Modificando la funcion find

Si queremos que cuando se consulte al usuario tambien se obtengan los datos del customer debemos agregar la siguiente opcion

async findAll() {
    return await this.userRepo.find({
      relations: ['customer'] // esta
    });
  }

async findOne(id: number) {
  const user = await this.userRepo.findOne(id, {
    relations: ['customer'] // esta
  });
    
	if (!user) {
	    throw new NotFoundException(`User #${id} not found`);
	 }
   return user;
}

Andrés Esteban Rodríguez Jiménez

student•

Resolviendo la relación uno a uno en el controlador

Vamos a resolver que al momento de crear un usuario, podamos mandar un id de un customer y así mismo crear la relación, pero para esto primero debemos modificar el DTO de creación de usuario:

src/users/dtos/user.dto:

// ...

export class CreateUserDto {
  // ..

	// simplemente especificamos que existe esta propiedad
	// anadimos validaciones
  @IsPositive()
  @IsOptional()
  @ApiProperty()
  readonly customerId: number;
}

export class UpdateUserDto extends PartialType(CreateUserDto) {}

Ahora si, vamos a modificar nuestro servicio de usuarios y vamos a preguntar si existe un customerId, y si sí, resolvamos la relación:

**src/users/services/user.service**:

// ...

import { User } from '../entities/user.entity';
import { CreateUserDto, UpdateUserDto } from '../dtos/user.dto';

import { ProductsService } from './../../products/services/products.service';
// importamos el servicio de Customers
import { CustomersService } from './customers.service';

@Injectable()
export class UsersService {
  constructor(
    // inyectamos el servicio de customers en nuestro servicio
    private customersService: CustomersService,
    @InjectRepository(User) private userRepo: Repository<User>,
  ) {}

  findAll() {
		// al momento de traer los usuarios, traemos su customer en caso de tenerlo
    return this.userRepo.find({
      where: { id },
      relations: ['customer'],
    });
  }

  async findOne(id: number) {
    // al momento de traer un usuario, traemos su customer en caso de tenerlo
    const user = await this.userRepo.findOne({
      where: { id },
      relations: ['customer'],
    });
    if (!user) {
      throw new NotFoundException(`Users #${id} not found`);
    }
    return user;
  }

  async create(data: CreateUserDto) {
    const newUser = this.userRepo.create(data);
    // si existe un customer el la data que nos envían
    if (data.customerId) {
      // encuentra a ese customer en base a su id
      const customer = await this.customersService.findOne(data.customerId);
      // relaciona al usuario con el customer
      newUser.customer = customer;
    }
    return this.userRepo.save(newUser);
  }

  // ...
}

Y listo, ya hemos resuelto la relación entre user y customer.

Miguel Angel Reyes Moreno

student•

El nombre de esta clase debe ser "Resolviendo la relación uno a uno en el SERVICIO" pues al final es ahí donde mandamos la instrucción de las relaciones.

Juan Collado

student•

FindOne

Resolver relacion en el metodo findOne

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

Nicolas Schimpf

student•

Hay un problema semantico con este código. Idealmente, no deberías obtener un producto del repositorio de usuarios, para eso está el repositorio de productos.

Saludos

Juan Collado

student•

Gracias Nicolas! En realidad nombré mal el nombre de la constante, ya que en el ejemplo, mi idea sí era obtener el usuario con el userRepository y resolver la relación de customer.

Entonces en vez de const product -> const user Saludos!

William Condori

student•

Para obtener un usuario con su customer, en el método findOne, pueden hacer el siguiente cambio:

 async findOne(id: number) {
    const user = await this.userRepo.findOne(id, { relations: ['customer'] });
    if (!user) {
      throw new NotFoundException(`User #${id} not found`);
    }
    return user;
  }