@javalabs/prisma-client 1.0.18 → 1.0.20

package/src/scripts/fix-schema-discrepancies.ts

@@ -1,318 +1,318 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as pg from 'pg';
-import { Logger } from '@nestjs/common';
-import * as dotenv from 'dotenv';
-
-dotenv.config();
-
-interface ColumnMismatch {
-  type: string;
-  message: string;
-  severity: string;
-  details: {
-    table: string;
-    column: string;
-    constraint_type: string;
-  };
-}
-
-interface MigrationReport {
-  timestamp: string;
-  sourceDatabase: string;
-  targetDatabase: string;
-  issueCount: number;
-  issues: ColumnMismatch[];
-}
-
-export class SchemaDiscrepancyFixer {
-  private readonly logger = new Logger('SchemaDiscrepancyFixer');
-  private readonly sourcePool: pg.Pool;
-  private readonly targetPool: pg.Pool;
-  private readonly columnTypeCache: Record<string, Record<string, string>> = {};
-
-  constructor(
-    private readonly sourceUrl: string = process.env.SOURCE_DATABASE_URL,
-    private readonly targetUrl: string = process.env.DATABASE_URL,
-    private readonly reportPath?: string
-  ) {
-    if (!this.sourceUrl) {
-      throw new Error('SOURCE_DATABASE_URL environment variable is required');
-    }
-
-    if (!this.targetUrl) {
-      throw new Error('DATABASE_URL environment variable is required');
-    }
-
-    this.sourcePool = new pg.Pool({
-      connectionString: this.sourceUrl,
-    });
-
-    this.targetPool = new pg.Pool({
-      connectionString: this.targetUrl,
-    });
-  }
-
-  async fixDiscrepancies(): Promise<void> {
-    try {
-      // Encontrar el informe de pre-migración más reciente si no se especificó uno
-      const reportFile = this.reportPath || await this.findLatestReport();
-      if (!reportFile) {
-        this.logger.error('No pre-migration report found');
-        return;
-      }
-
-      this.logger.log(`Using pre-migration report: ${reportFile}`);
-      const reportContent = fs.readFileSync(reportFile, 'utf8');
-      const report: MigrationReport = JSON.parse(reportContent);
-
-      // Filtrar solo los problemas de tipo COLUMN_MISMATCH
-      const columnMismatches = report.issues.filter(
-        issue => issue.type === 'COLUMN_MISMATCH'
-      );
-
-      if (columnMismatches.length === 0) {
-        this.logger.log('No column mismatches to fix');
-        return;
-      }
-
-      this.logger.log(`Found ${columnMismatches.length} column mismatches to fix`);
-
-      // Agrupar por tabla para optimizar las consultas
-      const tableGroups = this.groupByTable(columnMismatches);
-
-      // Procesar cada tabla
-      for (const [table, columns] of Object.entries(tableGroups)) {
-        await this.fixTableColumns(table, columns);
-      }
-
-      this.logger.log('Schema discrepancies fixed successfully');
-    } catch (error) {
-      this.logger.error(`Error fixing schema discrepancies: ${error.message}`);
-      throw error;
-    } finally {
-      await this.cleanup();
-    }
-  }
-
-  private async findLatestReport(): Promise<string | null> {
-    const logsDir = path.join(process.cwd(), 'migration-logs');
-    if (!fs.existsSync(logsDir)) {
-      return null;
-    }
-
-    const files = fs.readdirSync(logsDir);
-    const reportFiles = files.filter(file => file.startsWith('pre-migration-report-'));
-    
-    if (reportFiles.length === 0) {
-      return null;
-    }
-
-    // Ordenar por fecha (más reciente primero)
-    reportFiles.sort().reverse();
-    return path.join(logsDir, reportFiles[0]);
-  }
-
-  private groupByTable(mismatches: ColumnMismatch[]): Record<string, ColumnMismatch[]> {
-    return mismatches.reduce((groups, mismatch) => {
-      const table = mismatch.details.table;
-      if (!groups[table]) {
-        groups[table] = [];
-      }
-      groups[table].push(mismatch);
-      return groups;
-    }, {} as Record<string, ColumnMismatch[]>);
-  }
-
-  private async fixTableColumns(table: string, columns: ColumnMismatch[]): Promise<void> {
-    try {
-      this.logger.log(`Fixing columns for table "${table}"`);
-
-      // Obtener los esquemas en la base de datos de destino
-      const schemas = await this.getTargetSchemas();
-      
-      // Obtener los tipos de columna de la base de datos de origen
-      await this.cacheSourceColumnTypes(table, columns.map(c => c.details.column));
-
-      for (const schema of schemas) {
-        this.logger.log(`Processing schema "${schema}" for table "${table}"`);
-        
-        // Verificar si la tabla existe en este esquema
-        const tableExists = await this.checkTableExists(schema, table);
-        if (!tableExists) {
-          this.logger.warn(`Table "${table}" does not exist in schema "${schema}". Skipping.`);
-          continue;
-        }
-
-        // Añadir las columnas faltantes
-        for (const column of columns) {
-          const columnName = column.details.column;
-          const columnType = this.columnTypeCache[table]?.[columnName];
-          
-          if (!columnType) {
-            this.logger.warn(`Could not determine type for column "${columnName}" in table "${table}". Skipping.`);
-            continue;
-          }
-
-          // Verificar si la columna ya existe
-          const columnExists = await this.checkColumnExists(schema, table, columnName);
-          if (columnExists) {
-            this.logger.log(`Column "${columnName}" already exists in "${schema}"."${table}". Skipping.`);
-            continue;
-          }
-
-          // Añadir la columna
-          await this.addColumn(schema, table, columnName, columnType);
-          
-          // Añadir restricción UNIQUE si es necesario
-          if (column.details.constraint_type === 'UNIQUE') {
-            await this.addUniqueConstraint(schema, table, columnName);
-          }
-        }
-      }
-
-      this.logger.log(`Fixed columns for table "${table}" successfully`);
-    } catch (error) {
-      this.logger.error(`Error fixing columns for table "${table}": ${error.message}`);
-      throw error;
-    }
-  }
-
-  private async getTargetSchemas(): Promise<string[]> {
-    const query = `
-      SELECT schema_name
-      FROM information_schema.schemata
-      WHERE schema_name NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
-      AND schema_name NOT LIKE 'pg_%'
-    `;
-
-    const result = await this.targetPool.query(query);
-    return result.rows.map(row => row.schema_name);
-  }
-
-  private async cacheSourceColumnTypes(table: string, columns: string[]): Promise<void> {
-    if (!this.columnTypeCache[table]) {
-      this.columnTypeCache[table] = {};
-    }
-
-    const columnsStr = columns.map(c => `'${c}'`).join(',');
-    const query = `
-      SELECT column_name, data_type, 
-        CASE 
-          WHEN data_type = 'character varying' THEN data_type || '(' || character_maximum_length || ')'
-          WHEN data_type = 'numeric' THEN 
-            CASE 
-              WHEN numeric_precision IS NOT NULL AND numeric_scale IS NOT NULL 
-              THEN data_type || '(' || numeric_precision || ',' || numeric_scale || ')'
-              ELSE data_type
-            END
-          ELSE data_type
-        END as full_data_type
-      FROM information_schema.columns
-      WHERE table_schema = 'public'
-      AND table_name = $1
-      AND column_name IN (${columnsStr})
-    `;
-
-    const result = await this.sourcePool.query(query, [table]);
-    
-    for (const row of result.rows) {
-      this.columnTypeCache[table][row.column_name] = row.full_data_type;
-    }
-  }
-
-  private async checkTableExists(schema: string, table: string): Promise<boolean> {
-    const query = `
-      SELECT EXISTS (
-        SELECT FROM information_schema.tables 
-        WHERE table_schema = $1
-        AND table_name = $2
-      );
-    `;
-
-    const result = await this.targetPool.query(query, [schema, table]);
-    return result.rows[0].exists;
-  }
-
-  private async checkColumnExists(schema: string, table: string, column: string): Promise<boolean> {
-    const query = `
-      SELECT EXISTS (
-        SELECT FROM information_schema.columns 
-        WHERE table_schema = $1
-        AND table_name = $2
-        AND column_name = $3
-      );
-    `;
-
-    const result = await this.targetPool.query(query, [schema, table, column]);
-    return result.rows[0].exists;
-  }
-
-  private async addColumn(schema: string, table: string, column: string, type: string): Promise<void> {
-    try {
-      const query = `
-        ALTER TABLE "${schema}"."${table}" 
-        ADD COLUMN IF NOT EXISTS "${column}" ${type};
-      `;
-
-      await this.targetPool.query(query);
-      this.logger.log(`Added column "${column}" to "${schema}"."${table}" with type "${type}"`);
-    } catch (error) {
-      this.logger.error(`Error adding column "${column}" to "${schema}"."${table}": ${error.message}`);
-      throw error;
-    }
-  }
-
-  private async addUniqueConstraint(schema: string, table: string, column: string): Promise<void> {
-    try {
-      const constraintName = `${table}_${column}_unique`;
-      const query = `
-        ALTER TABLE "${schema}"."${table}" 
-        ADD CONSTRAINT "${constraintName}" UNIQUE ("${column}");
-      `;
-
-      await this.targetPool.query(query);
-      this.logger.log(`Added UNIQUE constraint on "${column}" to "${schema}"."${table}"`);
-    } catch (error) {
-      // Si la restricción ya existe, ignoramos el error
-      if (error.message.includes('already exists')) {
-        this.logger.log(`UNIQUE constraint on "${column}" already exists for "${schema}"."${table}"`);
-        return;
-      }
-      this.logger.error(`Error adding UNIQUE constraint on "${column}" to "${schema}"."${table}": ${error.message}`);
-      throw error;
-    }
-  }
-
-  private async cleanup(): Promise<void> {
-    try {
-      await this.sourcePool.end();
-      await this.targetPool.end();
-    } catch (error) {
-      this.logger.error(`Error during cleanup: ${error.message}`);
-    }
-  }
-}
-
-// Función para ejecutar el script directamente
-async function run() {
-  try {
-    const reportPath = process.argv[2]; // Opcional: ruta al informe
-    const fixer = new SchemaDiscrepancyFixer(
-      process.env.SOURCE_DATABASE_URL,
-      process.env.DATABASE_URL,
-      reportPath
-    );
-    
-    await fixer.fixDiscrepancies();
-    process.exit(0);
-  } catch (error) {
-    console.error('Error:', error.message);
-    process.exit(1);
-  }
-}
-
-// Ejecutar si se llama directamente
-if (require.main === module) {
-  run();
+import * as fs from 'fs';
+import * as path from 'path';
+import * as pg from 'pg';
+import { Logger } from '@nestjs/common';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+interface ColumnMismatch {
+  type: string;
+  message: string;
+  severity: string;
+  details: {
+    table: string;
+    column: string;
+    constraint_type: string;
+  };
+}
+
+interface MigrationReport {
+  timestamp: string;
+  sourceDatabase: string;
+  targetDatabase: string;
+  issueCount: number;
+  issues: ColumnMismatch[];
+}
+
+export class SchemaDiscrepancyFixer {
+  private readonly logger = new Logger('SchemaDiscrepancyFixer');
+  private readonly sourcePool: pg.Pool;
+  private readonly targetPool: pg.Pool;
+  private readonly columnTypeCache: Record<string, Record<string, string>> = {};
+
+  constructor(
+    private readonly sourceUrl: string = process.env.SOURCE_DATABASE_URL,
+    private readonly targetUrl: string = process.env.DATABASE_URL,
+    private readonly reportPath?: string
+  ) {
+    if (!this.sourceUrl) {
+      throw new Error('SOURCE_DATABASE_URL environment variable is required');
+    }
+
+    if (!this.targetUrl) {
+      throw new Error('DATABASE_URL environment variable is required');
+    }
+
+    this.sourcePool = new pg.Pool({
+      connectionString: this.sourceUrl,
+    });
+
+    this.targetPool = new pg.Pool({
+      connectionString: this.targetUrl,
+    });
+  }
+
+  async fixDiscrepancies(): Promise<void> {
+    try {
+      // Encontrar el informe de pre-migración más reciente si no se especificó uno
+      const reportFile = this.reportPath || await this.findLatestReport();
+      if (!reportFile) {
+        this.logger.error('No pre-migration report found');
+        return;
+      }
+
+      this.logger.log(`Using pre-migration report: ${reportFile}`);
+      const reportContent = fs.readFileSync(reportFile, 'utf8');
+      const report: MigrationReport = JSON.parse(reportContent);
+
+      // Filtrar solo los problemas de tipo COLUMN_MISMATCH
+      const columnMismatches = report.issues.filter(
+        issue => issue.type === 'COLUMN_MISMATCH'
+      );
+
+      if (columnMismatches.length === 0) {
+        this.logger.log('No column mismatches to fix');
+        return;
+      }
+
+      this.logger.log(`Found ${columnMismatches.length} column mismatches to fix`);
+
+      // Agrupar por tabla para optimizar las consultas
+      const tableGroups = this.groupByTable(columnMismatches);
+
+      // Procesar cada tabla
+      for (const [table, columns] of Object.entries(tableGroups)) {
+        await this.fixTableColumns(table, columns);
+      }
+
+      this.logger.log('Schema discrepancies fixed successfully');
+    } catch (error) {
+      this.logger.error(`Error fixing schema discrepancies: ${error.message}`);
+      throw error;
+    } finally {
+      await this.cleanup();
+    }
+  }
+
+  private async findLatestReport(): Promise<string | null> {
+    const logsDir = path.join(process.cwd(), 'migration-logs');
+    if (!fs.existsSync(logsDir)) {
+      return null;
+    }
+
+    const files = fs.readdirSync(logsDir);
+    const reportFiles = files.filter(file => file.startsWith('pre-migration-report-'));
+    
+    if (reportFiles.length === 0) {
+      return null;
+    }
+
+    // Ordenar por fecha (más reciente primero)
+    reportFiles.sort().reverse();
+    return path.join(logsDir, reportFiles[0]);
+  }
+
+  private groupByTable(mismatches: ColumnMismatch[]): Record<string, ColumnMismatch[]> {
+    return mismatches.reduce((groups, mismatch) => {
+      const table = mismatch.details.table;
+      if (!groups[table]) {
+        groups[table] = [];
+      }
+      groups[table].push(mismatch);
+      return groups;
+    }, {} as Record<string, ColumnMismatch[]>);
+  }
+
+  private async fixTableColumns(table: string, columns: ColumnMismatch[]): Promise<void> {
+    try {
+      this.logger.log(`Fixing columns for table "${table}"`);
+
+      // Obtener los esquemas en la base de datos de destino
+      const schemas = await this.getTargetSchemas();
+      
+      // Obtener los tipos de columna de la base de datos de origen
+      await this.cacheSourceColumnTypes(table, columns.map(c => c.details.column));
+
+      for (const schema of schemas) {
+        this.logger.log(`Processing schema "${schema}" for table "${table}"`);
+        
+        // Verificar si la tabla existe en este esquema
+        const tableExists = await this.checkTableExists(schema, table);
+        if (!tableExists) {
+          this.logger.warn(`Table "${table}" does not exist in schema "${schema}". Skipping.`);
+          continue;
+        }
+
+        // Añadir las columnas faltantes
+        for (const column of columns) {
+          const columnName = column.details.column;
+          const columnType = this.columnTypeCache[table]?.[columnName];
+          
+          if (!columnType) {
+            this.logger.warn(`Could not determine type for column "${columnName}" in table "${table}". Skipping.`);
+            continue;
+          }
+
+          // Verificar si la columna ya existe
+          const columnExists = await this.checkColumnExists(schema, table, columnName);
+          if (columnExists) {
+            this.logger.log(`Column "${columnName}" already exists in "${schema}"."${table}". Skipping.`);
+            continue;
+          }
+
+          // Añadir la columna
+          await this.addColumn(schema, table, columnName, columnType);
+          
+          // Añadir restricción UNIQUE si es necesario
+          if (column.details.constraint_type === 'UNIQUE') {
+            await this.addUniqueConstraint(schema, table, columnName);
+          }
+        }
+      }
+
+      this.logger.log(`Fixed columns for table "${table}" successfully`);
+    } catch (error) {
+      this.logger.error(`Error fixing columns for table "${table}": ${error.message}`);
+      throw error;
+    }
+  }
+
+  private async getTargetSchemas(): Promise<string[]> {
+    const query = `
+      SELECT schema_name
+      FROM information_schema.schemata
+      WHERE schema_name NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
+      AND schema_name NOT LIKE 'pg_%'
+    `;
+
+    const result = await this.targetPool.query(query);
+    return result.rows.map(row => row.schema_name);
+  }
+
+  private async cacheSourceColumnTypes(table: string, columns: string[]): Promise<void> {
+    if (!this.columnTypeCache[table]) {
+      this.columnTypeCache[table] = {};
+    }
+
+    const columnsStr = columns.map(c => `'${c}'`).join(',');
+    const query = `
+      SELECT column_name, data_type, 
+        CASE 
+          WHEN data_type = 'character varying' THEN data_type || '(' || character_maximum_length || ')'
+          WHEN data_type = 'numeric' THEN 
+            CASE 
+              WHEN numeric_precision IS NOT NULL AND numeric_scale IS NOT NULL 
+              THEN data_type || '(' || numeric_precision || ',' || numeric_scale || ')'
+              ELSE data_type
+            END
+          ELSE data_type
+        END as full_data_type
+      FROM information_schema.columns
+      WHERE table_schema = 'public'
+      AND table_name = $1
+      AND column_name IN (${columnsStr})
+    `;
+
+    const result = await this.sourcePool.query(query, [table]);
+    
+    for (const row of result.rows) {
+      this.columnTypeCache[table][row.column_name] = row.full_data_type;
+    }
+  }
+
+  private async checkTableExists(schema: string, table: string): Promise<boolean> {
+    const query = `
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables 
+        WHERE table_schema = $1
+        AND table_name = $2
+      );
+    `;
+
+    const result = await this.targetPool.query(query, [schema, table]);
+    return result.rows[0].exists;
+  }
+
+  private async checkColumnExists(schema: string, table: string, column: string): Promise<boolean> {
+    const query = `
+      SELECT EXISTS (
+        SELECT FROM information_schema.columns 
+        WHERE table_schema = $1
+        AND table_name = $2
+        AND column_name = $3
+      );
+    `;
+
+    const result = await this.targetPool.query(query, [schema, table, column]);
+    return result.rows[0].exists;
+  }
+
+  private async addColumn(schema: string, table: string, column: string, type: string): Promise<void> {
+    try {
+      const query = `
+        ALTER TABLE "${schema}"."${table}" 
+        ADD COLUMN IF NOT EXISTS "${column}" ${type};
+      `;
+
+      await this.targetPool.query(query);
+      this.logger.log(`Added column "${column}" to "${schema}"."${table}" with type "${type}"`);
+    } catch (error) {
+      this.logger.error(`Error adding column "${column}" to "${schema}"."${table}": ${error.message}`);
+      throw error;
+    }
+  }
+
+  private async addUniqueConstraint(schema: string, table: string, column: string): Promise<void> {
+    try {
+      const constraintName = `${table}_${column}_unique`;
+      const query = `
+        ALTER TABLE "${schema}"."${table}" 
+        ADD CONSTRAINT "${constraintName}" UNIQUE ("${column}");
+      `;
+
+      await this.targetPool.query(query);
+      this.logger.log(`Added UNIQUE constraint on "${column}" to "${schema}"."${table}"`);
+    } catch (error) {
+      // Si la restricción ya existe, ignoramos el error
+      if (error.message.includes('already exists')) {
+        this.logger.log(`UNIQUE constraint on "${column}" already exists for "${schema}"."${table}"`);
+        return;
+      }
+      this.logger.error(`Error adding UNIQUE constraint on "${column}" to "${schema}"."${table}": ${error.message}`);
+      throw error;
+    }
+  }
+
+  private async cleanup(): Promise<void> {
+    try {
+      await this.sourcePool.end();
+      await this.targetPool.end();
+    } catch (error) {
+      this.logger.error(`Error during cleanup: ${error.message}`);
+    }
+  }
+}
+
+// Función para ejecutar el script directamente
+async function run() {
+  try {
+    const reportPath = process.argv[2]; // Opcional: ruta al informe
+    const fixer = new SchemaDiscrepancyFixer(
+      process.env.SOURCE_DATABASE_URL,
+      process.env.DATABASE_URL,
+      reportPath
+    );
+    
+    await fixer.fixDiscrepancies();
+    process.exit(0);
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+// Ejecutar si se llama directamente
+if (require.main === module) {
+  run();
 }