Relaciones 1 a 1 en Bases de Datos con TimeORM

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

Resumen

¿Cómo manejar relaciones en bases de datos relacionales con TypeORM?

En el mundo de las bases de datos relacionales, es crucial entender cómo gestionar las diferentes relaciones que pueden ocurrir entre tablas, tales como uno a uno, uno a muchos, y muchos a muchos. En esta clase vamos a explorar cómo se puede utilizar TypeORM para manejar estas relaciones, enfocándonos en la relación uno a uno, específicamente entre un usuario y un cliente (user y customer).

¿Cómo se establece la relación uno a uno?

Vamos a crear las entidades necesarias, siguiendo buenas prácticas en su estructuración:

Entidad Customer:
- Llave primaria (ID).
- Atributos como name, lastName, y phone, todos de tipo Varchar.
- Timestamps para created_at y updated_at.
Entidad User:
- Llave primaria (ID).
- Atributos como email, password (encriptado en futuras implementaciones), y role.
- Timestamps para created_at y updated_at.

Ambas entidades deben ser declaradas en el User Module, donde se configurarán como entidades gestionadas por TypeORM.

¿Cómo crear la relación uno a uno?

Para implementar la relación uno a uno, se deben importar y utilizar dos decoradores de TypeORM: @OneToOne y @JoinColumn. Nuestra relación, en este escenario, será opcional, permitiendo que algunos usuarios no tengan clientes asociados (usuarios administrativos, por ejemplo).

// En User Entity
@OneToOne(() => CustomerEntity, { nullable: true })
@JoinColumn()
customer: CustomerEntity;

Usamos @OneToOne para declarar la relación y @JoinColumn exclusivamente en una de las entidades, designando la entidad "dueña" de la relación.

¿Cómo manejar relaciones bidireccionales?

TypeORM admite relaciones bidireccionales, lo que significa que cualquier entidad puede conocer su contraparte asociada:

// En Customer Entity
@OneToOne(() => UserEntity, user => user.customer, { nullable: true })
user: UserEntity;

Aquí especificamos el decorador @OneToOne con una row function, resolviendo la relación desde ambas entidades. Sin embargo, @JoinColumn solo se especifica en un lado, en este caso en User, para establecer quién tiene la relación en la base de datos.

¿Cómo crear y ejecutar migraciones?

Para establecer nuestras entidades en la base de datos, es indispensable generar y ejecutar migraciones:

Crear migración:

npm run typeorm migration:generate -- create-user-and-customer

Ejecutar migración:
```
npm run typeorm migration:run
```

Estas acciones se traducen en la creación física de las tablas y relaciones en la base de datos. Puedes verificar la ejecución accediendo a pgAdmin y revisando los esquemas generados.

¿Cómo verificar estructuras de tablas desde el terminal?

Puedes inspeccionar las estructuras y relaciones creadas por TypeORM conectándote directamente al contenedor de PostgreSQL:

docker-compose exec postgres-container bash

psql -h localhost -d mydb -U root

\d+ users  // Consultar detalles de la tabla users

Esta metodología te permite verificar la estructura de las tablas y sus llaves foráneas de manera detallada.

Atrévete a implementar esta configuración en tus proyectos, experimentando con las poderosas funcionalidades que te ofrece TypeORM para manejar relaciones complejas en tus bases de datos. ¡Sigue explorando y aprendiendo nuevas herramientas para llevar tus habilidades de desarrollo al siguiente nivel!

Guillermo Rodas Gómez

student•

Buenas, si no quieren colocar a cada entity los campos createAt y updateAt pueden crear una entidad básica que contenga estos atributos:

import { CreateDateColumn, UpdateDateColumn } from 'typeorm';

export class BasicEntity {
  @CreateDateColumn({
    type: 'timestamptz',
    default: () => 'CURRENT_TIMESTAMP',
  })
  createAt: Date;

  @UpdateDateColumn({
    type: 'timestamptz',
    default: () => 'CURRENT_TIMESTAMP',
  })
  updateAt: Date;
}

Y luego extender cada entidad que necesite estos campos:

