A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Modificando el naming

30/33
Recursos

Aportes 7

Preguntas 0

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

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 鈥榓 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[];