@javalabs/prisma-client 1.0.4 → 1.0.6

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

@@ -1,13 +1,29 @@
-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';
+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 logger = new Logger("PostMigrationValidator");
   private readonly sourcePool: pg.Pool;
   private readonly targetPool: pg.Pool;
   private readonly reportPath: string;
@@ -26,19 +42,45 @@ export class PostMigrationValidator {
     });
 
     // Crear directorio para reportes si no existe
-    const reportsDir = path.join(process.cwd(), 'migration-logs');
+    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`);
+    const timestamp = new Date()
+      .toISOString()
+      .replace(/:/g, "-")
+      .replace(/\..+/, "");
+    this.reportPath = path.join(
+      reportsDir,
+      `post-migration-report-${timestamp}.json`
+    );
   }
 
-  async validate() {
+  async validate(options?: {
+    publicOnly?: boolean;
+  }): Promise<ValidationResult> {
+    const issues: ValidationIssue[] = [];
+    const timestamp = new Date().toISOString();
+
     try {
-      this.logger.log('Starting post-migration validation');
+      // 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(`
@@ -46,7 +88,9 @@ export class PostMigrationValidator {
         FROM api_keys
       `);
 
-      this.logger.log(`Found ${apiKeysResult.rows.length} API keys to validate`);
+      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) {
@@ -60,37 +104,48 @@ export class PostMigrationValidator {
       this.saveReport();
 
       // Mostrar resumen
-      this.logger.log(`Validation completed with ${this.issues.length} issues found`);
+      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:');
+        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.');
+        this.logger.log("No issues found. Migration was successful.");
       }
 
       return {
         success: this.issues.length === 0,
         issueCount: this.issues.length,
-        reportPath: this.reportPath
+        timestamp,
+        sourceDatabase: this.sourceUrl,
+        targetDatabase: this.targetUrl,
+        issues: this.issues,
       };
     } catch (error) {
-      this.logger.error(`Error during validation: ${error.message}`, error.stack);
+      this.logger.error(
+        `Error during validation: ${error.message}`,
+        error.stack
+      );
       this.issues.push({
-        type: 'VALIDATION_ERROR',
+        type: "VALIDATION_ERROR",
         message: `Validation process failed: ${error.message}`,
-        details: error.stack
+        details: error.stack,
       });
       this.saveReport();
       return {
         success: false,
         issueCount: this.issues.length,
-        reportPath: this.reportPath
+        timestamp,
+        sourceDatabase: this.sourceUrl,
+        targetDatabase: this.targetUrl,
+        issues: this.issues,
       };
     } finally {
       await this.cleanup();
@@ -98,28 +153,35 @@ export class PostMigrationValidator {
   }
 
   private async validateTenantData(tenantId: string, providerId: number) {
-    this.logger.log(`Validating data for tenant: ${tenantId} (Provider ID: ${providerId})`);
-    
+    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(`
+      const schemaExistsResult = await this.targetPool.query(
+        `
         SELECT 1
         FROM information_schema.schemata
         WHERE schema_name = $1
         LIMIT 1
-      `, [tenantId]);
-      
+      `,
+        [tenantId]
+      );
+
       if (schemaExistsResult.rows.length === 0) {
-        this.logger.warn(`Schema ${tenantId} does not exist in target database`);
+        this.logger.warn(
+          `Schema ${tenantId} does not exist in target database`
+        );
         this.issues.push({
-          type: 'MISSING_SCHEMA',
+          type: "MISSING_SCHEMA",
           tenantId,
           providerId,
-          message: `Schema ${tenantId} does not exist in target database. Migration failed for this tenant.`
+          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 
@@ -128,99 +190,122 @@ export class PostMigrationValidator {
         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.logger.error(
+        `Error validating tenant ${tenantId}: ${error.message}`
+      );
       this.issues.push({
-        type: 'TENANT_VALIDATION_ERROR',
+        type: "TENANT_VALIDATION_ERROR",
         tenantId,
         providerId,
-        message: `Error validating tenant ${tenantId}: ${error.message}`
+        message: `Error validating tenant ${tenantId}: ${error.message}`,
       });
     }
   }
 
-  private async validateTableData(tenantId: string, tableName: string, providerId: number) {
+  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(`
+      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]);
-      
+      `,
+        [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)}%)`);
-      
+      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',
+          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})`
+          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',
+          type: "EXCESS_DATA",
           tenantId,
           tableName,
           sourceCount,
           targetCount,
-          message: `Table ${tableName} for tenant ${tenantId}: Target has more records (${targetCount}) than source (${sourceCount})`
+          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.logger.error(
+        `Error validating table ${tableName} for tenant ${tenantId}: ${error.message}`
+      );
       this.issues.push({
-        type: 'TABLE_VALIDATION_ERROR',
+        type: "TABLE_VALIDATION_ERROR",
         tenantId,
         tableName,
-        message: `Error validating table ${tableName} for tenant ${tenantId}: ${error.message}`
+        message: `Error validating table ${tableName} for tenant ${tenantId}: ${error.message}`,
       });
     }
   }
 
-  private async validateRandomRecords(tenantId: string, tableName: string, providerId: number) {
+  private async validateRandomRecords(
+    tenantId: string,
+    tableName: string,
+    providerId: number
+  ) {
     try {
       // Obtener la clave primaria de la tabla
-      const primaryKeyResult = await this.sourcePool.query(`
+      const primaryKeyResult = await this.sourcePool.query(
+        `
         SELECT kcu.column_name
         FROM information_schema.table_constraints tc
         JOIN information_schema.key_column_usage kcu
@@ -230,111 +315,123 @@ export class PostMigrationValidator {
         AND tc.table_schema = 'public'
         AND tc.table_name = $1
         LIMIT 1
-      `, [tableName]);
-      
+      `,
+        [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(`
+      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]);
-      
+      `,
+        [tableName]
+      );
+
       if (hasProviderIdResult.rows.length > 0) {
         randomRecordsQuery += ` WHERE provider_id = ${providerId}`;
       }
-      
+
       randomRecordsQuery += `
         ORDER BY RANDOM()
         LIMIT 5
       `;
-      
-      const randomRecordsResult = await this.sourcePool.query(randomRecordsQuery);
-      
+
+      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(`
+
+        const targetRecordResult = await this.targetPool.query(
+          `
           SELECT *
           FROM "${tenantId}"."${tableName}"
           WHERE "${primaryKeyColumn}" = $1
           LIMIT 1
-        `, [primaryKeyValue]);
-        
+        `,
+          [primaryKeyValue]
+        );
+
         if (targetRecordResult.rows.length === 0) {
           this.issues.push({
-            type: 'MISSING_RECORD',
+            type: "MISSING_RECORD",
             tenantId,
             tableName,
             recordId: primaryKeyValue,
-            message: `Record with ID ${primaryKeyValue} in table ${tableName} for tenant ${tenantId} was not migrated`
+            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') {
+          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',
+              type: "MISSING_COLUMN",
               tenantId,
               tableName,
               recordId: primaryKeyValue,
               columnName,
-              message: `Column ${columnName} is missing in record with ID ${primaryKeyValue} in table ${tableName} for tenant ${tenantId}`
+              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',
+              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)`
+              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.logger.error(
+        `Error validating random records for table ${tableName} in tenant ${tenantId}: ${error.message}`
+      );
       this.issues.push({
-        type: 'RECORD_VALIDATION_ERROR',
+        type: "RECORD_VALIDATION_ERROR",
         tenantId,
         tableName,
-        message: `Error validating random records for table ${tableName} in tenant ${tenantId}: ${error.message}`
+        message: `Error validating random records for table ${tableName} in tenant ${tenantId}: ${error.message}`,
       });
     }
   }
