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

Curso de NestJS: Persistencia de Datos con TypeORM

Contenido del curso

Introducción

Database

TypeORM

Migraciones

Relaciones

Consultas

Migración a NestJS 9 y TypeORM 0.3

Próximos pasos

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0010:28

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

Recursos

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

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:

// ...

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.

Introducción

Conexiones a Bases de Datos con Time OEM y NetsGIS

Integración de Datos con Next.js y Time ORM en Proyectos E-commerce

Database

Instalación de Docker en Windows, macOS y Ubuntu

Configuración de Postgres en Docker Compose

Conexión a Postgres en Docker: Terminal y PgAdmin

Conexión de NestJS a Postgres con Node Postgres

Inyección de Dependencias en NETJS: Conexión a PostgreSQL

Conexión a Bases de Datos con Variables de Entorno en Node.js

TypeORM

Implementación de TypeORM con NestJS en Proyectos Node.js

Creación de Entidades en ORM para Tiendas Virtuales

Implementación del Patrón Repository en NestJS con TypeORM

Operaciones CRUD en ProductService usando TypeORM y Postgres

Cambio de Postgres a MySQL en Docker para CRUD de Productos

Migraciones

Configuración de Migraciones en Bases de Datos con TimeORM

Configuración y uso de migraciones con TimeORM y TypeScript

Ejecución y gestión de migraciones con Time1M en Node.js

Migraciones en bases de datos: agregar campos automáticamente

Relaciones

Relaciones 1 a 1 en Bases de Datos con TimeORM

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

Relaciones Uno a Muchos en Bases de Datos con TypeORM

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

Relaciones Muchos a Muchos en Time1M: Creación y Manejo Práctico

Manipulación de Relaciones Muchos a Muchos en Controladores

Manipulación de Relaciones Muchos a Muchos con TimeORM en JavaScript

Relaciones Muchos a Muchos con Campos Agregados en TimeWareM

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

Consultas

Paginación de Productos con Limit y Offset en Controladores API

Filtrado de Precios con Rango Usando Between en Time Wareham

Indexación de Parámetros en Bases de Datos: Uso y Precauciones

Buenas prácticas de nombramiento en JavaScript y bases de datos

Serialización y Transformación de Datos en APIs con ClassTransformer

Migración a NestJS 9 y TypeORM 0.3

Actualización de dependencias en NEST y TimeWareM

Migración y ajustes en TimewareM 0.3: Cambios en métodos y servicios

Actualización de Migraciones en TimeWareM 0.3

Próximos pasos

Soluciones a referencias circulares en módulos NestJS

Persistencia de Datos con Time Ware M: Conexiones y Buenas Prácticas

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