@javalabs/prisma-client 1.0.18 → 1.0.19

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

@@ -1,563 +1,563 @@
-import { Logger } from "@nestjs/common";
-import { Pool } from "pg";
-import * as path from "path";
-import * as fs from "fs";
-import * as dotenv from "dotenv";
-
-dotenv.config();
-
-/**
- * Clase para sincronizar valores entre enums específicos y enums consolidados
- * Esta herramienta asegura que los valores en los enums específicos (deprecados)
- * sean compatibles con los enums consolidados durante la migración.
- */
-export class EnumValueSynchronizer {
-  private readonly logger = new Logger("EnumValueSynchronizer");
-  private readonly pool: Pool;
-
-  // Mapeo de enums específicos a enums consolidados
-  private readonly enumMappings: Record<string, string> = {
-    enum_credit_requests_status: "enum_transaction_status",
-    enum_global_user_transactions_status: "enum_transaction_status",
-    enum_global_user_transactions_transaction_type: "enum_transaction_type",
-    enum_invoices_status: "enum_transaction_status",
-    enum_payin_status: "enum_transaction_status",
-    enum_payout_status: "enum_transaction_status",
-    enum_pending_references_status: "enum_transaction_status",
-    enum_toku_status: "enum_transaction_status",
-    enum_transaction_updates_new_status: "enum_transaction_status",
-    enum_transactions_account_type: "enum_account_type",
-    enum_transactions_status: "enum_transaction_status",
-    enum_transactions_transaction_type: "enum_transaction_type",
-    enum_transactions_typetransaction: "enum_transaction_type",
-    enum_transactions_user_type_account: "enum_account_type",
-    enum_transactions_usertypeaccount: "enum_account_type",
-  };
-
-  // Mapeo de valores de texto a valores de enum válidos
-  private readonly valueNormalizationMap: Record<
-    string,
-    Record<string, string>
-  > = {
-    // Mapeos para enum_transaction_status
-    enum_transaction_status: {
-      PENDING: "PENDING",
-      pending: "PENDING",
-      COMPLETED: "COMPLETED",
-      completed: "COMPLETED",
-      FAILED: "FAILED",
-      failed: "FAILED",
-      PROCESSING: "PROCESSING",
-      processing: "PROCESSING",
-      CANCELLED: "CANCELLED",
-      cancelled: "CANCELLED",
-      canceled: "CANCELLED",
-      CANCELED: "CANCELLED",
-      REJECTED: "REJECTED",
-      rejected: "REJECTED",
-      APPROVED: "APPROVED",
-      approved: "APPROVED",
-      EXPIRED: "EXPIRED",
-      expired: "EXPIRED",
-      REFUNDED: "REFUNDED",
-      refunded: "REFUNDED",
-      PARTIAL_REFUND: "PARTIAL_REFUND",
-      partial_refund: "PARTIAL_REFUND",
-    },
-    // Mapeos para enum_transaction_type
-    enum_transaction_type: {
-      DEPOSIT: "DEPOSIT",
-      deposit: "DEPOSIT",
-      WITHDRAWAL: "WITHDRAWAL",
-      withdrawal: "WITHDRAWAL",
-      TRANSFER: "TRANSFER",
-      transfer: "TRANSFER",
-      PAYMENT: "PAYMENT",
-      payment: "PAYMENT",
-      REFUND: "REFUND",
-      refund: "REFUND",
-      FEE: "FEE",
-      fee: "FEE",
-      ADJUSTMENT: "ADJUSTMENT",
-      adjustment: "ADJUSTMENT",
-    },
-    // Mapeos para enum_account_type
-    enum_account_type: {
-      PERSONAL: "PERSONAL",
-      personal: "PERSONAL",
-      BUSINESS: "BUSINESS",
-      business: "BUSINESS",
-      MERCHANT: "MERCHANT",
-      merchant: "MERCHANT",
-      PLATFORM: "PLATFORM",
-      platform: "PLATFORM",
-    },
-  };
-
-  // Caché para valores de enum
-  private enumValuesCache: Record<string, string[]> = {};
-
-  constructor(
-    private readonly sourceUrl: string = process.env.SOURCE_DATABASE_URL,
-    private readonly targetUrl: string = process.env.DATABASE_URL
-  ) {
-    this.pool = new Pool({
-      connectionString: this.targetUrl,
-    });
-  }
-
-  /**
-   * Sincroniza los valores entre enums específicos y enums consolidados
-   * y normaliza los valores de texto a valores de enum válidos
-   */
-  async synchronizeEnumValues() {
-    try {
-      this.logger.log("Iniciando sincronización de valores de enum");
-
-      // Crear directorio para logs si no existe
-      const logsDir = path.join(process.cwd(), "migration-logs");
-      if (!fs.existsSync(logsDir)) {
-        fs.mkdirSync(logsDir, { recursive: true });
-      }
-
-      // Obtener todos los tipos enum en la base de datos
-      const enumsResult = await this.pool.query(`
-        SELECT t.typname AS enum_name
-        FROM pg_type t
-        JOIN pg_namespace n ON t.typnamespace = n.oid
-        WHERE t.typtype = 'e' -- enum types
-        AND n.nspname = 'public'
-        ORDER BY t.typname
-      `);
-
-      this.logger.log(
-        `Encontrados ${enumsResult.rows.length} tipos enum en la base de datos`
-      );
-
-      // Procesar cada enum específico y su correspondiente enum consolidado
-      for (const [specificEnum, consolidatedEnum] of Object.entries(
-        this.enumMappings
-      )) {
-        await this.synchronizeSpecificEnum(specificEnum, consolidatedEnum);
-      }
-
-      // Después de sincronizar los enums, normalizar los valores en las tablas
-      await this.normalizeEnumValuesInTables();
-
-      this.logger.log("Sincronización de valores de enum completada con éxito");
-    } catch (error) {
-      this.logger.error(
-        `Error durante la sincronización de valores de enum: ${error.message}`,
-        error.stack
-      );
-      throw error;
-    } finally {
-      await this.pool.end();
-    }
-  }
-
-  /**
-   * Sincroniza los valores entre un enum específico y su enum consolidado
-   */
-  private async synchronizeSpecificEnum(
-    specificEnum: string,
-    consolidatedEnum: string
-  ) {
-    try {
-      this.logger.log(
-        `Sincronizando valores entre ${specificEnum} y ${consolidatedEnum}`
-      );
-
-      // Verificar si ambos enums existen
-      const specificEnumExists = await this.enumExists(specificEnum);
-      const consolidatedEnumExists = await this.enumExists(consolidatedEnum);
-
-      if (!specificEnumExists || !consolidatedEnumExists) {
-        this.logger.warn(
-          `No se puede sincronizar: ${
-            !specificEnumExists ? specificEnum : consolidatedEnum
-          } no existe`
-        );
-        return;
-      }
-
-      // Obtener valores de ambos enums
-      const specificValues = await this.getEnumValues(specificEnum);
-      const consolidatedValues = await this.getEnumValues(consolidatedEnum);
-
-      this.logger.log(
-        `Valores en ${specificEnum}: ${specificValues.join(", ")}\n` +
-          `Valores en ${consolidatedEnum}: ${consolidatedValues.join(", ")}`
-      );
-
-      // Verificar valores que están en el enum específico pero no en el consolidado
-      const missingValues = specificValues.filter(
-        (value) => !consolidatedValues.includes(value)
-      );
-
-      if (missingValues.length === 0) {
-        this.logger.log(
-          `No hay valores faltantes entre ${specificEnum} y ${consolidatedEnum}`
-        );
-        return;
-      }
-
-      this.logger.log(
-        `Encontrados ${
-          missingValues.length
-        } valores en ${specificEnum} que faltan en ${consolidatedEnum}: ${missingValues.join(
-          ", "
-        )}`
-      );
-
-      // Agregar los valores faltantes al enum consolidado
-      for (const value of missingValues) {
-        await this.addValueToEnum(consolidatedEnum, value);
-      }
-
-      this.logger.log(
-        `Sincronización entre ${specificEnum} y ${consolidatedEnum} completada`
-      );
-    } catch (error) {
-      this.logger.error(
-        `Error sincronizando ${specificEnum} con ${consolidatedEnum}: ${error.message}`
-      );
-    }
-  }
-
-  /**
-   * Verifica si un enum existe en la base de datos
-   */
-  private async enumExists(enumName: string): Promise<boolean> {
-    const result = await this.pool.query(
-      `
-      SELECT 1
-      FROM pg_type t
-      JOIN pg_namespace n ON t.typnamespace = n.oid
-      WHERE t.typname = $1
-      AND t.typtype = 'e' -- enum types
-      AND n.nspname = 'public'
-    `,
-      [enumName]
-    );
-
-    return result.rows.length > 0;
-  }
-
-  /**
-   * Obtiene los valores de un enum
-   */
-  private async getEnumValues(enumName: string): Promise<string[]> {
-    const result = await this.pool.query(
-      `
-      SELECT e.enumlabel
-      FROM pg_enum e
-      JOIN pg_type t ON e.enumtypid = t.oid
-      JOIN pg_namespace n ON t.typnamespace = n.oid
-      WHERE t.typname = $1
-      AND n.nspname = 'public'
-      ORDER BY e.enumsortorder
-    `,
-      [enumName]
-    );
-
-    return result.rows.map((row) => row.enumlabel);
-  }
-
-  /**
-   * Agrega un valor a un enum existente
-   */
-  private async addValueToEnum(enumName: string, value: string) {
-    try {
-      // Escapar comillas simples en el valor
-      const escapedValue = value.replace(/'/g, "''");
-
-      // Agregar el valor al enum
-      await this.pool.query(`
-        ALTER TYPE ${enumName} ADD VALUE IF NOT EXISTS '${escapedValue}'
-      `);
-
-      // Actualizar la caché de valores de enum
-      if (this.enumValuesCache[enumName]) {
-        if (!this.enumValuesCache[enumName].includes(value)) {
-          this.enumValuesCache[enumName].push(value);
-        }
-      }
-
-      this.logger.log(`Valor '${value}' agregado al enum ${enumName}`);
-    } catch (error) {
-      this.logger.error(
-        `Error agregando valor '${value}' al enum ${enumName}: ${error.message}`
-      );
-      throw error;
-    }
-  }
-
-  /**
-   * Normaliza los valores de enum en todas las tablas
-   */
-  private async normalizeEnumValuesInTables() {
-    this.logger.log("Iniciando normalización de valores de enum en tablas");
-
-    try {
-      // Obtener todos los schemas excepto los del sistema
-      const schemas = await this.getSchemas();
-      this.logger.log(`Encontrados ${schemas.length} schemas para procesar`);
-
-      // Para cada schema, normalizar los valores de enum en sus tablas
-      for (const schema of schemas) {
-        await this.normalizeEnumValuesInSchema(schema);
-      }
-
-      this.logger.log("Normalización de valores de enum en tablas completada");
-    } catch (error) {
-      this.logger.error(
-        `Error durante la normalización de valores de enum: ${error.message}`,
-        error.stack
-      );
-    }
-  }
-
-  /**
-   * Obtiene todos los schemas de la base de datos excepto los del sistema
-   */
-  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);
-  }
-
-  /**
-   * Normaliza los valores de enum en un schema específico
-   */
-  private async normalizeEnumValuesInSchema(schema: string) {
-    this.logger.log(`Procesando valores de enum en 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 se encontraron columnas enum en schema: ${schema}`);
-        return;
-      }
-
-      this.logger.log(
-        `Encontradas ${enumColumnsResult.rows.length} columnas enum en 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.normalizeEnumColumn(
-          schema,
-          tableName,
-          columnName,
-          enumTypeName
-        );
-      }
-
-      this.logger.log(
-        `Completado procesamiento de valores enum para schema: ${schema}`
-      );
-    } catch (error) {
-      this.logger.error(
-        `Error procesando valores enum para schema ${schema}: ${error.message}`,
-        error.stack
-      );
-    }
-  }
-
-  /**
-   * Normaliza los valores en una columna enum específica
-   */
-  private async normalizeEnumColumn(
-    schema: string,
-    tableName: string,
-    columnName: string,
-    enumTypeName: string
-  ) {
-    this.logger.log(
-      `Normalizando columna enum ${columnName} (${enumTypeName}) en tabla ${schema}.${tableName}`
-    );
-
-    try {
-      // Obtener los valores válidos para el enum si no están en caché
-      if (!this.enumValuesCache[enumTypeName]) {
-        this.enumValuesCache[enumTypeName] = await this.getEnumValues(
-          enumTypeName
-        );
-      }
-      const validEnumValues = this.enumValuesCache[enumTypeName];
-
-      if (validEnumValues.length === 0) {
-        this.logger.warn(
-          `No se encontraron valores para el enum ${enumTypeName}. Omitiendo.`
-        );
-        return;
-      }
-
-      // 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 se encontraron valores inválidos para columna enum ${columnName} en tabla ${schema}.${tableName}`
-        );
-        return;
-      }
-
-      this.logger.log(
-        `Encontrados ${
-          invalidValues.length
-        } valores inválidos para enum ${enumTypeName} en ${schema}.${tableName}: ${invalidValues.join(
-          ", "
-        )}`
-      );
-
-      // Para cada valor inválido, intentar normalizarlo
-      for (const invalidValue of invalidValues) {
-        const normalizedValue = this.getNormalizedEnumValue(
-          enumTypeName,
-          invalidValue
-        );
-
-        if (normalizedValue && normalizedValue !== invalidValue) {
-          // Actualizar los registros con el valor normalizado
-          const updateQuery = `
-            UPDATE "${schema}"."${tableName}"
-            SET "${columnName}" = $1
-            WHERE "${columnName}" = $2
-          `;
-
-          const result = await this.pool.query(updateQuery, [
-            normalizedValue,
-            invalidValue,
-          ]);
-
-          this.logger.log(
-            `Actualizado valor '${invalidValue}' a '${normalizedValue}' en ${result.rowCount} filas de ${schema}.${tableName}.${columnName}`
-          );
-
-          // Si el valor normalizado no está en el enum, agregarlo
-          if (!validEnumValues.includes(normalizedValue)) {
-            await this.addValueToEnum(enumTypeName, normalizedValue);
-          }
-        } else if (!normalizedValue) {
-          // Si no se puede normalizar, establecer a NULL
-          const updateQuery = `
-            UPDATE "${schema}"."${tableName}"
-            SET "${columnName}" = NULL
-            WHERE "${columnName}" = $1
-          `;
-
-          const result = await this.pool.query(updateQuery, [invalidValue]);
-
-          this.logger.log(
-            `Establecido valor '${invalidValue}' a NULL en ${result.rowCount} filas de ${schema}.${tableName}.${columnName}`
-          );
-        }
-      }
-    } catch (error) {
-      this.logger.error(
-        `Error normalizando columna enum ${columnName} en ${schema}.${tableName}: ${error.message}`,
-        error.stack
-      );
-    }
-  }
-
-  /**
-   * Obtiene un valor de enum normalizado basado en mapeos predefinidos
-   */
-  private getNormalizedEnumValue(
-    enumTypeName: string,
-    value: string
-  ): string | null {
-    // Si el valor ya es válido, devolverlo tal cual
-    if (this.enumValuesCache[enumTypeName]?.includes(value)) {
-      return value;
-    }
-
-    // Buscar en el mapa de normalización
-    if (
-      this.valueNormalizationMap[enumTypeName] &&
-      this.valueNormalizationMap[enumTypeName][value]
-    ) {
-      return this.valueNormalizationMap[enumTypeName][value];
-    }
-
-    // Intentar normalizar basado en similitud (convertir a mayúsculas, quitar espacios, etc.)
-    const normalizedInput = value.toUpperCase().replace(/\s+/g, "_");
-
-    // Verificar si la versión normalizada existe en el mapa
-    if (
-      this.valueNormalizationMap[enumTypeName] &&
-      this.valueNormalizationMap[enumTypeName][normalizedInput]
-    ) {
-      return this.valueNormalizationMap[enumTypeName][normalizedInput];
-    }
-
-    // Buscar coincidencias parciales en los valores válidos
-    const validValues = this.enumValuesCache[enumTypeName] || [];
-    for (const validValue of validValues) {
-      // Comparar ignorando mayúsculas/minúsculas
-      if (validValue.toLowerCase() === value.toLowerCase()) {
-        return validValue;
-      }
-    }
-
-    // Si no se encuentra coincidencia, devolver null
-    return null;
-  }
-}
-
-// Ejecutar el script si se llama directamente
-if (require.main === module) {
-  const run = async () => {
-    const synchronizer = new EnumValueSynchronizer(
-      process.env.SOURCE_DATABASE_URL,
-      process.env.DATABASE_URL
-    );
-    await synchronizer.synchronizeEnumValues();
-  };
-
-  run().catch((error) => {
-    console.error("Error ejecutando sincronización de valores de enum:", error);
-    process.exit(1);
-  });
-}
+import { Logger } from "@nestjs/common";
+import { Pool } from "pg";
+import * as path from "path";
+import * as fs from "fs";
+import * as dotenv from "dotenv";
+
+dotenv.config();
+
+/**
+ * Clase para sincronizar valores entre enums específicos y enums consolidados
+ * Esta herramienta asegura que los valores en los enums específicos (deprecados)
+ * sean compatibles con los enums consolidados durante la migración.
+ */
+export class EnumValueSynchronizer {
+  private readonly logger = new Logger("EnumValueSynchronizer");
+  private readonly pool: Pool;
+
+  // Mapeo de enums específicos a enums consolidados
+  private readonly enumMappings: Record<string, string> = {
+    enum_credit_requests_status: "enum_transaction_status",
+    enum_global_user_transactions_status: "enum_transaction_status",
+    enum_global_user_transactions_transaction_type: "enum_transaction_type",
+    enum_invoices_status: "enum_transaction_status",
+    enum_payin_status: "enum_transaction_status",
+    enum_payout_status: "enum_transaction_status",
+    enum_pending_references_status: "enum_transaction_status",
+    enum_toku_status: "enum_transaction_status",
+    enum_transaction_updates_new_status: "enum_transaction_status",
+    enum_transactions_account_type: "enum_account_type",
+    enum_transactions_status: "enum_transaction_status",
+    enum_transactions_transaction_type: "enum_transaction_type",
+    enum_transactions_typetransaction: "enum_transaction_type",
+    enum_transactions_user_type_account: "enum_account_type",
+    enum_transactions_usertypeaccount: "enum_account_type",
+  };
+
+  // Mapeo de valores de texto a valores de enum válidos
+  private readonly valueNormalizationMap: Record<
+    string,
+    Record<string, string>
+  > = {
+    // Mapeos para enum_transaction_status
+    enum_transaction_status: {
+      PENDING: "PENDING",
+      pending: "PENDING",
+      COMPLETED: "COMPLETED",
+      completed: "COMPLETED",
+      FAILED: "FAILED",
+      failed: "FAILED",
+      PROCESSING: "PROCESSING",
+      processing: "PROCESSING",
+      CANCELLED: "CANCELLED",
+      cancelled: "CANCELLED",
+      canceled: "CANCELLED",
+      CANCELED: "CANCELLED",
+      REJECTED: "REJECTED",
+      rejected: "REJECTED",
+      APPROVED: "APPROVED",
+      approved: "APPROVED",
+      EXPIRED: "EXPIRED",
+      expired: "EXPIRED",
+      REFUNDED: "REFUNDED",
+      refunded: "REFUNDED",
+      PARTIAL_REFUND: "PARTIAL_REFUND",
+      partial_refund: "PARTIAL_REFUND",
+    },
+    // Mapeos para enum_transaction_type
+    enum_transaction_type: {
+      DEPOSIT: "DEPOSIT",
+      deposit: "DEPOSIT",
+      WITHDRAWAL: "WITHDRAWAL",
+      withdrawal: "WITHDRAWAL",
+      TRANSFER: "TRANSFER",
+      transfer: "TRANSFER",
+      PAYMENT: "PAYMENT",
+      payment: "PAYMENT",
+      REFUND: "REFUND",
+      refund: "REFUND",
+      FEE: "FEE",
+      fee: "FEE",
+      ADJUSTMENT: "ADJUSTMENT",
+      adjustment: "ADJUSTMENT",
+    },
+    // Mapeos para enum_account_type
+    enum_account_type: {
+      PERSONAL: "PERSONAL",
+      personal: "PERSONAL",
+      BUSINESS: "BUSINESS",
+      business: "BUSINESS",
+      MERCHANT: "MERCHANT",
+      merchant: "MERCHANT",
+      PLATFORM: "PLATFORM",
+      platform: "PLATFORM",
+    },
+  };
+
+  // Caché para valores de enum
+  private enumValuesCache: Record<string, string[]> = {};
+
+  constructor(
+    private readonly sourceUrl: string = process.env.SOURCE_DATABASE_URL,
+    private readonly targetUrl: string = process.env.DATABASE_URL
+  ) {
+    this.pool = new Pool({
+      connectionString: this.targetUrl,
+    });
+  }
+
+  /**
+   * Sincroniza los valores entre enums específicos y enums consolidados
+   * y normaliza los valores de texto a valores de enum válidos
+   */
+  async synchronizeEnumValues() {
+    try {
+      this.logger.log("Iniciando sincronización de valores de enum");
+
+      // Crear directorio para logs si no existe
+      const logsDir = path.join(process.cwd(), "migration-logs");
+      if (!fs.existsSync(logsDir)) {
+        fs.mkdirSync(logsDir, { recursive: true });
+      }
+
+      // Obtener todos los tipos enum en la base de datos
+      const enumsResult = await this.pool.query(`
+        SELECT t.typname AS enum_name
+        FROM pg_type t
+        JOIN pg_namespace n ON t.typnamespace = n.oid
+        WHERE t.typtype = 'e' -- enum types
+        AND n.nspname = 'public'
+        ORDER BY t.typname
+      `);
+
+      this.logger.log(
+        `Encontrados ${enumsResult.rows.length} tipos enum en la base de datos`
+      );
+
+      // Procesar cada enum específico y su correspondiente enum consolidado
+      for (const [specificEnum, consolidatedEnum] of Object.entries(
+        this.enumMappings
+      )) {
+        await this.synchronizeSpecificEnum(specificEnum, consolidatedEnum);
+      }
+
+      // Después de sincronizar los enums, normalizar los valores en las tablas
+      await this.normalizeEnumValuesInTables();
+
+      this.logger.log("Sincronización de valores de enum completada con éxito");
+    } catch (error) {
+      this.logger.error(
+        `Error durante la sincronización de valores de enum: ${error.message}`,
+        error.stack
+      );
+      throw error;
+    } finally {
+      await this.pool.end();
+    }
+  }
+
+  /**
+   * Sincroniza los valores entre un enum específico y su enum consolidado
+   */
+  private async synchronizeSpecificEnum(
+    specificEnum: string,
+    consolidatedEnum: string
+  ) {
+    try {
+      this.logger.log(
+        `Sincronizando valores entre ${specificEnum} y ${consolidatedEnum}`
+      );
+
+      // Verificar si ambos enums existen
+      const specificEnumExists = await this.enumExists(specificEnum);
+      const consolidatedEnumExists = await this.enumExists(consolidatedEnum);
+
+      if (!specificEnumExists || !consolidatedEnumExists) {
+        this.logger.warn(
+          `No se puede sincronizar: ${
+            !specificEnumExists ? specificEnum : consolidatedEnum
+          } no existe`
+        );
+        return;
+      }
+
+      // Obtener valores de ambos enums
+      const specificValues = await this.getEnumValues(specificEnum);
+      const consolidatedValues = await this.getEnumValues(consolidatedEnum);
+
+      this.logger.log(
+        `Valores en ${specificEnum}: ${specificValues.join(", ")}\n` +
+          `Valores en ${consolidatedEnum}: ${consolidatedValues.join(", ")}`
+      );
+
+      // Verificar valores que están en el enum específico pero no en el consolidado
+      const missingValues = specificValues.filter(
+        (value) => !consolidatedValues.includes(value)
+      );
+
+      if (missingValues.length === 0) {
+        this.logger.log(
+          `No hay valores faltantes entre ${specificEnum} y ${consolidatedEnum}`
+        );
+        return;
+      }
+
+      this.logger.log(
+        `Encontrados ${
+          missingValues.length
+        } valores en ${specificEnum} que faltan en ${consolidatedEnum}: ${missingValues.join(
+          ", "
+        )}`
+      );
+
+      // Agregar los valores faltantes al enum consolidado
+      for (const value of missingValues) {
+        await this.addValueToEnum(consolidatedEnum, value);
+      }
+
+      this.logger.log(
+        `Sincronización entre ${specificEnum} y ${consolidatedEnum} completada`
+      );
+    } catch (error) {
+      this.logger.error(
+        `Error sincronizando ${specificEnum} con ${consolidatedEnum}: ${error.message}`
+      );
+    }
+  }
+
+  /**
+   * Verifica si un enum existe en la base de datos
+   */
+  private async enumExists(enumName: string): Promise<boolean> {
+    const result = await this.pool.query(
+      `
+      SELECT 1
+      FROM pg_type t
+      JOIN pg_namespace n ON t.typnamespace = n.oid
+      WHERE t.typname = $1
+      AND t.typtype = 'e' -- enum types
+      AND n.nspname = 'public'
+    `,
+      [enumName]
+    );
+
+    return result.rows.length > 0;
+  }
+
+  /**
+   * Obtiene los valores de un enum
+   */
+  private async getEnumValues(enumName: string): Promise<string[]> {
+    const result = await this.pool.query(
+      `
+      SELECT e.enumlabel
+      FROM pg_enum e
+      JOIN pg_type t ON e.enumtypid = t.oid
+      JOIN pg_namespace n ON t.typnamespace = n.oid
+      WHERE t.typname = $1
+      AND n.nspname = 'public'
+      ORDER BY e.enumsortorder
+    `,
+      [enumName]
+    );
+
+    return result.rows.map((row) => row.enumlabel);
+  }
+
+  /**
+   * Agrega un valor a un enum existente
+   */
+  private async addValueToEnum(enumName: string, value: string) {
+    try {
+      // Escapar comillas simples en el valor
+      const escapedValue = value.replace(/'/g, "''");
+
+      // Agregar el valor al enum
+      await this.pool.query(`
+        ALTER TYPE ${enumName} ADD VALUE IF NOT EXISTS '${escapedValue}'
+      `);
+
+      // Actualizar la caché de valores de enum
+      if (this.enumValuesCache[enumName]) {
+        if (!this.enumValuesCache[enumName].includes(value)) {
+          this.enumValuesCache[enumName].push(value);
+        }
+      }
+
+      this.logger.log(`Valor '${value}' agregado al enum ${enumName}`);
+    } catch (error) {
+      this.logger.error(
+        `Error agregando valor '${value}' al enum ${enumName}: ${error.message}`
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Normaliza los valores de enum en todas las tablas
+   */
+  private async normalizeEnumValuesInTables() {
+    this.logger.log("Iniciando normalización de valores de enum en tablas");
+
+    try {
+      // Obtener todos los schemas excepto los del sistema
+      const schemas = await this.getSchemas();
+      this.logger.log(`Encontrados ${schemas.length} schemas para procesar`);
+
+      // Para cada schema, normalizar los valores de enum en sus tablas
+      for (const schema of schemas) {
+        await this.normalizeEnumValuesInSchema(schema);
+      }
+
+      this.logger.log("Normalización de valores de enum en tablas completada");
+    } catch (error) {
+      this.logger.error(
+        `Error durante la normalización de valores de enum: ${error.message}`,
+        error.stack
+      );
+    }
+  }
+
+  /**
+   * Obtiene todos los schemas de la base de datos excepto los del sistema
+   */
+  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);
+  }
+
+  /**
+   * Normaliza los valores de enum en un schema específico
+   */
+  private async normalizeEnumValuesInSchema(schema: string) {
+    this.logger.log(`Procesando valores de enum en 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 se encontraron columnas enum en schema: ${schema}`);
+        return;
+      }
+
+      this.logger.log(
+        `Encontradas ${enumColumnsResult.rows.length} columnas enum en 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.normalizeEnumColumn(
+          schema,
+          tableName,
+          columnName,
+          enumTypeName
+        );
+      }
+
+      this.logger.log(
+        `Completado procesamiento de valores enum para schema: ${schema}`
+      );
+    } catch (error) {
+      this.logger.error(
+        `Error procesando valores enum para schema ${schema}: ${error.message}`,
+        error.stack
+      );
+    }
+  }
+
+  /**
+   * Normaliza los valores en una columna enum específica
+   */
+  private async normalizeEnumColumn(
+    schema: string,
+    tableName: string,
+    columnName: string,
+    enumTypeName: string
+  ) {
+    this.logger.log(
+      `Normalizando columna enum ${columnName} (${enumTypeName}) en tabla ${schema}.${tableName}`
+    );
+
+    try {
+      // Obtener los valores válidos para el enum si no están en caché
+      if (!this.enumValuesCache[enumTypeName]) {
+        this.enumValuesCache[enumTypeName] = await this.getEnumValues(
+          enumTypeName
+        );
+      }
+      const validEnumValues = this.enumValuesCache[enumTypeName];
+
+      if (validEnumValues.length === 0) {
+        this.logger.warn(
+          `No se encontraron valores para el enum ${enumTypeName}. Omitiendo.`
+        );
+        return;
+      }
+
+      // 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 se encontraron valores inválidos para columna enum ${columnName} en tabla ${schema}.${tableName}`
+        );
+        return;
+      }
+
+      this.logger.log(
+        `Encontrados ${
+          invalidValues.length
+        } valores inválidos para enum ${enumTypeName} en ${schema}.${tableName}: ${invalidValues.join(
+          ", "
+        )}`
+      );
+
+      // Para cada valor inválido, intentar normalizarlo
+      for (const invalidValue of invalidValues) {
+        const normalizedValue = this.getNormalizedEnumValue(
+          enumTypeName,
+          invalidValue
+        );
+
+        if (normalizedValue && normalizedValue !== invalidValue) {
+          // Actualizar los registros con el valor normalizado
+          const updateQuery = `
+            UPDATE "${schema}"."${tableName}"
+            SET "${columnName}" = $1
+            WHERE "${columnName}" = $2
+          `;
+
+          const result = await this.pool.query(updateQuery, [
+            normalizedValue,
+            invalidValue,
+          ]);
+
+          this.logger.log(
+            `Actualizado valor '${invalidValue}' a '${normalizedValue}' en ${result.rowCount} filas de ${schema}.${tableName}.${columnName}`
+          );
+
+          // Si el valor normalizado no está en el enum, agregarlo
+          if (!validEnumValues.includes(normalizedValue)) {
+            await this.addValueToEnum(enumTypeName, normalizedValue);
+          }
+        } else if (!normalizedValue) {
+          // Si no se puede normalizar, establecer a NULL
+          const updateQuery = `
+            UPDATE "${schema}"."${tableName}"
+            SET "${columnName}" = NULL
+            WHERE "${columnName}" = $1
+          `;
+
+          const result = await this.pool.query(updateQuery, [invalidValue]);
+
+          this.logger.log(
+            `Establecido valor '${invalidValue}' a NULL en ${result.rowCount} filas de ${schema}.${tableName}.${columnName}`
+          );
+        }
+      }
+    } catch (error) {
+      this.logger.error(
+        `Error normalizando columna enum ${columnName} en ${schema}.${tableName}: ${error.message}`,
+        error.stack
+      );
+    }
+  }
+
+  /**
+   * Obtiene un valor de enum normalizado basado en mapeos predefinidos
+   */
+  private getNormalizedEnumValue(
+    enumTypeName: string,
+    value: string
+  ): string | null {
+    // Si el valor ya es válido, devolverlo tal cual
+    if (this.enumValuesCache[enumTypeName]?.includes(value)) {
+      return value;
+    }
+
+    // Buscar en el mapa de normalización
+    if (
+      this.valueNormalizationMap[enumTypeName] &&
+      this.valueNormalizationMap[enumTypeName][value]
+    ) {
+      return this.valueNormalizationMap[enumTypeName][value];
+    }
+
+    // Intentar normalizar basado en similitud (convertir a mayúsculas, quitar espacios, etc.)
+    const normalizedInput = value.toUpperCase().replace(/\s+/g, "_");
+
+    // Verificar si la versión normalizada existe en el mapa
+    if (
+      this.valueNormalizationMap[enumTypeName] &&
+      this.valueNormalizationMap[enumTypeName][normalizedInput]
+    ) {
+      return this.valueNormalizationMap[enumTypeName][normalizedInput];
+    }
+
+    // Buscar coincidencias parciales en los valores válidos
+    const validValues = this.enumValuesCache[enumTypeName] || [];
+    for (const validValue of validValues) {
+      // Comparar ignorando mayúsculas/minúsculas
+      if (validValue.toLowerCase() === value.toLowerCase()) {
+        return validValue;
+      }
+    }
+
+    // Si no se encuentra coincidencia, devolver null
+    return null;
+  }
+}
+
+// Ejecutar el script si se llama directamente
+if (require.main === module) {
+  const run = async () => {
+    const synchronizer = new EnumValueSynchronizer(
+      process.env.SOURCE_DATABASE_URL,
+      process.env.DATABASE_URL
+    );
+    await synchronizer.synchronizeEnumValues();
+  };
+
+  run().catch((error) => {
+    console.error("Error ejecutando sincronización de valores de enum:", error);
+    process.exit(1);
+  });
+}