@javalabs/prisma-client 1.0.16 → 1.0.19

package/src/scripts/sequence-synchronizer.ts

@@ -1,127 +1,127 @@
-import { Logger } from "@nestjs/common";
-import { Pool } from "pg";
-
-export class SequenceSynchronizer {
-  private readonly logger = new Logger("SequenceSynchronizer");
-  private readonly pool: Pool;
-
-  constructor(databaseUrl: string) {
-    this.pool = new Pool({
-      connectionString: databaseUrl,
-    });
-  }
-
-  async synchronizeSequences(): Promise<void> {
-    try {
-      this.logger.log("Iniciando sincronización de secuencias");
-
-      // Obtener todas las tablas en la base de datos
-      const tables = await this.getTables();
-      this.logger.log(`Encontradas ${tables.length} tablas para procesar`);
-
-      // Procesar cada tabla
-      for (const table of tables) {
-        await this.synchronizeTableSequences(table);
-      }
-
-      this.logger.log("Sincronización de secuencias completada con éxito");
-    } catch (error) {
-      this.logger.error(
-        `Error durante la sincronización de secuencias: ${error.message}`,
-        error.stack
-      );
-      throw error;
-    } finally {
-      await this.pool.end();
-    }
-  }
-
-  private async getTables(): Promise<string[]> {
-    const query = `
-      SELECT table_name 
-      FROM information_schema.tables 
-      WHERE table_schema = 'public' 
-      AND table_type = 'BASE TABLE'
-    `;
-
-    const result = await this.pool.query(query);
-    return result.rows.map((row) => row.table_name);
-  }
-
-  private async synchronizeTableSequences(tableName: string): Promise<void> {
-    try {
-      // Verificar si la tabla tiene una columna id
-      const columns = await this.pool.query(
-        `
-        SELECT column_name 
-        FROM information_schema.columns 
-        WHERE table_name = $1 
-        AND column_name = 'id'
-      `,
-        [tableName]
-      );
-
-      if (columns.rows.length === 0) {
-        this.logger.debug(
-          `La tabla ${tableName} no tiene columna id, omitiendo`
-        );
-        return;
-      }
-
-      // Verificar si existe una secuencia para esta tabla
-      const sequenceName = `${tableName}_id_seq`;
-      const sequences = await this.pool.query(
-        `
-        SELECT sequence_name 
-        FROM information_schema.sequences 
-        WHERE sequence_name = $1
-      `,
-        [sequenceName]
-      );
-
-      if (sequences.rows.length === 0) {
-        this.logger.debug(
-          `No se encontró secuencia para la tabla ${tableName}, omitiendo`
-        );
-        return;
-      }
-
-      // Obtener el máximo ID actual de la tabla
-      const maxResult = await this.pool.query(`
-        SELECT COALESCE(MAX(id), 0) as max_id FROM "${tableName}"
-      `);
-      const maxId = maxResult.rows[0].max_id;
-
-      // Obtener el valor actual de la secuencia
-      const currValResult = await this.pool.query(`
-        SELECT last_value FROM "${sequenceName}"
-      `);
-      const currVal = currValResult.rows[0].last_value;
-
-      this.logger.log(
-        `Tabla ${tableName}: ID Máximo = ${maxId}, Valor Actual de Secuencia = ${currVal}`
-      );
-
-      // Actualizar la secuencia solo si es necesario
-      if (currVal <= maxId) {
-        await this.pool.query(
-          `
-          SELECT setval($1, $2, true)
-        `,
-          [sequenceName, maxId]
-        );
-        this.logger.log(
-          `Actualizada secuencia para tabla ${tableName} a ${maxId}`
-        );
-      } else {
-        this.logger.log(
-          `La secuencia para la tabla ${tableName} ya está adelantada al ID máximo, no se requiere actualización`
-        );
-      }
-    } catch (error) {
-      this.logger.error(
-        `Error sincronizando secuencias para tabla ${tableName}: ${error.message}`
-      );
-    }
-  }
-}
+import { Logger } from "@nestjs/common";
+import { Pool } from "pg";
+
+export class SequenceSynchronizer {
+  private readonly logger = new Logger("SequenceSynchronizer");
+  private readonly pool: Pool;
+
+  constructor(databaseUrl: string) {
+    this.pool = new Pool({
+      connectionString: databaseUrl,
+    });
+  }
+
+  async synchronizeSequences(): Promise<void> {
+    try {
+      this.logger.log("Iniciando sincronización de secuencias");
+
+      // Obtener todas las tablas en la base de datos
+      const tables = await this.getTables();
+      this.logger.log(`Encontradas ${tables.length} tablas para procesar`);
+
+      // Procesar cada tabla
+      for (const table of tables) {
+        await this.synchronizeTableSequences(table);
+      }
+
+      this.logger.log("Sincronización de secuencias completada con éxito");
+    } catch (error) {
+      this.logger.error(
+        `Error durante la sincronización de secuencias: ${error.message}`,
+        error.stack
+      );
+      throw error;
+    } finally {
+      await this.pool.end();
+    }
+  }
+
+  private async getTables(): Promise<string[]> {
+    const query = `
+      SELECT table_name 
+      FROM information_schema.tables 
+      WHERE table_schema = 'public' 
+      AND table_type = 'BASE TABLE'
+    `;
+
+    const result = await this.pool.query(query);
+    return result.rows.map((row) => row.table_name);
+  }
+
+  private async synchronizeTableSequences(tableName: string): Promise<void> {
+    try {
+      // Verificar si la tabla tiene una columna id
+      const columns = await this.pool.query(
+        `
+        SELECT column_name 
+        FROM information_schema.columns 
+        WHERE table_name = $1 
+        AND column_name = 'id'
+      `,
+        [tableName]
+      );
+
+      if (columns.rows.length === 0) {
+        this.logger.debug(
+          `La tabla ${tableName} no tiene columna id, omitiendo`
+        );
+        return;
+      }
+
+      // Verificar si existe una secuencia para esta tabla
+      const sequenceName = `${tableName}_id_seq`;
+      const sequences = await this.pool.query(
+        `
+        SELECT sequence_name 
+        FROM information_schema.sequences 
+        WHERE sequence_name = $1
+      `,
+        [sequenceName]
+      );
+
+      if (sequences.rows.length === 0) {
+        this.logger.debug(
+          `No se encontró secuencia para la tabla ${tableName}, omitiendo`
+        );
+        return;
+      }
+
+      // Obtener el máximo ID actual de la tabla
+      const maxResult = await this.pool.query(`
+        SELECT COALESCE(MAX(id), 0) as max_id FROM "${tableName}"
+      `);
+      const maxId = maxResult.rows[0].max_id;
+
+      // Obtener el valor actual de la secuencia
+      const currValResult = await this.pool.query(`
+        SELECT last_value FROM "${sequenceName}"
+      `);
+      const currVal = currValResult.rows[0].last_value;
+
+      this.logger.log(
+        `Tabla ${tableName}: ID Máximo = ${maxId}, Valor Actual de Secuencia = ${currVal}`
+      );
+
+      // Actualizar la secuencia solo si es necesario
+      if (currVal <= maxId) {
+        await this.pool.query(
+          `
+          SELECT setval($1, $2, true)
+        `,
+          [sequenceName, maxId]
+        );
+        this.logger.log(
+          `Actualizada secuencia para tabla ${tableName} a ${maxId}`
+        );
+      } else {
+        this.logger.log(
+          `La secuencia para la tabla ${tableName} ya está adelantada al ID máximo, no se requiere actualización`
+        );
+      }
+    } catch (error) {
+      this.logger.error(
+        `Error sincronizando secuencias para tabla ${tableName}: ${error.message}`
+      );
+    }
+  }
+}

