@javalabs/prisma-client 1.0.18 → 1.0.19

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

@@ -1,526 +1,526 @@
-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();
-
-interface ValidationIssue {
-  type: string;
-  tenantId?: string;
-  providerId?: number | null;
-  message: string;
-}
-
-interface ValidationResult {
-  success: boolean;
-  issueCount: number;
-  timestamp: string;
-  sourceDatabase: string;
-  targetDatabase: string;
-  issues: ValidationIssue[];
-}
-
-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(options?: {
-    publicOnly?: boolean;
-  }): Promise<ValidationResult> {
-    const issues: ValidationIssue[] = [];
-    const timestamp = new Date().toISOString();
-
-    try {
-      // Si estamos en modo public-only, solo validamos el esquema público
-      if (options?.publicOnly) {
-        this.logger.log("Running validation in public-only mode");
-        // Aquí solo validaríamos las tablas públicas
-        return {
-          success: true,
-          issueCount: 0,
-          timestamp,
-          sourceDatabase: process.env.SOURCE_DATABASE_URL,
-          targetDatabase: process.env.DATABASE_URL,
-          issues: [],
-        };
-      }
-
-      // Si no es public-only, procedemos con la validación normal de todos los schemas
-      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,
-        timestamp,
-        sourceDatabase: this.sourceUrl,
-        targetDatabase: this.targetUrl,
-        issues: this.issues,
-      };
-    } 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,
-        timestamp,
-        sourceDatabase: this.sourceUrl,
-        targetDatabase: this.targetUrl,
-        issues: this.issues,
-      };
-    } 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(JSON.stringify(result, null, 2));
-        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();
+
+interface ValidationIssue {
+  type: string;
+  tenantId?: string;
+  providerId?: number | null;
+  message: string;
+}
+
+interface ValidationResult {
+  success: boolean;
+  issueCount: number;
+  timestamp: string;
+  sourceDatabase: string;
+  targetDatabase: string;
+  issues: ValidationIssue[];
+}
+
+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(options?: {
+    publicOnly?: boolean;
+  }): Promise<ValidationResult> {
+    const issues: ValidationIssue[] = [];
+    const timestamp = new Date().toISOString();
+
+    try {
+      // Si estamos en modo public-only, solo validamos el esquema público
+      if (options?.publicOnly) {
+        this.logger.log("Running validation in public-only mode");
+        // Aquí solo validaríamos las tablas públicas
+        return {
+          success: true,
+          issueCount: 0,
+          timestamp,
+          sourceDatabase: process.env.SOURCE_DATABASE_URL,
+          targetDatabase: process.env.DATABASE_URL,
+          issues: [],
+        };
+      }
+
+      // Si no es public-only, procedemos con la validación normal de todos los schemas
+      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,
+        timestamp,
+        sourceDatabase: this.sourceUrl,
+        targetDatabase: this.targetUrl,
+        issues: this.issues,
+      };
+    } 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,
+        timestamp,
+        sourceDatabase: this.sourceUrl,
+        targetDatabase: this.targetUrl,
+        issues: this.issues,
+      };
+    } 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(JSON.stringify(result, null, 2));
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error("Error:", error.message);
+      process.exit(1);
+    }
+  };
+
+  run();
+}