@javalabs/prisma-client 1.0.0

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

@@ -0,0 +1,427 @@
+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 PostMigrationValidator {
+  private readonly logger = new Logger('PostMigrationValidator');
+  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, `post-migration-report-${timestamp}.json`);
+  }
+
+  async validate() {
+    try {
+      this.logger.log('Starting post-migration validation');
+
+      // Obtener todos los API keys para determinar los schemas de tenant
+      const apiKeysResult = await this.sourcePool.query(`
+        SELECT api_key, provider_id
+        FROM api_keys
+      `);
+
+      this.logger.log(`Found ${apiKeysResult.rows.length} API keys to validate`);
+
+      // Para cada API key (tenant), validar los datos migrados
+      for (const apiKey of apiKeysResult.rows) {
+        const tenantId = apiKey.api_key;
+        const providerId = apiKey.provider_id;
+
+        await this.validateTenantData(tenantId, providerId);
+      }
+
+      // 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 was successful.');
+      }
+
+      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 validateTenantData(tenantId: string, providerId: number) {
+    this.logger.log(`Validating data for tenant: ${tenantId} (Provider ID: ${providerId})`);
+    
+    try {
+      // Verificar si el schema existe en la base de datos de destino
+      const schemaExistsResult = await this.targetPool.query(`
+        SELECT 1
+        FROM information_schema.schemata
+        WHERE schema_name = $1
+        LIMIT 1
+      `, [tenantId]);
+      
+      if (schemaExistsResult.rows.length === 0) {
+        this.logger.warn(`Schema ${tenantId} does not exist in target database`);
+        this.issues.push({
+          type: 'MISSING_SCHEMA',
+          tenantId,
+          providerId,
+          message: `Schema ${tenantId} does not exist in target database. Migration failed for this tenant.`
+        });
+        return;
+      }
+      
+      // 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'
+        AND table_name NOT IN ('_prisma_migrations', 'api_keys')
+      `);
+      
+      // Para cada tabla, comparar el número de registros
+      for (const tableRow of tablesResult.rows) {
+        const tableName = tableRow.table_name;
+        await this.validateTableData(tenantId, tableName, providerId);
+      }
+    } catch (error) {
+      this.logger.error(`Error validating tenant ${tenantId}: ${error.message}`);
+      this.issues.push({
+        type: 'TENANT_VALIDATION_ERROR',
+        tenantId,
+        providerId,
+        message: `Error validating tenant ${tenantId}: ${error.message}`
+      });
+    }
+  }
+
+  private async validateTableData(tenantId: string, tableName: string, providerId: number) {
+    try {
+      // Contar registros en la base de datos de origen
+      let sourceCountQuery = `SELECT COUNT(*) as count FROM ${tableName}`;
+      
+      // Añadir filtro por provider_id si la tabla tiene esa columna
+      const hasProviderIdResult = await this.sourcePool.query(`
+        SELECT 1
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+        AND table_name = $1
+        AND column_name = 'provider_id'
+        LIMIT 1
+      `, [tableName]);
+      
+      if (hasProviderIdResult.rows.length > 0) {
+        sourceCountQuery += ` WHERE provider_id = ${providerId}`;
+      }
+      
+      const sourceCountResult = await this.sourcePool.query(sourceCountQuery);
+      const sourceCount = parseInt(sourceCountResult.rows[0].count);
+      
+      // Contar registros en la base de datos de destino
+      const targetCountQuery = `SELECT COUNT(*) as count FROM "${tenantId}"."${tableName}"`;
+      const targetCountResult = await this.targetPool.query(targetCountQuery);
+      const targetCount = parseInt(targetCountResult.rows[0].count);
+      
+      // Calcular el porcentaje de migración
+      const migrationPercentage = sourceCount > 0 ? (targetCount / sourceCount) * 100 : 100;
+      
+      this.logger.log(`Table ${tableName} for tenant ${tenantId}: ${targetCount}/${sourceCount} records migrated (${migrationPercentage.toFixed(2)}%)`);
+      
+      // Si hay una discrepancia significativa, registrarla como un problema
+      if (migrationPercentage < 95) {
+        this.issues.push({
+          type: 'DATA_MISMATCH',
+          tenantId,
+          tableName,
+          sourceCount,
+          targetCount,
+          migrationPercentage: parseFloat(migrationPercentage.toFixed(2)),
+          message: `Table ${tableName} for tenant ${tenantId}: Only ${migrationPercentage.toFixed(2)}% of records were migrated (${targetCount}/${sourceCount})`
+        });
+      }
+      
+      // Si hay más registros en el destino que en el origen, también es un problema
+      if (targetCount > sourceCount) {
+        this.issues.push({
+          type: 'EXCESS_DATA',
+          tenantId,
+          tableName,
+          sourceCount,
+          targetCount,
+          message: `Table ${tableName} for tenant ${tenantId}: Target has more records (${targetCount}) than source (${sourceCount})`
+        });
+      }
+      
+      // Validar algunos registros aleatorios para verificar la integridad de los datos
+      if (sourceCount > 0 && targetCount > 0) {
+        await this.validateRandomRecords(tenantId, tableName, providerId);
+      }
+    } catch (error) {
+      this.logger.error(`Error validating table ${tableName} for tenant ${tenantId}: ${error.message}`);
+      this.issues.push({
+        type: 'TABLE_VALIDATION_ERROR',
+        tenantId,
+        tableName,
+        message: `Error validating table ${tableName} for tenant ${tenantId}: ${error.message}`
+      });
+    }
+  }
+
+  private async validateRandomRecords(tenantId: string, tableName: string, providerId: number) {
+    try {
+      // Obtener la clave primaria de la tabla
+      const primaryKeyResult = await this.sourcePool.query(`
+        SELECT kcu.column_name
+        FROM information_schema.table_constraints tc
+        JOIN information_schema.key_column_usage kcu
+          ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+        WHERE tc.constraint_type = 'PRIMARY KEY'
+        AND tc.table_schema = 'public'
+        AND tc.table_name = $1
+        LIMIT 1
+      `, [tableName]);
+      
+      if (primaryKeyResult.rows.length === 0) {
+        this.logger.warn(`No primary key found for table ${tableName}`);
+        return;
+      }
+      
+      const primaryKeyColumn = primaryKeyResult.rows[0].column_name;
+      
+      // Obtener hasta 5 registros aleatorios de la base de datos de origen
+      let randomRecordsQuery = `
+        SELECT *
+        FROM ${tableName}
+      `;
+      
+      // Añadir filtro por provider_id si la tabla tiene esa columna
+      const hasProviderIdResult = await this.sourcePool.query(`
+        SELECT 1
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+        AND table_name = $1
+        AND column_name = 'provider_id'
+        LIMIT 1
+      `, [tableName]);
+      
+      if (hasProviderIdResult.rows.length > 0) {
+        randomRecordsQuery += ` WHERE provider_id = ${providerId}`;
+      }
+      
+      randomRecordsQuery += `
+        ORDER BY RANDOM()
+        LIMIT 5
+      `;
+      
+      const randomRecordsResult = await this.sourcePool.query(randomRecordsQuery);
+      
+      // Para cada registro aleatorio, verificar si existe en la base de datos de destino
+      for (const sourceRecord of randomRecordsResult.rows) {
+        const primaryKeyValue = sourceRecord[primaryKeyColumn];
+        
+        const targetRecordResult = await this.targetPool.query(`
+          SELECT *
+          FROM "${tenantId}"."${tableName}"
+          WHERE "${primaryKeyColumn}" = $1
+          LIMIT 1
+        `, [primaryKeyValue]);
+        
+        if (targetRecordResult.rows.length === 0) {
+          this.issues.push({
+            type: 'MISSING_RECORD',
+            tenantId,
+            tableName,
+            recordId: primaryKeyValue,
+            message: `Record with ID ${primaryKeyValue} in table ${tableName} for tenant ${tenantId} was not migrated`
+          });
+          continue;
+        }
+        
+        const targetRecord = targetRecordResult.rows[0];
+        
+        // Comparar los valores de las columnas
+        for (const columnName in sourceRecord) {
+          // Ignorar columnas específicas de la base de datos de origen
+          if (columnName === 'provider_id') {
+            continue;
+          }
+          
+          // Verificar si la columna existe en el registro de destino
+          if (!(columnName in targetRecord)) {
+            this.issues.push({
+              type: 'MISSING_COLUMN',
+              tenantId,
+              tableName,
+              recordId: primaryKeyValue,
+              columnName,
+              message: `Column ${columnName} is missing in record with ID ${primaryKeyValue} in table ${tableName} for tenant ${tenantId}`
+            });
+            continue;
+          }
+          
+          // Comparar los valores (con manejo especial para tipos de datos específicos)
+          const sourceValue = sourceRecord[columnName];
+          const targetValue = targetRecord[columnName];
+          
+          if (this.areValuesDifferent(sourceValue, targetValue)) {
+            this.issues.push({
+              type: 'VALUE_MISMATCH',
+              tenantId,
+              tableName,
+              recordId: primaryKeyValue,
+              columnName,
+              sourceValue,
+              targetValue,
+              message: `Value mismatch for column ${columnName} in record with ID ${primaryKeyValue} in table ${tableName} for tenant ${tenantId}: ${sourceValue} (source) vs ${targetValue} (target)`
+            });
+          }
+        }
+      }
+    } catch (error) {
+      this.logger.error(`Error validating random records for table ${tableName} in tenant ${tenantId}: ${error.message}`);
+      this.issues.push({
+        type: 'RECORD_VALIDATION_ERROR',
+        tenantId,
+        tableName,
+        message: `Error validating random records for table ${tableName} in tenant ${tenantId}: ${error.message}`
+      });
+    }
+  }
+
+  private areValuesDifferent(sourceValue: any, targetValue: any): boolean {
+    // Si ambos son null o undefined, son iguales
+    if (sourceValue == null && targetValue == null) {
+      return false;
+    }
+    
+    // Si uno es null y el otro no, son diferentes
+    if (sourceValue == null || targetValue == null) {
+      return true;
+    }
+    
+    // Para fechas, comparar como strings ISO
+    if (sourceValue instanceof Date && targetValue instanceof Date) {
+      return sourceValue.toISOString() !== targetValue.toISOString();
+    }
+    
+    // Para números, comparar con tolerancia para punto flotante
+    if (typeof sourceValue === 'number' && typeof targetValue === 'number') {
+      const epsilon = 0.0001;
+      return Math.abs(sourceValue - targetValue) > epsilon;
+    }
+    
+    // Para strings, comparar directamente
+    if (typeof sourceValue === 'string' && typeof targetValue === 'string') {
+      return sourceValue !== targetValue;
+    }
+    
+    // Para booleanos, comparar directamente
+    if (typeof sourceValue === 'boolean' && typeof targetValue === 'boolean') {
+      return sourceValue !== targetValue;
+    }
+    
+    // Para otros tipos, convertir a string y comparar
+    return String(sourceValue) !== String(targetValue);
+  }
+
+  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 PostMigrationValidator();
+      const result = await validator.validate();
+      
+      if (result.success) {
+        console.log('Post-migration validation successful! No issues found.');
+        process.exit(0);
+      } else {
+        console.log(`Post-migration 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();
+}