@javalabs/prisma-client 1.0.18 → 1.0.20

package/src/scripts/pre-migration-validator.ts

@@ -1,611 +1,611 @@
-import * as pg from 'pg';
-import * as dotenv from 'dotenv';
-import { Logger } from '@nestjs/common';
-import * as fs from 'fs';
-import * as path from 'path';
-
-dotenv.config();
-
-export class PreMigrationValidator {
-  private readonly logger = new Logger('PreMigrationValidator');
-  private readonly sourcePool: pg.Pool;
-  private readonly targetPool: pg.Pool;
-  private readonly reportPath: string;
-  private issues: any[] = [];
-
-  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,
-    });
-
-    // Crear directorio para reportes si no existe
-    const reportsDir = path.join(process.cwd(), 'migration-logs');
-    if (!fs.existsSync(reportsDir)) {
-      fs.mkdirSync(reportsDir, { recursive: true });
-    }
-
-    // Archivo para guardar el reporte
-    const timestamp = new Date().toISOString().replace(/:/g, '-').replace(/\..+/, '');
-    this.reportPath = path.join(reportsDir, `pre-migration-report-${timestamp}.json`);
-  }
-
-  async validate() {
-    try {
-      this.logger.log('Starting pre-migration validation');
-
-      // 1. Verificar conexiones a las bases de datos
-      await this.validateDatabaseConnections();
-
-      // 2. Verificar API keys en la base de datos de origen
-      await this.validateApiKeys();
-
-      // 3. Verificar compatibilidad de tipos de datos
-      await this.validateDataTypeCompatibility();
-
-      // 4. Verificar tamaños de columnas
-      await this.validateColumnSizes();
-
-      // 5. Verificar valores de enum
-      await this.validateEnumValues();
-
-      // 6. Verificar restricciones de clave foránea
-      await this.validateForeignKeyConstraints();
-
-      // 7. Verificar índices únicos
-      await this.validateUniqueConstraints();
-
-      // Guardar el reporte
-      this.saveReport();
-
-      // Mostrar resumen
-      this.logger.log(`Validation completed with ${this.issues.length} issues found`);
-      if (this.issues.length > 0) {
-        this.logger.log(`Check the full report at: ${this.reportPath}`);
-        
-        // Mostrar los primeros 5 problemas como ejemplo
-        this.logger.log('Sample issues:');
-        for (let i = 0; i < Math.min(5, this.issues.length); i++) {
-          const issue = this.issues[i];
-          this.logger.log(`- ${issue.type}: ${issue.message}`);
-        }
-      } else {
-        this.logger.log('No issues found. Migration should proceed smoothly.');
-      }
-
-      return {
-        success: this.issues.length === 0,
-        issueCount: this.issues.length,
-        reportPath: this.reportPath
-      };
-    } catch (error) {
-      this.logger.error(`Error during validation: ${error.message}`, error.stack);
-      this.issues.push({
-        type: 'VALIDATION_ERROR',
-        message: `Validation process failed: ${error.message}`,
-        details: error.stack
-      });
-      this.saveReport();
-      return {
-        success: false,
-        issueCount: this.issues.length,
-        reportPath: this.reportPath
-      };
-    } finally {
-      await this.cleanup();
-    }
-  }
-
-  private async validateDatabaseConnections() {
-    this.logger.log('Validating database connections');
-    
-    try {
-      // Verificar conexión a la base de datos de origen
-      await this.sourcePool.query('SELECT 1');
-      this.logger.log('Source database connection successful');
-    } catch (error) {
-      this.logger.error(`Source database connection failed: ${error.message}`);
-      this.issues.push({
-        type: 'CONNECTION_ERROR',
-        source: 'source',
-        message: `Cannot connect to source database: ${error.message}`
-      });
-    }
-
-    try {
-      // Verificar conexión a la base de datos de destino
-      await this.targetPool.query('SELECT 1');
-      this.logger.log('Target database connection successful');
-    } catch (error) {
-      this.logger.error(`Target database connection failed: ${error.message}`);
-      this.issues.push({
-        type: 'CONNECTION_ERROR',
-        source: 'target',
-        message: `Cannot connect to target database: ${error.message}`
-      });
-    }
-  }
-
-  private async validateApiKeys() {
-    this.logger.log('Validating API keys');
-    
-    try {
-      // Verificar que existan API keys en la base de datos de origen
-      const result = await this.sourcePool.query(`
-        SELECT COUNT(*) as count FROM api_keys
-      `);
-      
-      const count = parseInt(result.rows[0].count);
-      
-      if (count === 0) {
-        this.logger.warn('No API keys found in source database');
-        this.issues.push({
-          type: 'DATA_ERROR',
-          message: 'No API keys found in source database. Migration will not create any tenant schemas.'
-        });
-      } else {
-        this.logger.log(`Found ${count} API keys in source database`);
-      }
-    } catch (error) {
-      this.logger.error(`Error validating API keys: ${error.message}`);
-      this.issues.push({
-        type: 'VALIDATION_ERROR',
-        message: `Error validating API keys: ${error.message}`
-      });
-    }
-  }
-
-  private async validateDataTypeCompatibility() {
-    this.logger.log('Validating data type compatibility');
-    
-    try {
-      // Obtener todas las tablas de la base de datos de origen
-      const tablesResult = await this.sourcePool.query(`
-        SELECT table_name 
-        FROM information_schema.tables 
-        WHERE table_schema = 'public'
-        AND table_type = 'BASE TABLE'
-      `);
-      
-      for (const tableRow of tablesResult.rows) {
-        const tableName = tableRow.table_name;
-        
-        // Obtener columnas de la tabla en la base de datos de origen
-        const sourceColumnsResult = await this.sourcePool.query(`
-          SELECT column_name, data_type, udt_name
-          FROM information_schema.columns
-          WHERE table_schema = 'public'
-          AND table_name = $1
-        `, [tableName]);
-        
-        // Verificar si la tabla existe en la base de datos de destino (schema public)
-        const targetTableExists = await this.targetPool.query(`
-          SELECT 1
-          FROM information_schema.tables
-          WHERE table_schema = 'public'
-          AND table_name = $1
-          LIMIT 1
-        `, [tableName]);
-        
-        if (targetTableExists.rows.length === 0) {
-          // Si la tabla no existe en el destino, no hay problema de compatibilidad
-          continue;
-        }
-        
-        // Obtener columnas de la tabla en la base de datos de destino
-        const targetColumnsResult = await this.targetPool.query(`
-          SELECT column_name, data_type, udt_name
-          FROM information_schema.columns
-          WHERE table_schema = 'public'
-          AND table_name = $1
-        `, [tableName]);
-        
-        // Crear mapas para facilitar la comparación
-        const sourceColumns = sourceColumnsResult.rows.reduce((map, col) => {
-          map[col.column_name] = col;
-          return map;
-        }, {});
-        
-        const targetColumns = targetColumnsResult.rows.reduce((map, col) => {
-          map[col.column_name] = col;
-          return map;
-        }, {});
-        
-        // Comparar tipos de datos
-        for (const columnName in sourceColumns) {
-          if (targetColumns[columnName]) {
-            const sourceType = sourceColumns[columnName].data_type;
-            const targetType = targetColumns[columnName].data_type;
-            
-            // Verificar si los tipos son compatibles
-            if (sourceType !== targetType) {
-              // Algunos tipos pueden ser compatibles aunque tengan nombres diferentes
-              const isCompatible = this.areTypesCompatible(sourceType, targetType);
-              
-              if (!isCompatible) {
-                this.logger.warn(`Data type mismatch for ${tableName}.${columnName}: ${sourceType} (source) vs ${targetType} (target)`);
-                this.issues.push({
-                  type: 'TYPE_MISMATCH',
-                  table: tableName,
-                  column: columnName,
-                  sourceType,
-                  targetType,
-                  message: `Data type mismatch for ${tableName}.${columnName}: ${sourceType} (source) vs ${targetType} (target)`
-                });
-              }
-            }
-          }
-        }
-      }
-    } catch (error) {
-      this.logger.error(`Error validating data type compatibility: ${error.message}`);
-      this.issues.push({
-        type: 'VALIDATION_ERROR',
-        message: `Error validating data type compatibility: ${error.message}`
-      });
-    }
-  }
-
-  private areTypesCompatible(sourceType: string, targetType: string): boolean {
-    // Definir pares de tipos compatibles
-    const compatibleTypes = [
-      ['character varying', 'varchar'],
-      ['character', 'char'],
-      ['integer', 'int'],
-      ['boolean', 'bool'],
-      ['double precision', 'float8'],
-      ['real', 'float4'],
-      ['timestamp without time zone', 'timestamp'],
-      ['timestamp with time zone', 'timestamptz']
-    ];
-    
-    // Verificar si los tipos son iguales
-    if (sourceType === targetType) {
-      return true;
-    }
-    
-    // Verificar si los tipos son compatibles
-    return compatibleTypes.some(pair => 
-      (pair[0] === sourceType && pair[1] === targetType) || 
-      (pair[0] === targetType && pair[1] === sourceType)
-    );
-  }
-
-  private async validateColumnSizes() {
-    this.logger.log('Validating column sizes');
-    
-    try {
-      // Obtener todas las tablas de la base de datos de origen
-      const tablesResult = await this.sourcePool.query(`
-        SELECT table_name 
-        FROM information_schema.tables 
-        WHERE table_schema = 'public'
-        AND table_type = 'BASE TABLE'
-      `);
-      
-      for (const tableRow of tablesResult.rows) {
-        const tableName = tableRow.table_name;
-        
-        // Obtener columnas de tipo character con longitud máxima
-        const sourceColumnsResult = await this.sourcePool.query(`
-          SELECT column_name, data_type, character_maximum_length
-          FROM information_schema.columns
-          WHERE table_schema = 'public'
-          AND table_name = $1
-          AND data_type IN ('character varying', 'character', 'varchar', 'char')
-          AND character_maximum_length IS NOT NULL
-        `, [tableName]);
-        
-        // Verificar si la tabla existe en la base de datos de destino (schema public)
-        const targetTableExists = await this.targetPool.query(`
-          SELECT 1
-          FROM information_schema.tables
-          WHERE table_schema = 'public'
-          AND table_name = $1
-          LIMIT 1
-        `, [tableName]);
-        
-        if (targetTableExists.rows.length === 0) {
-          // Si la tabla no existe en el destino, no hay problema de tamaño
-          continue;
-        }
-        
-        // Para cada columna, verificar si el tamaño en el destino es suficiente
-        for (const sourceColumn of sourceColumnsResult.rows) {
-          const columnName = sourceColumn.column_name;
-          const sourceMaxLength = sourceColumn.character_maximum_length;
-          
-          // Obtener la columna correspondiente en el destino
-          const targetColumnResult = await this.targetPool.query(`
-            SELECT character_maximum_length
-            FROM information_schema.columns
-            WHERE table_schema = 'public'
-            AND table_name = $1
-            AND column_name = $2
-            AND data_type IN ('character varying', 'character', 'varchar', 'char')
-          `, [tableName, columnName]);
-          
-          if (targetColumnResult.rows.length > 0) {
-            const targetMaxLength = targetColumnResult.rows[0].character_maximum_length;
-            
-            // Si el tamaño en el destino es menor, podría haber truncamiento
-            if (targetMaxLength < sourceMaxLength) {
-              this.logger.warn(`Column size mismatch for ${tableName}.${columnName}: ${sourceMaxLength} (source) vs ${targetMaxLength} (target)`);
-              this.issues.push({
-                type: 'SIZE_MISMATCH',
-                table: tableName,
-                column: columnName,
-                sourceSize: sourceMaxLength,
-                targetSize: targetMaxLength,
-                message: `Column size mismatch for ${tableName}.${columnName}: ${sourceMaxLength} (source) vs ${targetMaxLength} (target). Data may be truncated.`
-              });
-            }
-          }
-        }
-      }
-    } catch (error) {
-      this.logger.error(`Error validating column sizes: ${error.message}`);
-      this.issues.push({
-        type: 'VALIDATION_ERROR',
-        message: `Error validating column sizes: ${error.message}`
-      });
-    }
-  }
-
-  private async validateEnumValues() {
-    this.logger.log('Validating enum values');
-    
-    try {
-      // 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'
-      `);
-      
-      // Para cada tipo enum, obtener sus valores
-      for (const enumRow of sourceEnumsResult.rows) {
-        const enumName = enumRow.enum_name;
-        
-        // 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);
-        
-        // 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, no hay problema de compatibilidad
-          continue;
-        }
-        
-        // Obtener valores 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);
-        
-        // Verificar si todos los valores del origen existen en el destino
-        for (const sourceValue of sourceEnumValues) {
-          if (!targetEnumValues.includes(sourceValue)) {
-            this.logger.warn(`Enum value '${sourceValue}' for type ${enumName} exists in source but not in target`);
-            this.issues.push({
-              type: 'ENUM_VALUE_MISSING',
-              enumType: enumName,
-              value: sourceValue,
-              message: `Enum value '${sourceValue}' for type ${enumName} exists in source but not in target. Data migration will fail for records with this value.`
-            });
-          }
-        }
-      }
-    } catch (error) {
-      this.logger.error(`Error validating enum values: ${error.message}`);
-      this.issues.push({
-        type: 'VALIDATION_ERROR',
-        message: `Error validating enum values: ${error.message}`
-      });
-    }
-  }
-
-  private async validateForeignKeyConstraints() {
-    this.logger.log('Validating foreign key constraints');
-    
-    // Esta validación es más compleja y depende de la estructura específica
-    // Por ahora, solo verificamos si hay tablas con claves foráneas en el origen
-    try {
-      const foreignKeysResult = await this.sourcePool.query(`
-        SELECT
-          tc.table_name,
-          kcu.column_name,
-          ccu.table_name AS foreign_table_name,
-          ccu.column_name AS foreign_column_name
-        FROM
-          information_schema.table_constraints AS tc
-          JOIN information_schema.key_column_usage AS kcu
-            ON tc.constraint_name = kcu.constraint_name
-            AND tc.table_schema = kcu.table_schema
-          JOIN information_schema.constraint_column_usage AS ccu
-            ON ccu.constraint_name = tc.constraint_name
-            AND ccu.table_schema = tc.table_schema
-        WHERE tc.constraint_type = 'FOREIGN KEY'
-        AND tc.table_schema = 'public'
-      `);
-      
-      this.logger.log(`Found ${foreignKeysResult.rows.length} foreign key constraints in source database`);
-      
-      // Aquí podríamos hacer validaciones más específicas si es necesario
-    } catch (error) {
-      this.logger.error(`Error validating foreign key constraints: ${error.message}`);
-      this.issues.push({
-        type: 'VALIDATION_ERROR',
-        message: `Error validating foreign key constraints: ${error.message}`
-      });
-    }
-  }
-
-  private async validateUniqueConstraints() {
-    this.logger.log('Validating unique constraints...');
-    
-    try {
-      // Obtener restricciones únicas de la base de datos de origen
-      const sourceConstraintsQuery = `
-        SELECT 
-          tc.table_name, 
-          kcu.column_name 
-        FROM 
-          information_schema.table_constraints tc
-          JOIN information_schema.key_column_usage kcu
-            ON tc.constraint_name = kcu.constraint_name
-        WHERE 
-          tc.constraint_type = 'UNIQUE'
-          AND tc.table_schema = 'public'
-      `;
-      
-      const sourceConstraints = await this.sourcePool.query(sourceConstraintsQuery);
-      
-      // Para cada restricción, verificar si existe en la base de datos de destino
-      for (const constraint of sourceConstraints.rows) {
-        const { table_name, column_name } = constraint;
-        
-        try {
-          // Verificar si la columna existe en la tabla de destino
-          const columnExistsQuery = `
-            SELECT column_name 
-            FROM information_schema.columns 
-            WHERE table_name = $1 
-              AND column_name = $2
-              AND table_schema = 'public'
-          `;
-          
-          const columnExists = await this.targetPool.query(columnExistsQuery, [table_name, column_name]);
-          
-          if (columnExists.rows.length === 0) {
-            // La columna no existe, registrar como advertencia pero no como error crítico
-            this.issues.push({
-              type: 'COLUMN_MISMATCH',
-              message: `Column "${column_name}" in table "${table_name}" exists in source but not in target`,
-              severity: 'WARNING',
-              details: {
-                table: table_name,
-                column: column_name,
-                constraint_type: 'UNIQUE'
-              }
-            });
-            continue; // Saltar a la siguiente restricción
-          }
-          
-          // Resto del código para validar restricciones únicas...
-        } catch (error) {
-          // Capturar errores específicos de columnas que no existen
-          if (error.message.includes('does not exist')) {
-            this.issues.push({
-              type: 'COLUMN_MISMATCH',
-              message: `Error checking column "${column_name}" in table "${table_name}": ${error.message}`,
-              severity: 'WARNING',
-              details: {
-                table: table_name,
-                column: column_name,
-                error: error.message
-              }
-            });
-          } else {
-            throw error; // Re-lanzar otros errores
-          }
-        }
-      }
-      
-      this.logger.log('Unique constraints validation completed');
-    } catch (error) {
-      // Convertir errores críticos en advertencias para permitir que la migración continúe
-      this.issues.push({
-        type: 'VALIDATION_ERROR',
-        message: `Error validating unique constraints: ${error.message}`,
-        severity: 'WARNING',
-        details: {
-          error: error.message,
-          stack: error.stack
-        }
-      });
-      
-      this.logger.warn(`Error during unique constraints validation: ${error.message}`);
-    }
-  }
-
-  private saveReport() {
-    try {
-      const report = {
-        timestamp: new Date().toISOString(),
-        sourceDatabase: this.sourceUrl,
-        targetDatabase: this.targetUrl,
-        issueCount: this.issues.length,
-        issues: this.issues
-      };
-      
-      fs.writeFileSync(
-        this.reportPath,
-        JSON.stringify(report, null, 2),
-        'utf8'
-      );
-    } catch (error) {
-      this.logger.error(`Error saving validation report: ${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 validator = new PreMigrationValidator();
-      const result = await validator.validate();
-      
-      if (result.success) {
-        console.log('Validation successful! No issues found.');
-        process.exit(0);
-      } else {
-        console.log(`Validation completed with ${result.issueCount} issues found.`);
-        console.log(`Check the full report at: ${result.reportPath}`);
-        process.exit(1);
-      }
-    } 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';
+import * as fs from 'fs';
+import * as path from 'path';
+
+dotenv.config();
+
+export class PreMigrationValidator {
+  private readonly logger = new Logger('PreMigrationValidator');
+  private readonly sourcePool: pg.Pool;
+  private readonly targetPool: pg.Pool;
+  private readonly reportPath: string;
+  private issues: any[] = [];
+
+  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,
+    });
+
+    // Crear directorio para reportes si no existe
+    const reportsDir = path.join(process.cwd(), 'migration-logs');
+    if (!fs.existsSync(reportsDir)) {
+      fs.mkdirSync(reportsDir, { recursive: true });
+    }
+
+    // Archivo para guardar el reporte
+    const timestamp = new Date().toISOString().replace(/:/g, '-').replace(/\..+/, '');
+    this.reportPath = path.join(reportsDir, `pre-migration-report-${timestamp}.json`);
+  }
+
+  async validate() {
+    try {
+      this.logger.log('Starting pre-migration validation');
+
+      // 1. Verificar conexiones a las bases de datos
+      await this.validateDatabaseConnections();
+
+      // 2. Verificar API keys en la base de datos de origen
+      await this.validateApiKeys();
+
+      // 3. Verificar compatibilidad de tipos de datos
+      await this.validateDataTypeCompatibility();
+
+      // 4. Verificar tamaños de columnas
+      await this.validateColumnSizes();
+
+      // 5. Verificar valores de enum
+      await this.validateEnumValues();
+
+      // 6. Verificar restricciones de clave foránea
+      await this.validateForeignKeyConstraints();
+
+      // 7. Verificar índices únicos
+      await this.validateUniqueConstraints();
+
+      // Guardar el reporte
+      this.saveReport();
+
+      // Mostrar resumen
+      this.logger.log(`Validation completed with ${this.issues.length} issues found`);
+      if (this.issues.length > 0) {
+        this.logger.log(`Check the full report at: ${this.reportPath}`);
+        
+        // Mostrar los primeros 5 problemas como ejemplo
+        this.logger.log('Sample issues:');
+        for (let i = 0; i < Math.min(5, this.issues.length); i++) {
+          const issue = this.issues[i];
+          this.logger.log(`- ${issue.type}: ${issue.message}`);
+        }
+      } else {
+        this.logger.log('No issues found. Migration should proceed smoothly.');
+      }
+
+      return {
+        success: this.issues.length === 0,
+        issueCount: this.issues.length,
+        reportPath: this.reportPath
+      };
+    } catch (error) {
+      this.logger.error(`Error during validation: ${error.message}`, error.stack);
+      this.issues.push({
+        type: 'VALIDATION_ERROR',
+        message: `Validation process failed: ${error.message}`,
+        details: error.stack
+      });
+      this.saveReport();
+      return {
+        success: false,
+        issueCount: this.issues.length,
+        reportPath: this.reportPath
+      };
+    } finally {
+      await this.cleanup();
+    }
+  }
+
+  private async validateDatabaseConnections() {
+    this.logger.log('Validating database connections');
+    
+    try {
+      // Verificar conexión a la base de datos de origen
+      await this.sourcePool.query('SELECT 1');
+      this.logger.log('Source database connection successful');
+    } catch (error) {
+      this.logger.error(`Source database connection failed: ${error.message}`);
+      this.issues.push({
+        type: 'CONNECTION_ERROR',
+        source: 'source',
+        message: `Cannot connect to source database: ${error.message}`
+      });
+    }
+
+    try {
+      // Verificar conexión a la base de datos de destino
+      await this.targetPool.query('SELECT 1');
+      this.logger.log('Target database connection successful');
+    } catch (error) {
+      this.logger.error(`Target database connection failed: ${error.message}`);
+      this.issues.push({
+        type: 'CONNECTION_ERROR',
+        source: 'target',
+        message: `Cannot connect to target database: ${error.message}`
+      });
+    }
+  }
+
+  private async validateApiKeys() {
+    this.logger.log('Validating API keys');
+    
+    try {
+      // Verificar que existan API keys en la base de datos de origen
+      const result = await this.sourcePool.query(`
+        SELECT COUNT(*) as count FROM api_keys
+      `);
+      
+      const count = parseInt(result.rows[0].count);
+      
+      if (count === 0) {
+        this.logger.warn('No API keys found in source database');
+        this.issues.push({
+          type: 'DATA_ERROR',
+          message: 'No API keys found in source database. Migration will not create any tenant schemas.'
+        });
+      } else {
+        this.logger.log(`Found ${count} API keys in source database`);
+      }
+    } catch (error) {
+      this.logger.error(`Error validating API keys: ${error.message}`);
+      this.issues.push({
+        type: 'VALIDATION_ERROR',
+        message: `Error validating API keys: ${error.message}`
+      });
+    }
+  }
+
+  private async validateDataTypeCompatibility() {
+    this.logger.log('Validating data type compatibility');
+    
+    try {
+      // Obtener todas las tablas de la base de datos de origen
+      const tablesResult = await this.sourcePool.query(`
+        SELECT table_name 
+        FROM information_schema.tables 
+        WHERE table_schema = 'public'
+        AND table_type = 'BASE TABLE'
+      `);
+      
+      for (const tableRow of tablesResult.rows) {
+        const tableName = tableRow.table_name;
+        
+        // Obtener columnas de la tabla en la base de datos de origen
+        const sourceColumnsResult = await this.sourcePool.query(`
+          SELECT column_name, data_type, udt_name
+          FROM information_schema.columns
+          WHERE table_schema = 'public'
+          AND table_name = $1
+        `, [tableName]);
+        
+        // Verificar si la tabla existe en la base de datos de destino (schema public)
+        const targetTableExists = await this.targetPool.query(`
+          SELECT 1
+          FROM information_schema.tables
+          WHERE table_schema = 'public'
+          AND table_name = $1
+          LIMIT 1
+        `, [tableName]);
+        
+        if (targetTableExists.rows.length === 0) {
+          // Si la tabla no existe en el destino, no hay problema de compatibilidad
+          continue;
+        }
+        
+        // Obtener columnas de la tabla en la base de datos de destino
+        const targetColumnsResult = await this.targetPool.query(`
+          SELECT column_name, data_type, udt_name
+          FROM information_schema.columns
+          WHERE table_schema = 'public'
+          AND table_name = $1
+        `, [tableName]);
+        
+        // Crear mapas para facilitar la comparación
+        const sourceColumns = sourceColumnsResult.rows.reduce((map, col) => {
+          map[col.column_name] = col;
+          return map;
+        }, {});
+        
+        const targetColumns = targetColumnsResult.rows.reduce((map, col) => {
+          map[col.column_name] = col;
+          return map;
+        }, {});
+        
+        // Comparar tipos de datos
+        for (const columnName in sourceColumns) {
+          if (targetColumns[columnName]) {
+            const sourceType = sourceColumns[columnName].data_type;
+            const targetType = targetColumns[columnName].data_type;
+            
+            // Verificar si los tipos son compatibles
+            if (sourceType !== targetType) {
+              // Algunos tipos pueden ser compatibles aunque tengan nombres diferentes
+              const isCompatible = this.areTypesCompatible(sourceType, targetType);
+              
+              if (!isCompatible) {
+                this.logger.warn(`Data type mismatch for ${tableName}.${columnName}: ${sourceType} (source) vs ${targetType} (target)`);
+                this.issues.push({
+                  type: 'TYPE_MISMATCH',
+                  table: tableName,
+                  column: columnName,
+                  sourceType,
+                  targetType,
+                  message: `Data type mismatch for ${tableName}.${columnName}: ${sourceType} (source) vs ${targetType} (target)`
+                });
+              }
+            }
+          }
+        }
+      }
+    } catch (error) {
+      this.logger.error(`Error validating data type compatibility: ${error.message}`);
+      this.issues.push({
+        type: 'VALIDATION_ERROR',
+        message: `Error validating data type compatibility: ${error.message}`
+      });
+    }
+  }
+
+  private areTypesCompatible(sourceType: string, targetType: string): boolean {
+    // Definir pares de tipos compatibles
+    const compatibleTypes = [
+      ['character varying', 'varchar'],
+      ['character', 'char'],
+      ['integer', 'int'],
+      ['boolean', 'bool'],
+      ['double precision', 'float8'],
+      ['real', 'float4'],
+      ['timestamp without time zone', 'timestamp'],
+      ['timestamp with time zone', 'timestamptz']
+    ];
+    
+    // Verificar si los tipos son iguales
+    if (sourceType === targetType) {
+      return true;
+    }
+    
+    // Verificar si los tipos son compatibles
+    return compatibleTypes.some(pair => 
+      (pair[0] === sourceType && pair[1] === targetType) || 
+      (pair[0] === targetType && pair[1] === sourceType)
+    );
+  }
+
+  private async validateColumnSizes() {
+    this.logger.log('Validating column sizes');
+    
+    try {
+      // Obtener todas las tablas de la base de datos de origen
+      const tablesResult = await this.sourcePool.query(`
+        SELECT table_name 
+        FROM information_schema.tables 
+        WHERE table_schema = 'public'
+        AND table_type = 'BASE TABLE'
+      `);
+      
+      for (const tableRow of tablesResult.rows) {
+        const tableName = tableRow.table_name;
+        
+        // Obtener columnas de tipo character con longitud máxima
+        const sourceColumnsResult = await this.sourcePool.query(`
+          SELECT column_name, data_type, character_maximum_length
+          FROM information_schema.columns
+          WHERE table_schema = 'public'
+          AND table_name = $1
+          AND data_type IN ('character varying', 'character', 'varchar', 'char')
+          AND character_maximum_length IS NOT NULL
+        `, [tableName]);
+        
+        // Verificar si la tabla existe en la base de datos de destino (schema public)
+        const targetTableExists = await this.targetPool.query(`
+          SELECT 1
+          FROM information_schema.tables
+          WHERE table_schema = 'public'
+          AND table_name = $1
+          LIMIT 1
+        `, [tableName]);
+        
+        if (targetTableExists.rows.length === 0) {
+          // Si la tabla no existe en el destino, no hay problema de tamaño
+          continue;
+        }
+        
+        // Para cada columna, verificar si el tamaño en el destino es suficiente
+        for (const sourceColumn of sourceColumnsResult.rows) {
+          const columnName = sourceColumn.column_name;
+          const sourceMaxLength = sourceColumn.character_maximum_length;
+          
+          // Obtener la columna correspondiente en el destino
+          const targetColumnResult = await this.targetPool.query(`
+            SELECT character_maximum_length
+            FROM information_schema.columns
+            WHERE table_schema = 'public'
+            AND table_name = $1
+            AND column_name = $2
+            AND data_type IN ('character varying', 'character', 'varchar', 'char')
+          `, [tableName, columnName]);
+          
+          if (targetColumnResult.rows.length > 0) {
+            const targetMaxLength = targetColumnResult.rows[0].character_maximum_length;
+            
+            // Si el tamaño en el destino es menor, podría haber truncamiento
+            if (targetMaxLength < sourceMaxLength) {
+              this.logger.warn(`Column size mismatch for ${tableName}.${columnName}: ${sourceMaxLength} (source) vs ${targetMaxLength} (target)`);
+              this.issues.push({
+                type: 'SIZE_MISMATCH',
+                table: tableName,
+                column: columnName,
+                sourceSize: sourceMaxLength,
+                targetSize: targetMaxLength,
+                message: `Column size mismatch for ${tableName}.${columnName}: ${sourceMaxLength} (source) vs ${targetMaxLength} (target). Data may be truncated.`
+              });
+            }
+          }
+        }
+      }
+    } catch (error) {
+      this.logger.error(`Error validating column sizes: ${error.message}`);
+      this.issues.push({
+        type: 'VALIDATION_ERROR',
+        message: `Error validating column sizes: ${error.message}`
+      });
+    }
+  }
+
+  private async validateEnumValues() {
+    this.logger.log('Validating enum values');
+    
+    try {
+      // 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'
+      `);
+      
+      // Para cada tipo enum, obtener sus valores
+      for (const enumRow of sourceEnumsResult.rows) {
+        const enumName = enumRow.enum_name;
+        
+        // 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);
+        
+        // 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, no hay problema de compatibilidad
+          continue;
+        }
+        
+        // Obtener valores 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);
+        
+        // Verificar si todos los valores del origen existen en el destino
+        for (const sourceValue of sourceEnumValues) {
+          if (!targetEnumValues.includes(sourceValue)) {
+            this.logger.warn(`Enum value '${sourceValue}' for type ${enumName} exists in source but not in target`);
+            this.issues.push({
+              type: 'ENUM_VALUE_MISSING',
+              enumType: enumName,
+              value: sourceValue,
+              message: `Enum value '${sourceValue}' for type ${enumName} exists in source but not in target. Data migration will fail for records with this value.`
+            });
+          }
+        }
+      }
+    } catch (error) {
+      this.logger.error(`Error validating enum values: ${error.message}`);
+      this.issues.push({
+        type: 'VALIDATION_ERROR',
+        message: `Error validating enum values: ${error.message}`
+      });
+    }
+  }
+
+  private async validateForeignKeyConstraints() {
+    this.logger.log('Validating foreign key constraints');
+    
+    // Esta validación es más compleja y depende de la estructura específica
+    // Por ahora, solo verificamos si hay tablas con claves foráneas en el origen
+    try {
+      const foreignKeysResult = await this.sourcePool.query(`
+        SELECT
+          tc.table_name,
+          kcu.column_name,
+          ccu.table_name AS foreign_table_name,
+          ccu.column_name AS foreign_column_name
+        FROM
+          information_schema.table_constraints AS tc
+          JOIN information_schema.key_column_usage AS kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          JOIN information_schema.constraint_column_usage AS ccu
+            ON ccu.constraint_name = tc.constraint_name
+            AND ccu.table_schema = tc.table_schema
+        WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_schema = 'public'
+      `);
+      
+      this.logger.log(`Found ${foreignKeysResult.rows.length} foreign key constraints in source database`);
+      
+      // Aquí podríamos hacer validaciones más específicas si es necesario
+    } catch (error) {
+      this.logger.error(`Error validating foreign key constraints: ${error.message}`);
+      this.issues.push({
+        type: 'VALIDATION_ERROR',
+        message: `Error validating foreign key constraints: ${error.message}`
+      });
+    }
+  }
+
+  private async validateUniqueConstraints() {
+    this.logger.log('Validating unique constraints...');
+    
+    try {
+      // Obtener restricciones únicas de la base de datos de origen
+      const sourceConstraintsQuery = `
+        SELECT 
+          tc.table_name, 
+          kcu.column_name 
+        FROM 
+          information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu
+            ON tc.constraint_name = kcu.constraint_name
+        WHERE 
+          tc.constraint_type = 'UNIQUE'
+          AND tc.table_schema = 'public'
+      `;
+      
+      const sourceConstraints = await this.sourcePool.query(sourceConstraintsQuery);
+      
+      // Para cada restricción, verificar si existe en la base de datos de destino
+      for (const constraint of sourceConstraints.rows) {
+        const { table_name, column_name } = constraint;
+        
+        try {
+          // Verificar si la columna existe en la tabla de destino
+          const columnExistsQuery = `
+            SELECT column_name 
+            FROM information_schema.columns 
+            WHERE table_name = $1 
+              AND column_name = $2
+              AND table_schema = 'public'
+          `;
+          
+          const columnExists = await this.targetPool.query(columnExistsQuery, [table_name, column_name]);
+          
+          if (columnExists.rows.length === 0) {
+            // La columna no existe, registrar como advertencia pero no como error crítico
+            this.issues.push({
+              type: 'COLUMN_MISMATCH',
+              message: `Column "${column_name}" in table "${table_name}" exists in source but not in target`,
+              severity: 'WARNING',
+              details: {
+                table: table_name,
+                column: column_name,
+                constraint_type: 'UNIQUE'
+              }
+            });
+            continue; // Saltar a la siguiente restricción
+          }
+          
+          // Resto del código para validar restricciones únicas...
+        } catch (error) {
+          // Capturar errores específicos de columnas que no existen
+          if (error.message.includes('does not exist')) {
+            this.issues.push({
+              type: 'COLUMN_MISMATCH',
+              message: `Error checking column "${column_name}" in table "${table_name}": ${error.message}`,
+              severity: 'WARNING',
+              details: {
+                table: table_name,
+                column: column_name,
+                error: error.message
+              }
+            });
+          } else {
+            throw error; // Re-lanzar otros errores
+          }
+        }
+      }
+      
+      this.logger.log('Unique constraints validation completed');
+    } catch (error) {
+      // Convertir errores críticos en advertencias para permitir que la migración continúe
+      this.issues.push({
+        type: 'VALIDATION_ERROR',
+        message: `Error validating unique constraints: ${error.message}`,
+        severity: 'WARNING',
+        details: {
+          error: error.message,
+          stack: error.stack
+        }
+      });
+      
+      this.logger.warn(`Error during unique constraints validation: ${error.message}`);
+    }
+  }
+
+  private saveReport() {
+    try {
+      const report = {
+        timestamp: new Date().toISOString(),
+        sourceDatabase: this.sourceUrl,
+        targetDatabase: this.targetUrl,
+        issueCount: this.issues.length,
+        issues: this.issues
+      };
+      
+      fs.writeFileSync(
+        this.reportPath,
+        JSON.stringify(report, null, 2),
+        'utf8'
+      );
+    } catch (error) {
+      this.logger.error(`Error saving validation report: ${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 validator = new PreMigrationValidator();
+      const result = await validator.validate();
+      
+      if (result.success) {
+        console.log('Validation successful! No issues found.');
+        process.exit(0);
+      } else {
+        console.log(`Validation completed with ${result.issueCount} issues found.`);
+        console.log(`Check the full report at: ${result.reportPath}`);
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  };
+
+  run();
 }