Generación

Traducción Beta No Oficial

Esta página fue traducida por PageTurner AI (beta). No está respaldada oficialmente por el proyecto. ¿Encontraste un error? Reportar problema →

TypeORM puede generar automáticamente archivos de migración basándose en los cambios que realices en las entidades, comparándolos con el esquema de base de datos existente en el servidor.

La generación automática de migraciones crea un nuevo archivo de migración y escribe todas las consultas SQL necesarias para actualizar la base de datos. Si no se detectan cambios, el comando finalizará con el código 1.

Imagina que tienes una entidad Post con una columna title, y cambias el nombre title por name.

Puedes generar la migración con este comando:

typeorm migration:generate -d <path/to/datasource> <migration-name>

El valor del argumento -d debe especificar la ruta donde está definida tu instancia de DataSource.

También puedes especificar un nombre con el parámetro --name

typeorm migration:generate -- -d <path/to/datasource> --name=<migration-name>

o usar una ruta completa:

typeorm migration:generate -d <path/to/datasource> <path/to/migrations>/<migration-name>

Suponiendo que usaste post-refactoring como nombre, se generará un archivo llamado {TIMESTAMP}-post-refactoring.ts con este contenido:

import { MigrationInterface, QueryRunner } from "typeorm"

export class PostRefactoringTIMESTAMP implements MigrationInterface {
    async up(queryRunner: QueryRunner): Promise<void> {
        await queryRunner.query(
            `ALTER TABLE "post" ALTER COLUMN "title" RENAME TO "name"`,
        )
    }

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

Alternativamente, también puedes generar tus migraciones como archivos JavaScript usando el flag o (alias de --outputJs). Esto es útil para proyectos que solo usan JavaScript y en los que no están instalados los paquetes adicionales de TypeScript. Este comando generará un nuevo archivo de migración {TIMESTAMP}-PostRefactoring.js con el siguiente contenido:

/**
 * @typedef {import('typeorm').MigrationInterface} MigrationInterface
 * @typedef {import('typeorm').QueryRunner} QueryRunner
 */

/**
 * @class
 * @implements {MigrationInterface}
 */
module.exports = class PostRefactoringTIMESTAMP {
    /**
     * @param {QueryRunner} queryRunner
     */
    async up(queryRunner) {
        await queryRunner.query(
            `ALTER TABLE "post" ALTER COLUMN "title" RENAME TO "name"`,
        )
    }

    /**
     * @param {QueryRunner} queryRunner
     */
    async down(queryRunner) {
        await queryRunner.query(
            `ALTER TABLE "post" ALTER COLUMN "name" RENAME TO "title"`,
        )
    }
}

Por defecto, genera código JavaScript CommonJS con la bandera o (alias de --outputJs), pero también puedes generar código ESM con la bandera esm. Esto es útil para proyectos JavaScript que usan ESM:

/**
 * @typedef {import('typeorm').MigrationInterface} MigrationInterface
 * @typedef {import('typeorm').QueryRunner} QueryRunner
 */

/**
 * @class
 * @implements {MigrationInterface}
 */
export class PostRefactoringTIMESTAMP {
    /**
     * @param {QueryRunner} queryRunner
     */
    async up(queryRunner) {
        await queryRunner.query(
            `ALTER TABLE "post" ALTER COLUMN "title" RENAME TO "name"`,
        )
    }

    /**
     * @param {QueryRunner} queryRunner
     */
    async down(queryRunner) {
        await queryRunner.query(
            `ALTER TABLE "post" ALTER COLUMN "name" RENAME TO "title"`,
        )
    }
}

Como ves, no necesitas escribir las consultas manualmente.

La regla básica es generar migraciones después de cada cambio que hagas en tus modelos. Para aplicar formato multilínea a las consultas generadas, usa la bandera p (alias de --pretty).