import { BasicEntity } from 'src/database/base.entity';
import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class User extends BasicEntity {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ type: 'varchar', length: 255 })
  email: string;

  @Column({ type: 'varchar', length: 255 })
  password: string;

  @Column({ type: 'varchar', length: 100 })
  role: string;
}

De esta forma nos ahorramos un poco de tiempo al crear nuestras entidades

Walter Lensinas

student•

Podria ser una interfaz? porque si es una clase y justo tener que extender de otra clase, no se si typescript tiene herencia multiple.

Guillermo Rodas Gómez

student•

Al ser interfaz, no podrás colocar decoradores a las propiedades de la interfaz, y los atributos createAt y updateAt igualmente tendran que estar en la clase que implementa la interfaz

Hugo Roca

student•

Vi un comentario que como haría para evitar estar repitiendo los campos de CreateAt y UpdateAt sin usar un herencia de clase, investigando un poco me tope con Embedded Entities. Dejo mi ejemplo el cual me funcionó.

Creé un archivo el cual la puse dentro de database.module: "dateAt.entity.ts"

import { CreateDateColumn, UpdateDateColumn } from 'typeorm';

export class DateAt {
  @CreateDateColumn({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
  createAt: Date;

  @UpdateDateColumn({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
  updateAt: Date;
}

En las entidades solo importe este archivo y dentro de column realize una arrow function hacia esta nueva clase.

import { PrimaryGeneratedColumn, Column, Entity } from 'typeorm';
import { DateAt } from '../../database/dateAt.entity';

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

  @Column({ type: 'varchar', length: 100 })
  name: string;

  @Column({ type: 'varchar', length: 100 })
  lastName: string;

  @Column({ type: 'varchar', length: 20 })
  phone: string;

  @Column(() => DateAt)
  register: DateAt;
}

Me funcionó, incluso corrí el comando npm run migrations:generate -- dateAt, el cual no me dio problema alguno.

Ángel David Roque Ayala

student•

Apuntes

Para realizar relaciones 1 a 1 debemos hacer lo siguiente

// src/user/entities/user.entity
@OneToOne(()=>Customer, (customer)=>customer.user, {nullable: true})
@JoinColumn()
customer: Customer;

// src/user/entities/customer.entity
@OneToOne(()=>User, (user)=> user.customer)
user:User;

La entidad que tenga el decorador @JoinColumn es el objeto que creara la llave foranea. Solo una entidad puede tener el decorador @JoinColumn

TypeORM permite tener una relacion bidireccional en las relaciones 1 a 1 sin necesidad de hacer queryes extras.

Ángel David Roque Ayala

student•

Lo que hicimos

//src/user/entities/customer.entity
import { Column, CreateDateColumn, Entity, OneToOne, PrimaryGeneratedColumn, UpdateDateColumn } from "typeorm";
import { User } from "./user.entity";

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

  @Column({type: 'varchar', length: 255})
  name: string;

  @Column({type: 'varchar', length: 255})
  lastName: string;

  @Column({ type: 'varchar', length: 255 })
  phone: string;

  @CreateDateColumn({
    type: 'timestamptz',
    default: () => 'CURRENT_TIMESTAMP',
  })
  createAt: Date;

  @UpdateDateColumn({
    type: 'timestamptz',
    default: () => 'CURRENT_TIMESTAMP',
  })
  updateAt: Date;

  @OneToOne(()=>User, (user)=> user.customer)
  user:User;
}

//src/user/entities/user.entity
import { Column, CreateDateColumn, Entity, JoinColumn, OneToOne, PrimaryGeneratedColumn, UpdateDateColumn } from "typeorm";
import { Customer } from "./customer.entity";

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

  @Column({ type: 'varchar', length: 255})
  email: string;
  
  @Column({ type: 'varchar', length: 255})
  password: string;

  @Column({ type: 'varchar', length: 255})
  role: string;

  @CreateDateColumn({
    type: 'timestamptz',
    default: () => 'CURRENT_TIMESTAMP'
  })
  createAt: Date;

  @UpdateDateColumn({
    type: 'timestamptz',
    default: () => 'CURRENT_TIMESTAMP',
  })
  updateAt: Date;

  @OneToOne(()=>Customer, (customer)=>customer.user, {nullable: true})
  @JoinColumn()
  customer: Customer;

}

//src/user/services/customer.service
import { Injectable, NotFoundException } from '@nestjs/common';

import { Customer } from '../entities/customer.entity';
import { CreateCustomerDto, UpdateCustomerDto } from '../dtos/customer.dto';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';

@Injectable()
export class CustomersService {
  constructor(
    @InjectRepository(Customer) private customerRepo: Repository<Customer>
  ){}

