@javalabs/prisma-client 1.0.0

package/src/scripts/schema-sync.ts

@@ -0,0 +1,129 @@
+import { Logger } from "@nestjs/common";
+import { DatabaseConnector } from "./data-migration/db-connector";
+import * as fs from "fs";
+import * as path from "path";
+
+async function main() {
+  const logger = new Logger("SchemaSyncTool");
+  logger.log("Starting schema synchronization");
+
+  // Crear conexiones a las bases de datos
+  const connections = DatabaseConnector.createConnections();
+
+  try {
+    // Obtener todas las tablas de la base de datos origen
+    const sourceTables = await getTablesFromDatabase(connections.sourcePool);
+    logger.log(`Found ${sourceTables.length} tables in source database`);
+
+    // Obtener todas las tablas de la base de datos destino
+    const targetTables = await getTablesFromDatabase(connections.targetPool);
+    logger.log(`Found ${targetTables.length} tables in target database`);
+
+    // Comparar esquemas y generar SQL para sincronizar
+    const syncScript = await generateSyncScript(
+      connections.sourcePool,
+      connections.targetPool,
+      sourceTables,
+      targetTables
+    );
+
+    // Guardar el script SQL
+    const timestamp = new Date().toISOString().replace(/:/g, "-").split(".")[0];
+    const filePath = path.join(
+      process.cwd(),
+      `schema-sync-${timestamp}.sql`
+    );
+    fs.writeFileSync(filePath, syncScript);
+
+    logger.log(`Schema synchronization script saved to ${filePath}`);
+    logger.log("Review the script and execute it manually to synchronize schemas");
+
+  } catch (error) {
+    logger.error(`Error in schema synchronization: ${error.message}`, error.stack);
+  } finally {
+    // Cerrar conexiones
+    await DatabaseConnector.cleanup(connections);
+  }
+}
+
+async function getTablesFromDatabase(pool: any): Promise<string[]> {
+  const query = `
+    SELECT table_name 
+    FROM information_schema.tables 
+    WHERE table_schema = 'public'
+    AND table_type = 'BASE TABLE'
+  `;
+  
+  const result = await pool.query(query);
+  return result.rows.map(row => row.table_name);
+}
+
+async function generateSyncScript(
+  sourcePool: any,
+  targetPool: any,
+  sourceTables: string[],
+  targetTables: string[]
+): Promise<string> {
+  let script = "-- Schema synchronization script\n\n";
+
+  // Procesar cada tabla de la fuente
+  for (const table of sourceTables) {
+    // Obtener columnas de la tabla fuente
+    const sourceColumns = await getTableColumns(sourcePool, table);
+    
+    if (targetTables.includes(table)) {
+      // La tabla existe en ambas bases de datos, comparar columnas
+      const targetColumns = await getTableColumns(targetPool, table);
+      
+      // Encontrar columnas que faltan en el destino
+      const missingColumns = sourceColumns.filter(
+        sourceCol => !targetColumns.some(targetCol => targetCol.column_name === sourceCol.column_name)
+      );
+      
+      // Generar SQL para agregar columnas faltantes
+      for (const column of missingColumns) {
+        script += `-- Adding missing column ${column.column_name} to table ${table}\n`;
+        script += `ALTER TABLE "${table}" ADD COLUMN "${column.column_name}" ${column.data_type}`;
+        
+        // Agregar restricciones si es necesario
+        if (column.is_nullable === 'NO') {
+          script += " NOT NULL";
+        }
+        
+        script += ";\n\n";
+      }
+    } else {
+      // La tabla no existe en el destino, generar SQL para crearla
+      script += `-- Table ${table} does not exist in target database\n`;
+      script += `-- Consider running a full schema migration instead\n\n`;
+    }
+  }
+
+  return script;
+}
+
+async function getTableColumns(pool: any, table: string): Promise<any[]> {
+  const query = `
+    SELECT 
+      column_name, 
+      data_type, 
+      is_nullable,
+      column_default
+    FROM 
+      information_schema.columns
+    WHERE 
+      table_schema = 'public' 
+      AND table_name = $1
+    ORDER BY 
+      ordinal_position
+  `;
+  
+  const result = await pool.query(query, [table]);
+  return result.rows;
+}
+
+// Ejecutar el script
+main().catch(e => {
+  console.error(e);
+  process.exit(1);
+});

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

@@ -0,0 +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();
+}