package/src/scripts/sync-enum-types.ts

@@ -1,171 +1,171 @@
-import * as pg from 'pg';
-import * as dotenv from 'dotenv';
-import { Logger } from '@nestjs/common';
-
-dotenv.config();
-
-export class EnumSynchronizer {
-  private readonly logger = new Logger('EnumSynchronizer');
-  private readonly sourcePool: pg.Pool;
-  private readonly targetPool: pg.Pool;
-
-  constructor(
-    private readonly sourceUrl: string = process.env.SOURCE_DATABASE_URL,
-    private readonly targetUrl: string = process.env.DATABASE_URL
-  ) {
-    this.sourcePool = new pg.Pool({
-      connectionString: this.sourceUrl,
-    });
-
-    this.targetPool = new pg.Pool({
-      connectionString: this.targetUrl,
-    });
-  }
-
-  async synchronizeEnums() {
-    try {
-      this.logger.log('Starting enum synchronization');
-
-      // Obtener todos los tipos enum en la base de datos de origen
-      const sourceEnumsResult = await this.sourcePool.query(`
-        SELECT t.typname AS enum_name
-        FROM pg_type t
-        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-        WHERE t.typtype = 'e'
-        AND n.nspname = 'public'
-      `);
-
-      this.logger.log(`Found ${sourceEnumsResult.rows.length} enum types in source database`);
-
-      // Para cada tipo enum, sincronizar sus valores
-      for (const enumRow of sourceEnumsResult.rows) {
-        const enumName = enumRow.enum_name;
-        await this.synchronizeEnumType(enumName);
-      }
-
-      this.logger.log('Enum synchronization completed successfully');
-    } catch (error) {
-      this.logger.error(`Error during enum synchronization: ${error.message}`, error.stack);
-    } finally {
-      await this.cleanup();
-    }
-  }
-
-  private async synchronizeEnumType(enumName: string) {
-    this.logger.log(`Synchronizing enum type: ${enumName}`);
-
-    try {
-      // Obtener valores del enum en la base de datos de origen
-      const sourceEnumValuesResult = await this.sourcePool.query(`
-        SELECT e.enumlabel
-        FROM pg_enum e
-        JOIN pg_type t ON e.enumtypid = t.oid
-        WHERE t.typname = $1
-        ORDER BY e.enumsortorder
-      `, [enumName]);
-
-      const sourceEnumValues = sourceEnumValuesResult.rows.map(row => row.enumlabel);
-      this.logger.log(`Source enum ${enumName} has values: ${sourceEnumValues.join(', ')}`);
-
-      // Verificar si el enum existe en la base de datos de destino
-      const targetEnumExistsResult = await this.targetPool.query(`
-        SELECT 1
-        FROM pg_type t
-        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-        WHERE t.typtype = 'e'
-        AND t.typname = $1
-        AND n.nspname = 'public'
-        LIMIT 1
-      `, [enumName]);
-
-      if (targetEnumExistsResult.rows.length === 0) {
-        // Si el enum no existe en el destino, crearlo
-        await this.createEnumType(enumName, sourceEnumValues);
-      } else {
-        // Si el enum existe, actualizar sus valores
-        await this.updateEnumValues(enumName, sourceEnumValues);
-      }
-    } catch (error) {
-      this.logger.error(`Error synchronizing enum type ${enumName}: ${error.message}`);
-    }
-  }
-
-  private async createEnumType(enumName: string, values: string[]) {
-    this.logger.log(`Creating enum type ${enumName} in target database`);
-
-    try {
-      // Escapar los valores para la consulta SQL
-      const escapedValues = values.map(value => `'${value.replace(/'/g, "''")}'`).join(', ');
-
-      // Crear el tipo enum
-      await this.targetPool.query(`
-        CREATE TYPE ${enumName} AS ENUM (${escapedValues})
-      `);
-
-      this.logger.log(`Successfully created enum type ${enumName} with values: ${values.join(', ')}`);
-    } catch (error) {
-      this.logger.error(`Error creating enum type ${enumName}: ${error.message}`);
-    }
-  }
-
-  private async updateEnumValues(enumName: string, sourceValues: string[]) {
-    this.logger.log(`Updating enum type ${enumName} in target database`);
-
-    try {
-      // Obtener valores actuales del enum en la base de datos de destino
-      const targetEnumValuesResult = await this.targetPool.query(`
-        SELECT e.enumlabel
-        FROM pg_enum e
-        JOIN pg_type t ON e.enumtypid = t.oid
-        WHERE t.typname = $1
-        ORDER BY e.enumsortorder
-      `, [enumName]);
-
-      const targetEnumValues = targetEnumValuesResult.rows.map(row => row.enumlabel);
-      this.logger.log(`Target enum ${enumName} has values: ${targetEnumValues.join(', ')}`);
-
-      // Encontrar valores que están en el origen pero no en el destino
-      const missingValues = sourceValues.filter(value => !targetEnumValues.includes(value));
-
-      if (missingValues.length === 0) {
-        this.logger.log(`Enum type ${enumName} is already up to date`);
-        return;
-      }
-
-      this.logger.log(`Adding ${missingValues.length} new values to enum ${enumName}: ${missingValues.join(', ')}`);
-
-      // Agregar los valores faltantes al enum
-      for (const value of missingValues) {
-        await this.targetPool.query(`
-          ALTER TYPE ${enumName} ADD VALUE '${value.replace(/'/g, "''")}'
-        `);
-      }
-
-      this.logger.log(`Successfully updated enum type ${enumName}`);
-    } catch (error) {
-      this.logger.error(`Error updating enum type ${enumName}: ${error.message}`);
-    }
-  }
-
-  private async cleanup() {
-    this.logger.log('Cleaning up database connections');
-    await this.sourcePool.end();
-    await this.targetPool.end();
-  }
-}
-
-// Script para ejecutar desde línea de comandos
-if (require.main === module) {
-  const run = async () => {
-    try {
-      const synchronizer = new EnumSynchronizer();
-      await synchronizer.synchronizeEnums();
-      process.exit(0);
-    } catch (error) {
-      console.error('Error:', error.message);
-      process.exit(1);
-    }
-  };
-
-  run();
+import * as pg from 'pg';
+import * as dotenv from 'dotenv';
+import { Logger } from '@nestjs/common';
+
+dotenv.config();
+
+export class EnumSynchronizer {
+  private readonly logger = new Logger('EnumSynchronizer');
+  private readonly sourcePool: pg.Pool;
+  private readonly targetPool: pg.Pool;
+
+  constructor(
+    private readonly sourceUrl: string = process.env.SOURCE_DATABASE_URL,
+    private readonly targetUrl: string = process.env.DATABASE_URL
+  ) {
+    this.sourcePool = new pg.Pool({
+      connectionString: this.sourceUrl,
+    });
+
+    this.targetPool = new pg.Pool({
+      connectionString: this.targetUrl,
+    });
+  }
+
+  async synchronizeEnums() {
+    try {
+      this.logger.log('Starting enum synchronization');
+
+      // Obtener todos los tipos enum en la base de datos de origen
+      const sourceEnumsResult = await this.sourcePool.query(`
+        SELECT t.typname AS enum_name
+        FROM pg_type t
+        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+        WHERE t.typtype = 'e'
+        AND n.nspname = 'public'
+      `);
+
+      this.logger.log(`Found ${sourceEnumsResult.rows.length} enum types in source database`);
+
+      // Para cada tipo enum, sincronizar sus valores
+      for (const enumRow of sourceEnumsResult.rows) {
+        const enumName = enumRow.enum_name;
+        await this.synchronizeEnumType(enumName);
+      }
+
+      this.logger.log('Enum synchronization completed successfully');
+    } catch (error) {
+      this.logger.error(`Error during enum synchronization: ${error.message}`, error.stack);
+    } finally {
+      await this.cleanup();
+    }
+  }
+
+  private async synchronizeEnumType(enumName: string) {
+    this.logger.log(`Synchronizing enum type: ${enumName}`);
+
+    try {
+      // Obtener valores del enum en la base de datos de origen
+      const sourceEnumValuesResult = await this.sourcePool.query(`
+        SELECT e.enumlabel
+        FROM pg_enum e
+        JOIN pg_type t ON e.enumtypid = t.oid
+        WHERE t.typname = $1
+        ORDER BY e.enumsortorder
+      `, [enumName]);
+
+      const sourceEnumValues = sourceEnumValuesResult.rows.map(row => row.enumlabel);
+      this.logger.log(`Source enum ${enumName} has values: ${sourceEnumValues.join(', ')}`);
+
+      // Verificar si el enum existe en la base de datos de destino
+      const targetEnumExistsResult = await this.targetPool.query(`
+        SELECT 1
+        FROM pg_type t
+        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+        WHERE t.typtype = 'e'
+        AND t.typname = $1
+        AND n.nspname = 'public'
+        LIMIT 1
+      `, [enumName]);
+
+      if (targetEnumExistsResult.rows.length === 0) {
+        // Si el enum no existe en el destino, crearlo
+        await this.createEnumType(enumName, sourceEnumValues);
+      } else {
+        // Si el enum existe, actualizar sus valores
+        await this.updateEnumValues(enumName, sourceEnumValues);
+      }
+    } catch (error) {
+      this.logger.error(`Error synchronizing enum type ${enumName}: ${error.message}`);
+    }
+  }
+
+  private async createEnumType(enumName: string, values: string[]) {
+    this.logger.log(`Creating enum type ${enumName} in target database`);
+
+    try {
+      // Escapar los valores para la consulta SQL
+      const escapedValues = values.map(value => `'${value.replace(/'/g, "''")}'`).join(', ');
+
+      // Crear el tipo enum
+      await this.targetPool.query(`
+        CREATE TYPE ${enumName} AS ENUM (${escapedValues})
+      `);
+
+      this.logger.log(`Successfully created enum type ${enumName} with values: ${values.join(', ')}`);
+    } catch (error) {
+      this.logger.error(`Error creating enum type ${enumName}: ${error.message}`);
+    }
+  }
+
+  private async updateEnumValues(enumName: string, sourceValues: string[]) {
+    this.logger.log(`Updating enum type ${enumName} in target database`);
+
+    try {
+      // Obtener valores actuales del enum en la base de datos de destino
+      const targetEnumValuesResult = await this.targetPool.query(`
+        SELECT e.enumlabel
+        FROM pg_enum e
+        JOIN pg_type t ON e.enumtypid = t.oid
+        WHERE t.typname = $1
+        ORDER BY e.enumsortorder
+      `, [enumName]);
+
+      const targetEnumValues = targetEnumValuesResult.rows.map(row => row.enumlabel);
+      this.logger.log(`Target enum ${enumName} has values: ${targetEnumValues.join(', ')}`);
+
+      // Encontrar valores que están en el origen pero no en el destino
+      const missingValues = sourceValues.filter(value => !targetEnumValues.includes(value));
+
+      if (missingValues.length === 0) {
+        this.logger.log(`Enum type ${enumName} is already up to date`);
+        return;
+      }
+
+      this.logger.log(`Adding ${missingValues.length} new values to enum ${enumName}: ${missingValues.join(', ')}`);
+
+      // Agregar los valores faltantes al enum
+      for (const value of missingValues) {
+        await this.targetPool.query(`
+          ALTER TYPE ${enumName} ADD VALUE '${value.replace(/'/g, "''")}'
+        `);
+      }
+
+      this.logger.log(`Successfully updated enum type ${enumName}`);
+    } catch (error) {
+      this.logger.error(`Error updating enum type ${enumName}: ${error.message}`);
+    }
+  }
+
+  private async cleanup() {
+    this.logger.log('Cleaning up database connections');
+    await this.sourcePool.end();
+    await this.targetPool.end();
+  }
+}
+
+// Script para ejecutar desde línea de comandos
+if (require.main === module) {
+  const run = async () => {
+    try {
+      const synchronizer = new EnumSynchronizer();
+      await synchronizer.synchronizeEnums();
+      process.exit(0);
+    } catch (error) {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  };
+
+  run();
 }