Cursos Empresas Blog Live Conf Eventos Precios

0:0010:28

Recursos

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!

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

Curso de NestJS: Persistencia de Datos con TypeORM

Clase 19 de 36

Clase 19 / 36

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

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

export class UpdateUserDto extends PartialType(CreateUserDto) {}

//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);
  }

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;
}

// ...

export class CreateUserDto {
  // ..

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

export class UpdateUserDto extends PartialType(CreateUserDto) {}

// ...

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);
  }

  // ...
}

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

// ...

export class CreateUserDto {
  // ..

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

export class UpdateUserDto extends PartialType(CreateUserDto) {}

// ...

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);
  }

  // ...
}

Comentarios (5)5 comentarios

Ángel David Roque Ayala

Hace 5 años

Cambiando el dto user

Modificando la funcion crear

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

Modificando la funcion find

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

Andrés Esteban Rodríguez Jiménez

Hace 3 años

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:

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**:

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

Miguel Angel Reyes Moreno

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

Hace 4 años

FindOne

Resolver relacion en el metodo findOne

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

Nicolas Schimpf

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

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

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

Recursos

Resumen

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

Progreso del curso

Introducción

Database

TypeORM

Migraciones

Relaciones

Consultas

Migración a NestJS 9 y TypeORM 0.3

Próximos pasos