  async findAll() {
    return await this.customerRepo.find()
  }

  async findOne(id: number) {
    const customer = await this.customerRepo.findOne(id);
    if (!customer) {
      throw new NotFoundException(`Customer #${id} not found`);
    }
    return customer;
  }

  create(data: CreateCustomerDto) {
    const newCostumer = this.customerRepo.create(data);
    return this.customerRepo.save(newCostumer);
  }

  async update(id: number, changes: UpdateCustomerDto) {
    const customer = await this.findOne(id);
    this.customerRepo.merge(customer, changes);
    return this.customerRepo.save(customer);
  }

  remove(id: number) {
    return this.customerRepo.delete(id);
  }
}

//src/user/services/user.service
import { Injectable, NotFoundException, Inject } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';

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

import { ProductsService } from './../../products/services/products.service';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';

@Injectable()
export class UsersService {
  constructor(
    @InjectRepository(User) private userRepo: Repository<User>,
    private productsService: ProductsService,
    private configService: ConfigService,
  ) {}

  async findAll() {
    return await this.userRepo.find();
  }

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

  async create(data: CreateUserDto) {
    const newUser = this.userRepo.create(data);
    return await this.userRepo.save(newUser);
  }

  async update(id: number, changes: UpdateUserDto) {
    const user = await this.findOne(id);
    const updateUser = this.userRepo.merge(user, changes);
    return this.userRepo.save(updateUser);
  }

  remove(id: number) {
    return this.userRepo.delete(id);
  }

  async getOrderByUser(id: number): Promise<Order> {
    const user = await this.userRepo.findOne(id);
    return {
      date: new Date(),
      user,
      products: await this.productsService.findAll(),
    };
  }
}

npm run migrations:generate -- create-user-customer
npm run migrations:run

Hanier Morales

student•

Profe, tengo una consulta que me ha surgido en un proyecto a nivel personal. Estoy trabajando el backend con NestJS y el frontend con VueJS.

Estoy tratando de almacenar el valor de la columna id como tipo BigSerial.

Mi entidad se ve así:

@PrimaryGeneratedColumn('increment', { type: 'bigint' })
  id: number;

Mi dto así:

@IsNumber()
  @IsOptional()
  @ApiProperty()
  readonly id: number;

A la hora de guardar el registro en una vista en VueJS, puedo sin ningún problema crear y eliminar registros. El inconveniente está cuando deseo editar uno de ellos. Sucede que si edito un registro, siempre queda el anterior registro y se crea un nuevo registro con los datos que intenté modificar.

Hanier Morales

student•

Hola 🙂

Al final la solución se implementó de la siguiente manera. En mi entidad:

@PrimaryGeneratedColumn('increment', { type: 'bigint' })
  id: string;

y en mi DTO:

@IsOptional()
  @ApiProperty()
  readonly id: string;

el tipo de dato BigSerial para TypeORM es un String.

Andrés Esteban Rodríguez Jiménez

student•

Relaciones uno a uno

Para manejar las relaciones debemos especificarlo directamente desde nuestras entidades, para entender como manejar las relaciones uno a uno vamos a tomar como caso a user.entity.ts y a customer.entity.ts, vamos a lograr que los usuarios tengan como parámetro opcional un customer.

**src/user/entities/user.entity**:

import {
  // ...
  OneToOne,
  JoinColumn,
} from 'typeorm';

// importamos la entidad a la cual queremos relacionarnos
import { Customer } from './customer.entity';

@Entity()
export class User {
  // ...

