Modificando el naming

Apuntes de la clase

Naming o Nombramiento de variables en BD

• El naming es una buena practica.

• Nombre de una variable tiene que ser representativa

• Tiene que ser escrita en camelCase para JavaScript

• En BD una buena práctica es no tener caracteres especiales como la mayúscula.

  • Debido que si se hace consultas directa a la BD habría que escapar caracteres especiales.

• En BD debe ser separadas con _. (snake_case)

• Nombre de la tabla debe ser en plural.

  //products/entities/product.entity.ts
  
  @Entity({ name: 'products'}) // Nombre de la tabla
  @Index(['price', 'stock'])
  export class Product{
  	
  	....
  
  	@CreateDateColumn({
  		name: 'created_at', // nombre de la columna en la BD
  		type: 'timestamptz',
  		default: () => 'CURRENT_TIMESTAMP',
  	})
  	createdAt: Date;  // Nombre de la variable en el codigo
  
  	@UpdateDateColumn({
      name: 'update_at',
      type: 'timestamptz',
      default: () => 'CURRENT_TIMESTAMP',
    })
    updateAt: Date;
  	
  	...
  }
  

• En los casos de relaciones OneToOne se hace la modificación en la tabla que tenga el decorator @JoinColumn.

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

• En una relación ManyToOne se hace la modificación en quien lleve este decorator.

  • Se agrega el decorator @JoinColumn

  //products/entities/product.entity.ts
  
  @ManyToOne(() => Brand, (brand) => brand.products)
    @JoinColumn({ name: 'brand_id' })
    brand: Brand;
  

• En las tablas muchos a muchos que es manejada por TypeORM se modifica en la entidad que tenga el decorator @JoinTable

  • Recuerda que en este caso se crea una tabla ternaria.

  //products/entities/product.entity.ts
  
  @ManyToMany(() => Category, (category) => category.products)
    @JoinTable({
      name: 'products_categories', //nombre de la tabla que tambien puede ser products_has_categories
      joinColumn: {
        name: 'product_id', // Relación con la entidad donde estas situado.
      },
      inverseJoinColumn: {
        name: 'category_id', // Relación con la otra entidad.
      },
    })
    categories: Category[];
  

• Correr migraciones.

  • Debes ser precavido los nombres deben ser ideado desde el diseño.
  • Cuando se cambia el nombre de una tabla, crea una nueva tabla no migra los datos.
  • Se puede perder datos. Evitar usarlo luego que la BD este en producción.
  • Cuando eliminas toda la BD para volverla crear, sin estar en producción, tienes la opción de eliminar las migraciones anteriores, y crear una nueva como estructura inicial.
  • En caso de vaciar y volver a crear las tablas en la BD ejecuta

  npm run migrations:drop
  npm run migrations:generate -- init
  npm run migrations:run
  

Un tip para no tener que hacer drop: Si ejecutan typeorm migration:create -n <nombre-del-refactor>, TypeORM les generará una plantilla de archivo de migración en blanco donde podrían agregar sus Querys ‘a mano’ como este:

import {MigrationInterface, QueryRunner} from "typeorm";

export class PostRefactoringTIMESTAMP implements MigrationInterface {

    async up(queryRunner: QueryRunner): Promise<void> {
    }

    async down(queryRunner: QueryRunner): Promise<void> {
    }
}

Dentro del método up colocan los querys necesarios para hacer los cambios y dentro de down los querys para revertir los cambios en caso de que sea necesario. Por ejemplo:

import {MigrationInterface, QueryRunner} from "typeorm";

export class PostRefactoringTIMESTAMP implements MigrationInterface {

    async up(queryRunner: QueryRunner): Promise<void> {
        await queryRunner.query(`ALTER TABLE "post" RENAME COLUMN "title" TO "name"`);
    }

    async down(queryRunner: QueryRunner): Promise<void> {
        await queryRunner.query(`ALTER TABLE "post" RENAME COLUMN "name" TO "title"`); // reverts things made in "up" method
    }
}

creo que el nombre correcto es: created_at y updated_at

En TypeORM pueden definir una estrategia para el naming implementando la interfaz NamingStrategyInterface o bien, instalando esta librería que ya lo implementa:
https://github.com/tonivj5/typeorm-naming-strategies

Esta clase es muy importante, siempre tener en cuenta las buenas prácticas y el buen naming de los campos en la DB.

shait, este tema debimos verlo al inicio del curso, incluso cuando estábamos aprendiendo fundamentos de NestJs. -.-

Name of product.entity.ts

 @ManyToOne(() => Brand, (brand) => brand.products, { nullable: true })
  @JoinColumn({ name: 'brand_id' })
  brand: Brand

  @ManyToMany(() => Category, (categories) => categories.products, { nullable: true })

  @JoinTable({
    name: "product_categories",
    joinColumn: {
      name: "pk_product",
      referencedColumnName: "id"
    },
    inverseJoinColumn: {
      name: "pk_category",
      referencedColumnName: "id"
    }
  })
  categories: Category[];