@javalabs/prisma-client 1.0.18 → 1.0.20

package/src/scripts/retry-failed-migrations.ts

@@ -1,416 +1,416 @@
-import * as fs from "fs";
-import * as path from "path";
-import { PrismaClient } from "@prisma/client";
-import * as dotenv from "dotenv";
-import { Logger } from "@nestjs/common";
-import * as pg from "pg";
-import { MigrationErrorHandler } from "./error-handler";
-
-dotenv.config();
-
-export class FailedMigrationRetry {
-  private readonly logger = new Logger("FailedMigrationRetry");
-  private readonly targetPrisma: PrismaClient;
-  private readonly targetPool: pg.Pool;
-  private readonly errorHandler: MigrationErrorHandler;
-  private schemaCache: Record<string, any> = {};
-
-  constructor(private readonly errorLogPath: string) {
-    // Target database connection
-    this.targetPool = new pg.Pool({
-      connectionString: process.env.DATABASE_URL,
-    });
-
-    // Target Prisma client
-    this.targetPrisma = new PrismaClient({
-      datasources: {
-        db: {
-          url: process.env.DATABASE_URL,
-        },
-      },
-    });
-
-    // Inicializar el manejador de errores
-    this.errorHandler = new MigrationErrorHandler();
-  }
-
-  async retryFailedMigrations() {
-    try {
-      this.logger.log(`Loading error log from: ${this.errorLogPath}`);
-
-      // Cargar el archivo de log de errores
-      if (!fs.existsSync(this.errorLogPath)) {
-        this.logger.error(`Error log file not found: ${this.errorLogPath}`);
-        return;
-      }
-
-      const errorLogContent = fs.readFileSync(this.errorLogPath, "utf8");
-      const errorLog: Record<string, any[]> = JSON.parse(errorLogContent);
-
-      let totalErrors = 0;
-      let retrySuccessCount = 0;
-      let retryFailCount = 0;
-
-      // Procesar cada tenant
-      for (const tenantId in errorLog) {
-        const tenantErrors = errorLog[tenantId];
-        if (tenantErrors.length === 0) continue;
-
-        totalErrors += tenantErrors.length;
-        this.logger.log(
-          `Processing ${tenantErrors.length} errors for tenant: ${tenantId}`
-        );
-
-        // Crear cliente Prisma específico para este tenant
-        const tenantPrisma = new PrismaClient({
-          datasources: {
-            db: {
-              url: `${process.env.DATABASE_URL}?schema=${tenantId}`,
-            },
-          },
-          transactionOptions: {
-            maxWait: 120000,
-            timeout: 120000,
-          },
-        });
-
-        // Procesar cada error
-        for (const errorEntry of tenantErrors) {
-          const { entity, recordId, data } = errorEntry;
-
-          this.logger.log(`Retrying ${entity} with ID ${recordId}`);
-
-          try {
-            // Obtener el esquema de la tabla si no está en caché
-            if (!this.schemaCache[`${tenantId}.${entity}`]) {
-              this.schemaCache[`${tenantId}.${entity}`] =
-                await this.getTableSchema(entity, tenantId);
-            }
-
-            const tableSchema = this.schemaCache[`${tenantId}.${entity}`];
-
-            if (!tableSchema || tableSchema.length === 0) {
-              this.logger.warn(
-                `Schema not found for ${entity} in tenant ${tenantId}. Skipping.`
-              );
-              retryFailCount++;
-              continue;
-            }
-
-            // Preparar los datos para la inserción/actualización
-            const createData: Record<string, any> = {};
-            const updateData: Record<string, any> = {};
-
-            // Obtener la lista de columnas
-            const columnNames = tableSchema.map((col) => col.column_name);
-
-            // Si no tenemos los datos originales, no podemos reintentar
-            if (!data) {
-              this.logger.warn(
-                `No data available for ${entity} with ID ${recordId}. Skipping.`
-              );
-              retryFailCount++;
-              continue;
-            }
-
-            // Procesar cada columna
-            for (const column of tableSchema) {
-              const columnName = column.column_name;
-
-              // Omitir columnas que no están en los datos
-              if (!Object.prototype.hasOwnProperty.call(data, columnName)) {
-                continue;
-              }
-
-              // Manejar tipos especiales
-              if (column.data_type === "numeric" && data[columnName] !== null) {
-                // Convertir a número
-                const numericValue = parseFloat(data[columnName]);
-                if (!isNaN(numericValue)) {
-                  createData[columnName] = numericValue;
-                  updateData[columnName] = numericValue;
-                } else {
-                  createData[columnName] = null;
-                  updateData[columnName] = null;
-                }
-              }
-              // Manejar tipos enum
-              else if (
-                column.data_type === "USER-DEFINED" &&
-                column.udt_name.startsWith("enum_")
-              ) {
-                // Obtener valores válidos para el enum
-                const enumValues = await this.getEnumValues(column.udt_name);
-              
-                // Inicializar _enumTypes si no existe
-                if (!createData._enumTypes) createData._enumTypes = {};
-                if (!updateData._enumTypes) updateData._enumTypes = {};
-              
-                // Siempre guardar el tipo de enum para esta columna
-                createData._enumTypes[columnName] = column.udt_name;
-                updateData._enumTypes[columnName] = column.udt_name;
-              
-                if (data[columnName] === null || data[columnName] === "") {
-                  createData[columnName] = null;
-                  updateData[columnName] = null;
-                }
-                // Si el valor es un string, intentar encontrar una coincidencia en los valores del enum
-                else if (typeof data[columnName] === "string") {
-                  const matchingValue = this.findMatchingEnumValue(
-                    data[columnName],
-                    enumValues
-                  );
-                  if (matchingValue) {
-                    createData[columnName] = matchingValue;
-                    updateData[columnName] = matchingValue;
-                  } else {
-                    // Si no hay coincidencia, usar null
-                    createData[columnName] = null;
-                    updateData[columnName] = null;
-                    this.logger.warn(
-                      `No matching enum value found for ${columnName}="${data[columnName]}" in ${entity}. Using NULL.`
-                    );
-                  }
-                } else {
-                  // Para otros tipos, usar el valor tal cual
-                  const enumValue = data[columnName];
-                  createData[columnName] = data[columnName];
-                  updateData[columnName] = data[columnName];
-                }
-              } else {
-                // Para otros tipos de datos, usar el valor tal cual
-                createData[columnName] = data[columnName];
-                updateData[columnName] = data[columnName];
-              }
-            }
-
-            // Asegurarse de incluir el ID
-            if (columnNames.includes(recordId)) {
-              createData[recordId] = data[recordId];
-            }
-
-            // Ejecutar la operación upsert usando SQL raw en lugar de acceso directo al modelo
-            // Verificar primero si el registro existe
-            const checkExistQuery = `
-              SELECT 1 FROM "${tenantId}"."${entity}" 
-              WHERE "${recordId}" = $1
-              LIMIT 1
-            `;
-
-            const existResult = await this.targetPool.query(checkExistQuery, [
-              data[recordId],
-            ]);
-            const recordExists = existResult.rows.length > 0;
-
-            if (recordExists) {
-              // Construir la consulta UPDATE
-              const updateFields = Object.keys(updateData)
-                .filter((key) => key !== recordId && key !== '_enumTypes') // Excluir el campo ID y _enumTypes
-                .map((key, index) => {
-                  // Aplicar casting explícito para tipos enum
-                  if (updateData._enumTypes && updateData._enumTypes[key]) {
-                    return `"${key}" = $${index + 2}::${updateData._enumTypes[key]}`;
-                  }
-                  return `"${key}" = $${index + 2}`;
-                });
-
-              if (updateFields.length > 0) {
-                const updateQuery = `
-                  UPDATE "${tenantId}"."${entity}"
-                  SET ${updateFields.join(", ")}
-                  WHERE "${recordId}" = $1
-                `;
-
-                const updateValues = [
-                  data[recordId],
-                  ...Object.keys(updateData)
-                    .filter((key) => key !== recordId && key !== '_enumTypes')
-                    .map((key) => updateData[key]),
-                ];
-
-                await this.targetPool.query(updateQuery, updateValues);
-              }
-            } else {
-              // Construir la consulta INSERT
-              const insertFields = Object.keys(createData)
-                .filter(key => key !== '_enumTypes')
-                .map((key) => `"${key}"`);
-              
-              const insertPlaceholders = Object.keys(createData)
-                .filter(key => key !== '_enumTypes')
-                .map((key, index) => {
-                  // Aplicar casting explícito para tipos enum
-                  if (createData._enumTypes && createData._enumTypes[key]) {
-                    return `$${index + 1}::${createData._enumTypes[key]}`;
-                  }
-                  return `$${index + 1}`;
-                });
-
-              const insertQuery = `
-                INSERT INTO "${tenantId}"."${entity}" (${insertFields.join(", ")})
-                VALUES (${insertPlaceholders.join(", ")})
-              `;
-
-              const insertValues = Object.keys(createData)
-                .filter(key => key !== '_enumTypes')
-                .map((key) => createData[key]);
-
-              await this.targetPool.query(insertQuery, insertValues);
-            }
-
-            this.logger.log(
-              `Successfully migrated ${entity} with ID ${recordId}`
-            );
-            retrySuccessCount++;
-          } catch (error) {
-            this.logger.error(
-              `Error retrying ${entity} with ID ${recordId}: ${error.message}`
-            );
-            // Registrar el error en el nuevo log
-            this.errorHandler.logError(tenantId, entity, recordId, error, data);
-            retryFailCount++;
-          }
-        }
-
-        // Cerrar la conexión del cliente tenant
-        await tenantPrisma.$disconnect();
-      }
-
-      // Mostrar resumen
-      this.logger.log(`
-Retry Summary:
-- Total errors: ${totalErrors}
-- Successfully retried: ${retrySuccessCount}
-- Failed retries: ${retryFailCount}
-      `);
-
-      // Generar informe de errores restantes
-      const remainingErrorsReport = this.errorHandler.generateErrorReport();
-      this.logger.log("Remaining Errors Report:\n" + remainingErrorsReport);
-    } catch (error) {
-      this.logger.error(
-        `Error in retry process: ${error.message}`,
-        error.stack
-      );
-    } finally {
-      await this.cleanup();
-    }
-  }
-
-  private async getTableSchema(
-    tableName: string,
-    schemaName: string
-  ): Promise<any[]> {
-    try {
-      const schemaQuery = `
-        SELECT column_name, data_type, column_default, is_nullable, udt_name
-        FROM information_schema.columns
-        WHERE table_name = $1
-        AND table_schema = $2
-        ORDER BY ordinal_position
-      `;
-
-      const result = await this.targetPool.query(schemaQuery, [
-        tableName,
-        schemaName,
-      ]);
-      return result.rows;
-    } catch (error) {
-      this.logger.error(
-        `Error getting schema for table ${tableName} in schema ${schemaName}: ${error.message}`
-      );
-      return [];
-    }
-  }
-
-  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.targetPool.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 findMatchingEnumValue(
-    value: string,
-    enumValues: string[]
-  ): string | null {
-    // Buscar coincidencia exacta
-    if (enumValues.includes(value)) {
-      return value;
-    }
-
-    // Buscar coincidencia sin distinción de mayúsculas/minúsculas
-    const lowerValue = value.toLowerCase();
-    for (const enumValue of enumValues) {
-      if (enumValue.toLowerCase() === lowerValue) {
-        return enumValue;
-      }
-    }
-
-    // Buscar coincidencia parcial
-    const similarValues = enumValues.filter(
-      (v) =>
-        v.toLowerCase().includes(lowerValue) ||
-        lowerValue.includes(v.toLowerCase())
-    );
-
-    if (similarValues.length === 1) {
-      return similarValues[0];
-    } else if (similarValues.length > 1) {
-      // Si hay múltiples coincidencias, usar la más cercana por longitud
-      return similarValues.reduce((prev, curr) =>
-        Math.abs(curr.length - value.length) <
-        Math.abs(prev.length - value.length)
-          ? curr
-          : prev
-      );
-    }
-
-    return null;
-  }
-
-  private async cleanup() {
-    this.logger.log("Cleaning up database connections");
-    await this.targetPrisma.$disconnect();
-    await this.targetPool.end();
-  }
-}
-
-// Script para ejecutar desde línea de comandos
-if (require.main === module) {
-  const run = async () => {
-    try {
-      // Obtener la ruta del archivo de log de errores
-      const errorLogPath = process.argv[2];
-
-      if (!errorLogPath) {
-        console.error(
-          "Error: No error log file path provided. Please provide the path to the error log file."
-        );
-        process.exit(1);
-      }
-
-      const retryTool = new FailedMigrationRetry(errorLogPath);
-      await retryTool.retryFailedMigrations();
-      process.exit(0);
-    } catch (error) {
-      console.error("Error:", error.message);
-      process.exit(1);
-    }
-  };
-
-  run();
-}
+import * as fs from "fs";
+import * as path from "path";
+import { PrismaClient } from "@prisma/client";
+import * as dotenv from "dotenv";
+import { Logger } from "@nestjs/common";
+import * as pg from "pg";
+import { MigrationErrorHandler } from "./error-handler";
+
+dotenv.config();
+
+export class FailedMigrationRetry {
+  private readonly logger = new Logger("FailedMigrationRetry");
+  private readonly targetPrisma: PrismaClient;
+  private readonly targetPool: pg.Pool;
+  private readonly errorHandler: MigrationErrorHandler;
+  private schemaCache: Record<string, any> = {};
+
+  constructor(private readonly errorLogPath: string) {
+    // Target database connection
+    this.targetPool = new pg.Pool({
+      connectionString: process.env.DATABASE_URL,
+    });
+
+    // Target Prisma client
+    this.targetPrisma = new PrismaClient({
+      datasources: {
+        db: {
+          url: process.env.DATABASE_URL,
+        },
+      },
+    });
+
+    // Inicializar el manejador de errores
+    this.errorHandler = new MigrationErrorHandler();
+  }
+
+  async retryFailedMigrations() {
+    try {
+      this.logger.log(`Loading error log from: ${this.errorLogPath}`);
+
+      // Cargar el archivo de log de errores
+      if (!fs.existsSync(this.errorLogPath)) {
+        this.logger.error(`Error log file not found: ${this.errorLogPath}`);
+        return;
+      }
+
+      const errorLogContent = fs.readFileSync(this.errorLogPath, "utf8");
+      const errorLog: Record<string, any[]> = JSON.parse(errorLogContent);
+
+      let totalErrors = 0;
+      let retrySuccessCount = 0;
+      let retryFailCount = 0;
+
+      // Procesar cada tenant
+      for (const tenantId in errorLog) {
+        const tenantErrors = errorLog[tenantId];
+        if (tenantErrors.length === 0) continue;
+
+        totalErrors += tenantErrors.length;
+        this.logger.log(
+          `Processing ${tenantErrors.length} errors for tenant: ${tenantId}`
+        );
+
+        // Crear cliente Prisma específico para este tenant
+        const tenantPrisma = new PrismaClient({
+          datasources: {
+            db: {
+              url: `${process.env.DATABASE_URL}?schema=${tenantId}`,
+            },
+          },
+          transactionOptions: {
+            maxWait: 120000,
+            timeout: 120000,
+          },
+        });
+
+        // Procesar cada error
+        for (const errorEntry of tenantErrors) {
+          const { entity, recordId, data } = errorEntry;
+
+          this.logger.log(`Retrying ${entity} with ID ${recordId}`);
+
+          try {
+            // Obtener el esquema de la tabla si no está en caché
+            if (!this.schemaCache[`${tenantId}.${entity}`]) {
+              this.schemaCache[`${tenantId}.${entity}`] =
+                await this.getTableSchema(entity, tenantId);
+            }
+
+            const tableSchema = this.schemaCache[`${tenantId}.${entity}`];
+
+            if (!tableSchema || tableSchema.length === 0) {
+              this.logger.warn(
+                `Schema not found for ${entity} in tenant ${tenantId}. Skipping.`
+              );
+              retryFailCount++;
+              continue;
+            }
+
+            // Preparar los datos para la inserción/actualización
+            const createData: Record<string, any> = {};
+            const updateData: Record<string, any> = {};
+
+            // Obtener la lista de columnas
+            const columnNames = tableSchema.map((col) => col.column_name);
+
+            // Si no tenemos los datos originales, no podemos reintentar
+            if (!data) {
+              this.logger.warn(
+                `No data available for ${entity} with ID ${recordId}. Skipping.`
+              );
+              retryFailCount++;
+              continue;
+            }
+
+            // Procesar cada columna
+            for (const column of tableSchema) {
+              const columnName = column.column_name;
+
+              // Omitir columnas que no están en los datos
+              if (!Object.prototype.hasOwnProperty.call(data, columnName)) {
+                continue;
+              }
+
+              // Manejar tipos especiales
+              if (column.data_type === "numeric" && data[columnName] !== null) {
+                // Convertir a número
+                const numericValue = parseFloat(data[columnName]);
+                if (!isNaN(numericValue)) {
+                  createData[columnName] = numericValue;
+                  updateData[columnName] = numericValue;
+                } else {
+                  createData[columnName] = null;
+                  updateData[columnName] = null;
+                }
+              }
+              // Manejar tipos enum
+              else if (
+                column.data_type === "USER-DEFINED" &&
+                column.udt_name.startsWith("enum_")
+              ) {
+                // Obtener valores válidos para el enum
+                const enumValues = await this.getEnumValues(column.udt_name);
+              
+                // Inicializar _enumTypes si no existe
+                if (!createData._enumTypes) createData._enumTypes = {};
+                if (!updateData._enumTypes) updateData._enumTypes = {};
+              
+                // Siempre guardar el tipo de enum para esta columna
+                createData._enumTypes[columnName] = column.udt_name;
+                updateData._enumTypes[columnName] = column.udt_name;
+              
+                if (data[columnName] === null || data[columnName] === "") {
+                  createData[columnName] = null;
+                  updateData[columnName] = null;
+                }
+                // Si el valor es un string, intentar encontrar una coincidencia en los valores del enum
+                else if (typeof data[columnName] === "string") {
+                  const matchingValue = this.findMatchingEnumValue(
+                    data[columnName],
+                    enumValues
+                  );
+                  if (matchingValue) {
+                    createData[columnName] = matchingValue;
+                    updateData[columnName] = matchingValue;
+                  } else {
+                    // Si no hay coincidencia, usar null
+                    createData[columnName] = null;
+                    updateData[columnName] = null;
+                    this.logger.warn(
+                      `No matching enum value found for ${columnName}="${data[columnName]}" in ${entity}. Using NULL.`
+                    );
+                  }
+                } else {
+                  // Para otros tipos, usar el valor tal cual
+                  const enumValue = data[columnName];
+                  createData[columnName] = data[columnName];
+                  updateData[columnName] = data[columnName];
+                }
+              } else {
+                // Para otros tipos de datos, usar el valor tal cual
+                createData[columnName] = data[columnName];
+                updateData[columnName] = data[columnName];
+              }
+            }
+
+            // Asegurarse de incluir el ID
+            if (columnNames.includes(recordId)) {
+              createData[recordId] = data[recordId];
+            }
+
+            // Ejecutar la operación upsert usando SQL raw en lugar de acceso directo al modelo
+            // Verificar primero si el registro existe
+            const checkExistQuery = `
+              SELECT 1 FROM "${tenantId}"."${entity}" 
+              WHERE "${recordId}" = $1
+              LIMIT 1
+            `;
+
+            const existResult = await this.targetPool.query(checkExistQuery, [
+              data[recordId],
+            ]);
+            const recordExists = existResult.rows.length > 0;
+
+            if (recordExists) {
+              // Construir la consulta UPDATE
+              const updateFields = Object.keys(updateData)
+                .filter((key) => key !== recordId && key !== '_enumTypes') // Excluir el campo ID y _enumTypes
+                .map((key, index) => {
+                  // Aplicar casting explícito para tipos enum
+                  if (updateData._enumTypes && updateData._enumTypes[key]) {
+                    return `"${key}" = $${index + 2}::${updateData._enumTypes[key]}`;
+                  }
+                  return `"${key}" = $${index + 2}`;
+                });
+
+              if (updateFields.length > 0) {
+                const updateQuery = `
+                  UPDATE "${tenantId}"."${entity}"
+                  SET ${updateFields.join(", ")}
+                  WHERE "${recordId}" = $1
+                `;
+
+                const updateValues = [
+                  data[recordId],
+                  ...Object.keys(updateData)
+                    .filter((key) => key !== recordId && key !== '_enumTypes')
+                    .map((key) => updateData[key]),
+                ];
+
+                await this.targetPool.query(updateQuery, updateValues);
+              }
+            } else {
+              // Construir la consulta INSERT
+              const insertFields = Object.keys(createData)
+                .filter(key => key !== '_enumTypes')
+                .map((key) => `"${key}"`);
+              
+              const insertPlaceholders = Object.keys(createData)
+                .filter(key => key !== '_enumTypes')
+                .map((key, index) => {
+                  // Aplicar casting explícito para tipos enum
+                  if (createData._enumTypes && createData._enumTypes[key]) {
+                    return `$${index + 1}::${createData._enumTypes[key]}`;
+                  }
+                  return `$${index + 1}`;
+                });
+
+              const insertQuery = `
+                INSERT INTO "${tenantId}"."${entity}" (${insertFields.join(", ")})
+                VALUES (${insertPlaceholders.join(", ")})
+              `;
+
+              const insertValues = Object.keys(createData)
+                .filter(key => key !== '_enumTypes')
+                .map((key) => createData[key]);
+
+              await this.targetPool.query(insertQuery, insertValues);
+            }
+
+            this.logger.log(
+              `Successfully migrated ${entity} with ID ${recordId}`
+            );
+            retrySuccessCount++;
+          } catch (error) {
+            this.logger.error(
+              `Error retrying ${entity} with ID ${recordId}: ${error.message}`
+            );
+            // Registrar el error en el nuevo log
+            this.errorHandler.logError(tenantId, entity, recordId, error, data);
+            retryFailCount++;
+          }
+        }
+
+        // Cerrar la conexión del cliente tenant
+        await tenantPrisma.$disconnect();
+      }
+
+      // Mostrar resumen
+      this.logger.log(`
+Retry Summary:
+- Total errors: ${totalErrors}
+- Successfully retried: ${retrySuccessCount}
+- Failed retries: ${retryFailCount}
+      `);
+
+      // Generar informe de errores restantes
+      const remainingErrorsReport = this.errorHandler.generateErrorReport();
+      this.logger.log("Remaining Errors Report:\n" + remainingErrorsReport);
+    } catch (error) {
+      this.logger.error(
+        `Error in retry process: ${error.message}`,
+        error.stack
+      );
+    } finally {
+      await this.cleanup();
+    }
+  }
+
+  private async getTableSchema(
+    tableName: string,
+    schemaName: string
+  ): Promise<any[]> {
+    try {
+      const schemaQuery = `
+        SELECT column_name, data_type, column_default, is_nullable, udt_name
+        FROM information_schema.columns
+        WHERE table_name = $1
+        AND table_schema = $2
+        ORDER BY ordinal_position
+      `;
+
+      const result = await this.targetPool.query(schemaQuery, [
+        tableName,
+        schemaName,
+      ]);
+      return result.rows;
+    } catch (error) {
+      this.logger.error(
+        `Error getting schema for table ${tableName} in schema ${schemaName}: ${error.message}`
+      );
+      return [];
+    }
+  }
+
+  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.targetPool.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 findMatchingEnumValue(
+    value: string,
+    enumValues: string[]
+  ): string | null {
+    // Buscar coincidencia exacta
+    if (enumValues.includes(value)) {
+      return value;
+    }
+
+    // Buscar coincidencia sin distinción de mayúsculas/minúsculas
+    const lowerValue = value.toLowerCase();
+    for (const enumValue of enumValues) {
+      if (enumValue.toLowerCase() === lowerValue) {
+        return enumValue;
+      }
+    }
+
+    // Buscar coincidencia parcial
+    const similarValues = enumValues.filter(
+      (v) =>
+        v.toLowerCase().includes(lowerValue) ||
+        lowerValue.includes(v.toLowerCase())
+    );
+
+    if (similarValues.length === 1) {
+      return similarValues[0];
+    } else if (similarValues.length > 1) {
+      // Si hay múltiples coincidencias, usar la más cercana por longitud
+      return similarValues.reduce((prev, curr) =>
+        Math.abs(curr.length - value.length) <
+        Math.abs(prev.length - value.length)
+          ? curr
+          : prev
+      );
+    }
+
+    return null;
+  }
+
+  private async cleanup() {
+    this.logger.log("Cleaning up database connections");
+    await this.targetPrisma.$disconnect();
+    await this.targetPool.end();
+  }
+}
+
+// Script para ejecutar desde línea de comandos
+if (require.main === module) {
+  const run = async () => {
+    try {
+      // Obtener la ruta del archivo de log de errores
+      const errorLogPath = process.argv[2];
+
+      if (!errorLogPath) {
+        console.error(
+          "Error: No error log file path provided. Please provide the path to the error log file."
+        );
+        process.exit(1);
+      }
+
+      const retryTool = new FailedMigrationRetry(errorLogPath);
+      await retryTool.retryFailedMigrations();
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error.message);
+      process.exit(1);
+    }
+  };
+
+  run();
+}