@javalabs/prisma-client 1.0.16 → 1.0.19

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

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