@javalabs/prisma-client 1.0.0

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

@@ -0,0 +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);
+  });
+}

package/src/scripts/truncate-database.ts

@@ -0,0 +1,124 @@
+import * as pg from "pg";
+import * as dotenv from "dotenv";
+import { Logger } from "@nestjs/common";
+
+dotenv.config();
+
+export class DatabaseTruncateTool {
+  private readonly logger = new Logger("DatabaseTruncateTool");
+  private readonly pool: pg.Pool;
+
+  constructor(private readonly databaseUrl: string) {
+    this.pool = new pg.Pool({
+      connectionString: this.databaseUrl,
+    });
+  }
+
+  async truncateDatabase() {
+    try {
+      this.logger.log("Starting database truncate 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, truncar todas sus tablas
+      for (const schema of schemas) {
+        await this.truncateSchema(schema);
+      }
+
+      this.logger.log("Database has been successfully truncated");
+    } catch (error) {
+      this.logger.error(
+        `Error truncating database: ${error.message}`,
+        error.stack
+      );
+      throw error;
+    } 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 truncateSchema(schemaName: string) {
+    this.logger.log(`Processing schema: ${schemaName}`);
+    
+    try {
+      // Obtener todas las tablas del schema
+      const tablesResult = await this.pool.query(`
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = $1
+        AND table_type = 'BASE TABLE'
+      `, [schemaName]);
+      
+      const tables = tablesResult.rows.map(row => row.table_name);
+      
+      if (tables.length === 0) {
+        this.logger.log(`No tables found in schema ${schemaName}`);
+        return;
+      }
+      
+      this.logger.log(`Found ${tables.length} tables in schema ${schemaName}`);
+      
+      // Desactivar restricciones de clave foránea temporalmente
+      await this.pool.query(`SET session_replication_role = 'replica'`);
+      
+      // Truncar cada tabla
+      for (const table of tables) {
+        try {
+          await this.pool.query(`TRUNCATE TABLE "${schemaName}"."${table}" CASCADE`);
+          this.logger.log(`Truncated table ${schemaName}.${table}`);
+        } catch (tableError) {
+          this.logger.error(`Error truncating table ${schemaName}.${table}: ${tableError.message}`);
+        }
+      }
+      
+      // Reactivar restricciones de clave foránea
+      await this.pool.query(`SET session_replication_role = 'origin'`);
+      
+      this.logger.log(`Successfully processed schema: ${schemaName}`);
+    } catch (error) {
+      this.logger.error(`Error processing schema ${schemaName}: ${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 truncateTool = new DatabaseTruncateTool(databaseUrl);
+      await truncateTool.truncateDatabase();
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error.message);
+      process.exit(1);
+    }
+  };
+
+  run();
+}