@javalabs/prisma-client 1.0.0

package/src/scripts/error-handler.ts

@@ -0,0 +1,118 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { Logger } from '@nestjs/common';
+
+export class MigrationErrorHandler {
+  private readonly logger = new Logger('MigrationErrorHandler');
+  private errorLog: Record<string, any[]> = {};
+  private errorLogPath: string;
+
+  constructor(private readonly logDir: string = path.join(process.cwd(), 'migration-logs')) {
+    // Crear directorio de logs si no existe
+    if (!fs.existsSync(this.logDir)) {
+      fs.mkdirSync(this.logDir, { recursive: true });
+    }
+
+    // Crear nombre de archivo con timestamp
+    const timestamp = new Date().toISOString().replace(/:/g, '-').replace(/\..+/, '');
+    this.errorLogPath = path.join(this.logDir, `migration-errors-${timestamp}.json`);
+    
+    // Inicializar archivo de log
+    this.saveErrorLog();
+  }
+
+  /**
+   * Registra un error durante la migración
+   */
+  logError(tenantId: string, entityName: string, recordId: any, error: Error, data?: any): void {
+    if (!this.errorLog[tenantId]) {
+      this.errorLog[tenantId] = [];
+    }
+
+    this.errorLog[tenantId].push({
+      timestamp: new Date().toISOString(),
+      entity: entityName,
+      recordId,
+      error: {
+        message: error.message,
+        stack: error.stack,
+      },
+      data: data || null,
+    });
+
+    // Guardar el log después de cada error
+    this.saveErrorLog();
+  }
+
+  /**
+   * Guarda el log de errores en un archivo JSON
+   */
+  private saveErrorLog(): void {
+    try {
+      fs.writeFileSync(
+        this.errorLogPath,
+        JSON.stringify(this.errorLog, null, 2),
+        'utf8'
+      );
+    } catch (error) {
+      this.logger.error(`Error saving error log: ${error.message}`);
+    }
+  }
+
+  /**
+   * Genera un informe de errores
+   */
+  generateErrorReport(): string {
+    let totalErrors = 0;
+    let report = 'Migration Error Report\n';
+    report += '=====================\n\n';
+
+    for (const tenantId in this.errorLog) {
+      const tenantErrors = this.errorLog[tenantId];
+      if (tenantErrors.length === 0) continue;
+
+      totalErrors += tenantErrors.length;
+      report += `Tenant: ${tenantId}\n`;
+      report += `Errors: ${tenantErrors.length}\n\n`;
+
+      // Agrupar errores por entidad
+      const entityErrors: Record<string, number> = {};
+      for (const error of tenantErrors) {
+        entityErrors[error.entity] = (entityErrors[error.entity] || 0) + 1;
+      }
+
+      report += 'Errors by entity:\n';
+      for (const entity in entityErrors) {
+        report += `  - ${entity}: ${entityErrors[entity]}\n`;
+      }
+      report += '\n';
+
+      // Mostrar los primeros 5 errores como ejemplo
+      report += 'Sample errors:\n';
+      for (let i = 0; i < Math.min(5, tenantErrors.length); i++) {
+        const error = tenantErrors[i];
+        report += `  - ${error.entity} (ID: ${error.recordId}): ${error.error.message}\n`;
+      }
+      report += '\n';
+    }
+
+    report += `Total errors: ${totalErrors}\n`;
+    report += `Full error log saved to: ${this.errorLogPath}\n`;
+
+    return report;
+  }
+
+  /**
+   * Obtiene la lista de errores para un tenant específico
+   */
+  getErrorsForTenant(tenantId: string): any[] {
+    return this.errorLog[tenantId] || [];
+  }
+
+  /**
+   * Obtiene todos los errores
+   */
+  getAllErrors(): Record<string, any[]> {
+    return this.errorLog;
+  }
+}

package/src/scripts/fix-data-types.ts