@@ -344,33 +441,33 @@ export class PostMigrationValidator {
     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') {
+    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') {
+    if (typeof sourceValue === "string" && typeof targetValue === "string") {
       return sourceValue !== targetValue;
     }
-    
+
     // Para booleanos, comparar directamente
-    if (typeof sourceValue === 'boolean' && typeof targetValue === 'boolean') {
+    if (typeof sourceValue === "boolean" && typeof targetValue === "boolean") {
       return sourceValue !== targetValue;
     }
-    
+
     // Para otros tipos, convertir a string y comparar
     return String(sourceValue) !== String(targetValue);
   }
@@ -382,13 +479,13 @@ export class PostMigrationValidator {
         sourceDatabase: this.sourceUrl,
         targetDatabase: this.targetUrl,
         issueCount: this.issues.length,
-        issues: this.issues
+        issues: this.issues,
       };
-      
+
       fs.writeFileSync(
         this.reportPath,
         JSON.stringify(report, null, 2),
-        'utf8'
+        "utf8"
       );
     } catch (error) {
       this.logger.error(`Error saving validation report: ${error.message}`);
@@ -396,7 +493,7 @@ export class PostMigrationValidator {
   }
 
   private async cleanup() {
-    this.logger.log('Cleaning up database connections');
+    this.logger.log("Cleaning up database connections");
     await this.sourcePool.end();
     await this.targetPool.end();
   }
@@ -408,20 +505,22 @@ if (require.main === module) {
     try {
       const validator = new PostMigrationValidator();
       const result = await validator.validate();
-      
+
       if (result.success) {
-        console.log('Post-migration validation successful! No issues found.');
+        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}`);
+        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);
+      console.error("Error:", error.message);
       process.exit(1);
     }
   };
 
   run();
-}
+}