  // manejamos la referencia la entidad con OneToOne
  // especificamos con una función flecha que resuelva la entidad que le indiquemos
  // el customer es opcional "{ nullable: true }"
  @OneToOne(() => Customer, { nullable: true })
  // este decorador crea la referencia con una llave foranea
  @JoinColumn()
  costomer: Customer;
}

Relaciones bidireccionales

TypeORM nos la la posibilidad de trabajar las relaciones de forma bidireccional. Lo que significa que le podemos comunicar también al customer que el esta relacionado con un usuario:

**src/user/entities/customer.entity**:

import {
  // ...
  OneToOne,
} from 'typeorm';

// importamos al usuario
import { User } from './user.entity';

@Entity()
export class Customer {
  // ...

  // especificamos que resuleva la relación con el usuario
  // especificamos cual es el campo que referencia la relación, esto para tener comunicación bidireccional
  @OneToOne(() => User, (user) => user.customer, { nullable: true })
  user: User;
}

Ahora en el usuario, debemos indicar que esperamos recibir la comunicación con customer:

**src/user/entities/user.entity**:

import {
  Column,
  Entity,
  UpdateDateColumn,
  CreateDateColumn,
  PrimaryColumn,
  OneToOne,
  JoinColumn,
} from 'typeorm';

// importamos la entidad a la cual queremos relacionarnos
import { Customer } from './customer.entity';

@Entity()
export class User {
  // ...

  // con una función flecha le indicamos que esperamos una relación bidireccional con customer
  // le indicamos cual es el campo de customer que resuelve la relaión
	@OneToOne(
		() => Customer, 
		(customer) => customer.user, // <--
		{ nullable: true }
	)
  // este decorador crea la referencia con una llave foranea
  @JoinColumn()
  customer: Customer;
}

Es importante tener en cuenta que al establecer una relación bidireccional entre dos entidades en TypeORM, solo debemos especificar la referencia en una de las dos entidades. Esto significa que, si queremos establecer una relación bidireccional, solo una de las entidades tendrá el decorador @JoinColumn(), el cual será responsable de definir la clave foránea. En este caso, la entidad que contiene la referencia es la entidad "User".

Ahora solo debemos correr una migración y con eso crearemos nuestra primera relación uno a uno.

Jeison Vargas

student•

Comandos para acceder a la base de datos desde docker en la terminal:

$ docker-compose exec postgres bash
$ psql -h localhost -d my_db -U root
$ \d+
$ \d+ user
$ \d+ customer

Para salir deben ejecutar exit 2 veces.

Renato Renzo Luna Herrera

student•

Por que usar @PrimaryColumn() en vez de @PrimaryGeneratedColumn()??

Nicolas Mendoza

student•

El @PrimaryGeneratedColumn() genera el id automaticamente

Sergio Ivan Morales Serrano

student•

Hola. Alguien sabe por qué me da este error cuando genero la migracion?

TypeORMError: Entity metadata for Customer#user was not found. Check if you specified a correct entity object and if it's connected in the connection options.

Si quito la relación todo bien.

Gracias

Kuro Atlantia Search

student•

¿Y los constraints?

Alvaro Legarda

student•

jajajaj los momentos de los ajustes a 4x son los mejores

José Mauricio Lemús Rodezno

student•

Podemos configurar ONDELETE y ONUPDATE en nuestras entidades de la siguiente manera:

  @OneToOne(() => Customer, (customer) => customer.user, {
    nullable: true,
    onDelete: 'SET NULL',
    onUpdate: 'CASCADE',
  })
  @JoinColumn()
  customer: Customer;

Rodrigo Alejandro Rios

student•

Recomiendo hacer una entidad base con id, updateAd y createAd. Para que luego extender todas las demas entidades de esta base. Ej:

import {
  CreateDateColumn,
  PrimaryGeneratedColumn,
  UpdateDateColumn,
} from 'typeorm';

export abstract class BaseEntity {
  @PrimaryGeneratedColumn('uuid')
  id: string;

  @CreateDateColumn({
    type: 'timestamp',
    name: 'created_at',
  })
  createdAt: Date;

  @UpdateDateColumn({
    type: 'timestamp',
    name: 'updated_at',
  })
  updatedAt: Date;
}