@@ -0,0 +1,242 @@
+import { PrismaClient } from "@prisma/client";
+import * as dotenv from "dotenv";
+import { Logger } from "@nestjs/common";
+import * as pg from "pg";
+
+dotenv.config();
+
+export class DataTypeFixer {
+  private readonly logger = new Logger("DataTypeFixer");
+  private readonly sourcePool: pg.Pool;
+  private readonly targetPool: pg.Pool;
+
+  constructor() {
+    // Source database connection
+    this.sourcePool = new pg.Pool({
+      connectionString: process.env.SOURCE_DATABASE_URL,
+    });
+
+    // Target database connection
+    this.targetPool = new pg.Pool({
+      connectionString: process.env.DATABASE_URL,
+    });
+  }
+
+  async fixDataTypes() {
+    try {
+      this.logger.log("Starting data type fixing process");
+
+      // Get all schemas (tenants) from the target database
+      const schemasQuery = `
+        SELECT schema_name
+        FROM information_schema.schemata
+        WHERE schema_name NOT IN ('public', 'information_schema', 'pg_catalog', 'pg_toast')
+        AND schema_name NOT LIKE 'pg_%';
+      `;
+      
+      const schemasResult = await this.targetPool.query(schemasQuery);
+      const schemas = schemasResult.rows.map(row => row.schema_name);
+      
+      this.logger.log(`Found ${schemas.length} schemas to process`);
+      
+      // Process each schema
+      for (const schema of schemas) {
+        await this.fixNumericFieldsForSchema(schema);
+        await this.fixEnumFieldsForSchema(schema);
+      }
+      
+      this.logger.log("Data type fixing completed successfully");
+    } catch (error) {
+      this.logger.error(
+        `Error during data type fixing: ${error.message}`,
+        error.stack
+      );
+    } finally {
+      await this.cleanup();
+    }
+  }
+  
+  private async fixNumericFieldsForSchema(schema: string) {
+    this.logger.log(`Processing numeric fields for schema: ${schema}`);
+    
+    try {
+      // Get all tables with numeric columns in this schema
+      const numericColumnsQuery = `
+        SELECT 
+          table_name, 
+          column_name
+        FROM 
+          information_schema.columns
+        WHERE 
+          table_schema = $1
+          AND data_type = 'numeric'
+      `;
+      
+      const numericColumnsResult = await this.targetPool.query(numericColumnsQuery, [schema]);
+      
+      // Process each table with numeric columns
+      for (const row of numericColumnsResult.rows) {
+        const tableName = row.table_name;
+        const columnName = row.column_name;
+        
+        this.logger.log(`Fixing numeric column ${columnName} in table ${schema}.${tableName}`);
+        
+        // Update the column to cast text values to numeric
+        const updateQuery = `
+          UPDATE "${schema}"."${tableName}"
+          SET "${columnName}" = CASE
+            WHEN "${columnName}" IS NULL THEN NULL
+            WHEN "${columnName}" = '' THEN NULL
+            ELSE CAST("${columnName}" AS NUMERIC)
+          END
+          WHERE "${columnName}" IS NOT NULL
+          AND "${columnName}" != ''
+          AND "${columnName}" ~ '^[0-9]+(\.[0-9]+)?$';
+        `;
+        
+        try {
+          await this.targetPool.query(updateQuery);
+          this.logger.log(`Successfully fixed numeric column ${columnName} in table ${schema}.${tableName}`);
+        } catch (updateError) {
+          this.logger.error(
+            `Error fixing numeric column ${columnName} in table ${schema}.${tableName}: ${updateError.message}`
+          );
+        }
+      }
+      
+      this.logger.log(`Completed processing numeric fields for schema: ${schema}`);
+    } catch (error) {
+      this.logger.error(
+        `Error processing numeric fields for schema ${schema}: ${error.message}`,
+        error.stack
+      );
+    }
+  }
+
+  private async fixEnumFieldsForSchema(schema: string) {
+    this.logger.log(`Processing enum fields for schema: ${schema}`);
+    
+    try {
+      // Get all tables with enum columns in this schema
+      const enumColumnsQuery = `
+        SELECT 
+          c.table_name, 
+          c.column_name,
+          c.udt_name
+        FROM 
+          information_schema.columns c
+        WHERE 
+          c.table_schema = $1
+          AND c.data_type = 'USER-DEFINED'
+          AND c.udt_name LIKE 'enum_%'
+      `;
+      
+      const enumColumnsResult = await this.targetPool.query(enumColumnsQuery, [schema]);
+      
+      // Process each table with enum columns
+      for (const row of enumColumnsResult.rows) {
+        const tableName = row.table_name;
+        const columnName = row.column_name;
+        const enumTypeName = row.udt_name;
+        
+        this.logger.log(`Fixing enum column ${columnName} (${enumTypeName}) in table ${schema}.${tableName}`);
+        
+        // Get the valid enum values
+        const enumValuesQuery = `
+          SELECT e.enumlabel
+          FROM pg_enum e
+          JOIN pg_type t ON e.enumtypid = t.oid
+          WHERE t.typname = $1
+          ORDER BY e.enumsortorder
+        `;
+        
+        const enumValuesResult = await this.targetPool.query(enumValuesQuery, [enumTypeName]);
+        const validEnumValues = enumValuesResult.rows.map(r => r.enumlabel);
+        
+        if (validEnumValues.length === 0) {
+          this.logger.warn(`No enum values found for type ${enumTypeName}. Skipping.`);
+          continue;
+        }
+        
+        this.logger.log(`Valid values for ${enumTypeName}: ${validEnumValues.join(', ')}`);
+        
+        // Get current values in the column
+        const currentValuesQuery = `
+          SELECT DISTINCT "${columnName}" 
+          FROM "${schema}"."${tableName}" 
+          WHERE "${columnName}" IS NOT NULL
+        `;
+        
+        const currentValuesResult = await this.targetPool.query(currentValuesQuery);
+        const currentValues = currentValuesResult.rows.map(r => r[columnName]);
+        
+        // Find invalid values
+        const invalidValues = currentValues.filter(val => !validEnumValues.includes(val));
+        
+        if (invalidValues.length > 0) {
+          this.logger.log(`Found invalid values for enum ${enumTypeName}: ${invalidValues.join(', ')}`);
+          
+          // For each invalid value, try to map it to a valid one or set to NULL
+          for (const invalidValue of invalidValues) {
+            // Try to find a case-insensitive match
+            const matchingValidValue = validEnumValues.find(
+              v => v.toLowerCase() === invalidValue.toLowerCase()
+            );
+            
+            let updateQuery;
+            if (matchingValidValue) {
+              // If we found a case-insensitive match, use it
+              updateQuery = `
+                UPDATE "${schema}"."${tableName}"
+                SET "${columnName}" = $1
+                WHERE "${columnName}" = $2
+              `;
+              await this.targetPool.query(updateQuery, [matchingValidValue, invalidValue]);
+              this.logger.log(`Updated invalid value "${invalidValue}" to "${matchingValidValue}"`);
+            } else {
+              // Otherwise set to NULL or default value
+              updateQuery = `
+                UPDATE "${schema}"."${tableName}"
+                SET "${columnName}" = NULL
+                WHERE "${columnName}" = $1
+              `;
+              await this.targetPool.query(updateQuery, [invalidValue]);
+              this.logger.log(`Set invalid value "${invalidValue}" to NULL`);
+            }
+          }
+        } else {
+          this.logger.log(`No invalid enum values found for ${columnName} in ${schema}.${tableName}`);
+        }
+      }
+      
+      this.logger.log(`Completed processing enum fields for schema: ${schema}`);
+    } catch (error) {
+      this.logger.error(
+        `Error processing enum fields for schema ${schema}: ${error.message}`,
+        error.stack
+      );
+    }
+  }
+
+  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 fixer = new DataTypeFixer();
+      await fixer.fixDataTypes();
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error.message);
+      process.exit(1);
+    }
+  };
+
+  run();
+}

