@javalabs/prisma-client 1.0.18 → 1.0.20

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

@@ -1,357 +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();
-}
+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();
+}