package/src/scripts/fix-enum-values.ts

@@ -0,0 +1,357 @@
+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 EnumFixer {
+  private readonly logger = new Logger("EnumFixer");
+  private readonly pool: pg.Pool;
+  private enumValuesCache: Record<string, string[]> = {};
+  // Fix the type definition to match how it's actually used
+  private mappingsCache: Record<string, string | null> = {};
+  private readonly mappingsFilePath: string;
+
+  constructor(
+    private readonly databaseUrl: string = process.env.DATABASE_URL,
+    private readonly saveMapping: boolean = true
+  ) {
+    this.pool = new pg.Pool({
+      connectionString: this.databaseUrl,
+    });
+
+    // Crear directorio para mappings si no existe
+    const mappingsDir = path.join(process.cwd(), "migration-logs");
+    if (!fs.existsSync(mappingsDir)) {
+      fs.mkdirSync(mappingsDir, { recursive: true });
+    }
+
+    // Archivo para guardar los mappings
+    const timestamp = new Date()
+      .toISOString()
+      .replace(/:/g, "-")
+      .replace(/\..+/, "");
+    this.mappingsFilePath = path.join(
+      mappingsDir,
+      `enum-mappings-${timestamp}.json`
+    );
+
+    // Inicializar archivo de mappings
+    if (this.saveMapping) {
+      this.saveMappings();
+    }
+  }
+
+  async fixEnumValues() {
+    try {
+      this.logger.log("Starting enum values fixing process");
+
+      // Obtener todos los schemas excepto los del sistema
+      const schemas = await this.getSchemas();
+      this.logger.log(`Found ${schemas.length} schemas to process`);
+
+      // Para cada schema, procesar sus campos enum
+      for (const schema of schemas) {
+        await this.fixEnumValuesForSchema(schema);
+      }
+
+      // Guardar los mappings finales
+      if (this.saveMapping) {
+        this.saveMappings();
+        this.logger.log(`Enum mappings saved to: ${this.mappingsFilePath}`);
+      }
+
+      this.logger.log("Enum values fixing completed successfully");
+    } catch (error) {
+      this.logger.error(
+        `Error during enum values fixing: ${error.message}`,
+        error.stack
+      );
+    } finally {
+      await this.cleanup();
+    }
+  }
+
+  private async getSchemas(): Promise<string[]> {
+    const result = await this.pool.query(`
+      SELECT schema_name
+      FROM information_schema.schemata
+      WHERE schema_name NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
+      AND schema_name NOT LIKE 'pg_%'
+    `);
+
+    return result.rows.map((row) => row.schema_name);
+  }
+
+  private async fixEnumValuesForSchema(schema: string) {
+    this.logger.log(`Processing enum fields for schema: ${schema}`);
+
+    try {
+      // Obtener todas las columnas enum en este schema
+      const enumColumnsQuery = `
+        SELECT 
+          c.table_name, 
+          c.column_name,
+          c.udt_name
+        FROM 
+          information_schema.columns c
+        WHERE 
+          c.table_schema = $1
+          AND c.data_type = 'USER-DEFINED'
+          AND c.udt_name LIKE 'enum_%'
+      `;
+
+      const enumColumnsResult = await this.pool.query(enumColumnsQuery, [
+        schema,
+      ]);
+
+      if (enumColumnsResult.rows.length === 0) {
+        this.logger.log(`No enum fields found in schema: ${schema}`);
+        return;
+      }
+
+      this.logger.log(
+        `Found ${enumColumnsResult.rows.length} enum fields in schema: ${schema}`
+      );
+
+      // Procesar cada columna enum
+      for (const row of enumColumnsResult.rows) {
+        const tableName = row.table_name;
+        const columnName = row.column_name;
+        const enumTypeName = row.udt_name;
+
+        await this.fixEnumColumn(schema, tableName, columnName, enumTypeName);
+      }
+
+      this.logger.log(`Completed processing enum fields for schema: ${schema}`);
+    } catch (error) {
+      this.logger.error(
+        `Error processing enum fields for schema ${schema}: ${error.message}`,
+        error.stack
+      );
+    }
+  }
+
+  private async fixEnumColumn(
+    schema: string,
+    tableName: string,
+    columnName: string,
+    enumTypeName: string
+  ) {
+    this.logger.log(
+      `Fixing enum column ${columnName} (${enumTypeName}) in table ${schema}.${tableName}`
+    );
+
+    try {
+      // Obtener los valores válidos para el enum
+      let validEnumValues: string[];
+      if (this.enumValuesCache[enumTypeName]) {
+        validEnumValues = this.enumValuesCache[enumTypeName];
+      } else {
+        validEnumValues = await this.getEnumValues(enumTypeName);
+        this.enumValuesCache[enumTypeName] = validEnumValues;
+      }
+
+      if (validEnumValues.length === 0) {
+        this.logger.warn(
+          `No enum values found for type ${enumTypeName}. Skipping.`
+        );
+        return;
+      }
+
+      this.logger.log(
+        `Valid values for ${enumTypeName}: ${validEnumValues.join(", ")}`
+      );
+
+      // Obtener valores actuales en la columna
+      const currentValuesQuery = `
+        SELECT DISTINCT "${columnName}" 
+        FROM "${schema}"."${tableName}" 
+        WHERE "${columnName}" IS NOT NULL
+      `;
+
+      const currentValuesResult = await this.pool.query(currentValuesQuery);
+      const currentValues = currentValuesResult.rows.map((r) => r[columnName]);
+
+      // Encontrar valores inválidos
+      const invalidValues = currentValues.filter(
+        (val) => !validEnumValues.includes(val)
+      );
+
+      if (invalidValues.length === 0) {
+        this.logger.log(
+          `No invalid values found for enum column ${columnName} in table ${schema}.${tableName}`
+        );
+        return;
+      }
+
+      this.logger.log(
+        `Found ${
+          invalidValues.length
+        } invalid values for enum ${enumTypeName} in ${schema}.${tableName}: ${invalidValues.join(
+          ", "
+        )}`
+      );
+
+      // Para cada valor inválido, intentar mapearlo a uno válido o establecerlo a NULL
+      for (const invalidValue of invalidValues) {
+        // Intentar encontrar un mapping existente
+        const mappingKey = `${enumTypeName}:${invalidValue}`;
+        let mappedValue: string | null = null;
+
+        if (this.mappingsCache[mappingKey]) {
+          mappedValue = this.mappingsCache[mappingKey];
+          this.logger.log(
+            `Using cached mapping for ${invalidValue} -> ${mappedValue}`
+          );
+        } else {
+          // Intentar encontrar una coincidencia sin distinción de mayúsculas/minúsculas
+          const matchingValidValue = validEnumValues.find(
+            (v) => v.toLowerCase() === invalidValue.toLowerCase()
+          );
+
+          if (matchingValidValue) {
+            mappedValue = matchingValidValue;
+            this.logger.log(
+              `Found case-insensitive match for ${invalidValue} -> ${mappedValue}`
+            );
+          } else {
+            // Intentar encontrar una coincidencia parcial
+            const similarValues = validEnumValues.filter(
+              (v) =>
+                v.toLowerCase().includes(invalidValue.toLowerCase()) ||
+                invalidValue.toLowerCase().includes(v.toLowerCase())
+            );
+
+            if (similarValues.length === 1) {
+              mappedValue = similarValues[0];
+              this.logger.log(
+                `Found partial match for ${invalidValue} -> ${mappedValue}`
+              );
+            } else if (similarValues.length > 1) {
+              // Si hay múltiples coincidencias, usar la más cercana por longitud
+              mappedValue = similarValues.reduce((prev, curr) =>
+                Math.abs(curr.length - invalidValue.length) <
+                Math.abs(prev.length - invalidValue.length)
+                  ? curr
+                  : prev
+              );
+              this.logger.log(
+                `Found multiple partial matches for ${invalidValue}, using closest: ${mappedValue}`
+              );
+            } else {
+              // Si no hay coincidencias, usar NULL
+              mappedValue = null;
+              this.logger.log(
+                `No match found for ${invalidValue}, will set to NULL`
+              );
+            }
+          }
+
+          // Guardar el mapping para uso futuro
+          this.mappingsCache[mappingKey] = mappedValue;
+          if (this.saveMapping) {
+            this.saveMappings();
+          }
+        }
+
+        // Actualizar los registros con el valor mapeado usando CAST explícito
+        const updateQuery =
+          mappedValue !== null
+            ? `
+            UPDATE "${schema}"."${tableName}"
+            SET "${columnName}" = CAST($1 AS "${enumTypeName}")
+            WHERE "${columnName}" = $2
+          `
+            : `
+            UPDATE "${schema}"."${tableName}"
+            SET "${columnName}" = NULL
+            WHERE "${columnName}" = $1
+          `;
+
+        const updateParams =
+          mappedValue !== null ? [mappedValue, invalidValue] : [invalidValue];
+
+        const updateResult = await this.pool.query(updateQuery, updateParams);
+
+        this.logger.log(
+          `Updated ${
+            updateResult.rowCount
+          } rows in ${schema}.${tableName} with ${invalidValue} -> ${
+            mappedValue || "NULL"
+          } with explicit CAST`
+        );
+      }
+    } catch (error) {
+      this.logger.error(
+        `Error fixing enum column ${columnName} in table ${schema}.${tableName}: ${error.message}`,
+        error.stack
+      );
+    }
+  }
+
+  private async getEnumValues(enumTypeName: string): Promise<string[]> {
+    try {
+      const enumQuery = `
+        SELECT e.enumlabel
+        FROM pg_enum e
+        JOIN pg_type t ON e.enumtypid = t.oid
+        WHERE t.typname = $1
+        ORDER BY e.enumsortorder
+      `;
+
+      const result = await this.pool.query(enumQuery, [enumTypeName]);
+      return result.rows.map((row) => row.enumlabel);
+    } catch (error) {
+      this.logger.error(
+        `Error getting enum values for ${enumTypeName}: ${error.message}`
+      );
+      return [];
+    }
+  }
+
+  private saveMappings(): void {
+    try {
+      fs.writeFileSync(
+        this.mappingsFilePath,
+        JSON.stringify(this.mappingsCache, null, 2),
+        "utf8"
+      );
+    } catch (error) {
+      this.logger.error(`Error saving enum mappings: ${error.message}`);
+    }
+  }
+
+  private async cleanup() {
+    this.logger.log("Cleaning up database connections");
+    await this.pool.end();
+  }
+}
+
+// Script para ejecutar desde línea de comandos
+if (require.main === module) {
+  const run = async () => {
+    try {
+      // Obtener la URL de la base de datos desde los argumentos o .env
+      const databaseUrl = process.argv[2] || process.env.DATABASE_URL;
+
+      if (!databaseUrl) {
+        console.error(
+          "Error: No database URL provided. Please provide a database URL as an argument or set DATABASE_URL environment variable."
+        );
+        process.exit(1);
+      }
+
+      const enumFixer = new EnumFixer(databaseUrl);
+      await enumFixer.fixEnumValues();
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error.message);
+      process.exit(1);
+    }
+  };
+
+  run();
+}