@javalabs/prisma-client 1.0.16 → 1.0.19

package/src/scripts/data-migration/schema-utils.ts

@@ -1,248 +1,248 @@
-import { Logger } from "@nestjs/common";
-import { ColumnSchema } from "./types";
-
-export class SchemaUtils {
-  private readonly logger = new Logger("SchemaUtils");
-
-  constructor(private readonly connections: any) {}
-
-  // En el método getTableSchema de SchemaUtils
-  async getTableSchema(
-    tableName: string,
-    dbType: "source" | "target",
-    schema: string = "public"
-  ): Promise<ColumnSchema[]> {
-    const pool =
-      dbType === "source"
-        ? this.connections.sourcePool
-        : this.connections.targetPool;
-
-    const query = `
-      SELECT 
-        c.table_name,
-        c.column_name,
-        c.data_type,
-        c.udt_name,
-        c.character_maximum_length,
-        c.is_nullable,
-        c.column_default,
-        tc.constraint_type
-      FROM 
-        information_schema.columns c
-      LEFT JOIN information_schema.constraint_column_usage ccu 
-        ON c.column_name = ccu.column_name 
-        AND c.table_name = ccu.table_name
-      LEFT JOIN information_schema.table_constraints tc 
-        ON ccu.constraint_name = tc.constraint_name
-      WHERE 
-        c.table_schema = $1 
-        AND c.table_name = $2
-      ORDER BY 
-        c.ordinal_position
-    `;
-
-    try {
-      const result = await pool.query(query, [schema, tableName]);
-      // No transformar los nombres de las columnas, mantener el case original
-      return result.rows;
-    } catch (error) {
-      this.logger.error(
-        `Error getting schema for ${schema}.${tableName}: ${error.message}`
-      );
-      return [];
-    }
-  }
-
-  async checkSchemaExists(schemaName: string): Promise<boolean> {
-    try {
-      const query = `
-        SELECT schema_name 
-        FROM information_schema.schemata 
-        WHERE schema_name = $1
-      `;
-      const result = await this.connections.targetPool.query(query, [
-        schemaName,
-      ]);
-      return result.rows.length > 0;
-    } catch (error) {
-      this.logger.error(`Error checking if schema exists: ${error.message}`);
-      return false;
-    }
-  }
-
-  async getTargetTables(schemaName: string): Promise<string[]> {
-    try {
-      const query = `
-        SELECT table_name 
-        FROM information_schema.tables 
-        WHERE table_schema = $1
-        AND table_type = 'BASE TABLE'
-      `;
-      const result = await this.connections.targetPool.query(query, [
-        schemaName,
-      ]);
-
-      // Log para depuración
-      this.logger.log(
-        `Found ${result.rows.length} tables in schema ${schemaName}`
-      );
-      result.rows.forEach((row) => {
-        this.logger.log(`Table in schema ${schemaName}: ${row.table_name}`);
-      });
-
-      return result.rows.map((row) => row.table_name);
-    } catch (error) {
-      this.logger.error(`Error getting target tables: ${error.message}`);
-      return [];
-    }
-  }
-
-  async getEnumValues(schemaName: string, enumName: string): Promise<string[]> {
-    try {
-      // Consulta para obtener los valores posibles de un enum
-      const query = `
-        SELECT e.enumlabel
-        FROM pg_type t 
-        JOIN pg_enum e ON t.oid = e.enumtypid  
-        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-        WHERE t.typname = $1
-        AND n.nspname = $2
-      `;
-      const result = await this.connections.targetPool.query(query, [
-        enumName,
-        schemaName,
-      ]);
-      return result.rows.map((row) => row.enumlabel);
-    } catch (error) {
-      this.logger.error(
-        `Error getting enum values for ${enumName}: ${error.message}`
-      );
-      return [];
-    }
-  }
-
-  async executeQuery(query: string, params: any[] = []): Promise<any> {
-    return this.connections.targetPool.query(query, params);
-  }
-
-  async queryTargetDb(query: string, params: any[]): Promise<{ rows: any[] }> {
-    return this.connections.targetPool.query(query, params);
-  }
-
-  async createMissingColumns(
-    tableName: string,
-    schema: string,
-    columns: ColumnSchema[]
-  ) {
-    for (const column of columns) {
-      try {
-        const query = `
-          ALTER TABLE "${schema}"."${tableName}"
-          ADD COLUMN IF NOT EXISTS "${column.column_name}" ${column.data_type}
-          ${column.is_nullable === "NO" ? "NOT NULL" : ""}
-          ${column.column_default ? `DEFAULT ${column.column_default}` : ""}
-        `;
-        await this.connections.targetPool.query(query);
-
-        // Add unique constraint if needed
-        if (column.constraint_type === "UNIQUE") {
-          const constraintName = `${tableName}_${column.column_name}_unique`;
-          const uniqueQuery = `
-            DO $$
-            BEGIN
-              IF NOT EXISTS (
-                SELECT 1 FROM pg_constraint WHERE conname = '${constraintName}'
-              ) THEN
-                ALTER TABLE "${schema}"."${tableName}"
-                ADD CONSTRAINT "${constraintName}" UNIQUE ("${column.column_name}");
-              END IF;
-            END $$;
-          `;
-          await this.connections.targetPool.query(uniqueQuery);
-        }
-      } catch (error) {
-        this.logger.error(
-          `Error creating column ${column.column_name}: ${error.message}`
-        );
-        throw error;
-      }
-    }
-  }
-
-  async createSchema(schemaName: string): Promise<void> {
-    try {
-      // Create schema
-      await this.connections.targetPool.query(
-        `CREATE SCHEMA IF NOT EXISTS "${schemaName}"`
-      );
-
-      // Copy table structure from public schema
-      const tables = await this.getPublicTables();
-
-      for (const table of tables) {
-        await this.connections.targetPool.query(`
-          CREATE TABLE IF NOT EXISTS "${schemaName}"."${table}" (
-            LIKE public."${table}" INCLUDING ALL
-          );
-        `);
-      }
-
-      this.logger.log(`Created schema ${schemaName} with all tables`);
-    } catch (error) {
-      this.logger.error(
-        `Error creating schema ${schemaName}: ${error.message}`
-      );
-      throw error;
-    }
-  }
-
-  private async getPublicTables(): Promise<string[]> {
-    const result = await this.connections.targetPool.query(`
-      SELECT tablename 
-      FROM pg_tables 
-      WHERE schemaname = 'public'
-    `);
-    return result.rows.map((row) => row.tablename);
-  }
-
-  async getTableColumns(
-    schema: string,
-    table: string
-  ): Promise<ColumnSchema[]> {
-    const query = `
-      SELECT 
-        column_name,
-        data_type,
-        is_nullable,
-        column_default,
-        character_maximum_length,
-        numeric_precision,
-        numeric_scale
-      FROM information_schema.columns
-      WHERE table_schema = $1
-        AND table_name = $2
-      ORDER BY ordinal_position;
-    `;
-
-    try {
-      const result = await this.connections.sourcePool.query(query, [
-        schema,
-        table,
-      ]);
-      return result.rows.map((row: any) => ({
-        column_name: row.column_name,
-        data_type: row.data_type,
-        is_nullable: row.is_nullable,
-        column_default: row.column_default,
-        character_maximum_length: row.character_maximum_length,
-        numeric_precision: row.numeric_precision,
-        numeric_scale: row.numeric_scale,
-      }));
-    } catch (error) {
-      this.logger.error(
-        `Error obteniendo columnas para ${schema}.${table}: ${error.message}`
-      );
-      throw error;
-    }
-  }
-}
+import { Logger } from "@nestjs/common";
+import { ColumnSchema } from "./types";
+
+export class SchemaUtils {
+  private readonly logger = new Logger("SchemaUtils");
+
+  constructor(private readonly connections: any) {}
+
+  // En el método getTableSchema de SchemaUtils
+  async getTableSchema(
+    tableName: string,
+    dbType: "source" | "target",
+    schema: string = "public"
+  ): Promise<ColumnSchema[]> {
+    const pool =
+      dbType === "source"
+        ? this.connections.sourcePool
+        : this.connections.targetPool;
+
+    const query = `
+      SELECT 
+        c.table_name,
+        c.column_name,
+        c.data_type,
+        c.udt_name,
+        c.character_maximum_length,
+        c.is_nullable,
+        c.column_default,
+        tc.constraint_type
+      FROM 
+        information_schema.columns c
+      LEFT JOIN information_schema.constraint_column_usage ccu 
+        ON c.column_name = ccu.column_name 
+        AND c.table_name = ccu.table_name
+      LEFT JOIN information_schema.table_constraints tc 
+        ON ccu.constraint_name = tc.constraint_name
+      WHERE 
+        c.table_schema = $1 
+        AND c.table_name = $2
+      ORDER BY 
+        c.ordinal_position
+    `;
+
+    try {
+      const result = await pool.query(query, [schema, tableName]);
+      // No transformar los nombres de las columnas, mantener el case original
+      return result.rows;
+    } catch (error) {
+      this.logger.error(
+        `Error getting schema for ${schema}.${tableName}: ${error.message}`
+      );
+      return [];
+    }
+  }
+
+  async checkSchemaExists(schemaName: string): Promise<boolean> {
+    try {
+      const query = `
+        SELECT schema_name 
+        FROM information_schema.schemata 
+        WHERE schema_name = $1
+      `;
+      const result = await this.connections.targetPool.query(query, [
+        schemaName,
+      ]);
+      return result.rows.length > 0;
+    } catch (error) {
+      this.logger.error(`Error checking if schema exists: ${error.message}`);
+      return false;
+    }
+  }
+
+  async getTargetTables(schemaName: string): Promise<string[]> {
+    try {
+      const query = `
+        SELECT table_name 
+        FROM information_schema.tables 
+        WHERE table_schema = $1
+        AND table_type = 'BASE TABLE'
+      `;
+      const result = await this.connections.targetPool.query(query, [
+        schemaName,
+      ]);
+
+      // Log para depuración
+      this.logger.log(
+        `Found ${result.rows.length} tables in schema ${schemaName}`
+      );
+      result.rows.forEach((row) => {
+        this.logger.log(`Table in schema ${schemaName}: ${row.table_name}`);
+      });
+
+      return result.rows.map((row) => row.table_name);
+    } catch (error) {
+      this.logger.error(`Error getting target tables: ${error.message}`);
+      return [];
+    }
+  }
+
+  async getEnumValues(schemaName: string, enumName: string): Promise<string[]> {
+    try {
+      // Consulta para obtener los valores posibles de un enum
+      const query = `
+        SELECT e.enumlabel
+        FROM pg_type t 
+        JOIN pg_enum e ON t.oid = e.enumtypid  
+        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+        WHERE t.typname = $1
+        AND n.nspname = $2
+      `;
+      const result = await this.connections.targetPool.query(query, [
+        enumName,
+        schemaName,
+      ]);
+      return result.rows.map((row) => row.enumlabel);
+    } catch (error) {
+      this.logger.error(
+        `Error getting enum values for ${enumName}: ${error.message}`
+      );
+      return [];
+    }
+  }
+
+  async executeQuery(query: string, params: any[] = []): Promise<any> {
+    return this.connections.targetPool.query(query, params);
+  }
+
+  async queryTargetDb(query: string, params: any[]): Promise<{ rows: any[] }> {
+    return this.connections.targetPool.query(query, params);
+  }
+
+  async createMissingColumns(
+    tableName: string,
+    schema: string,
+    columns: ColumnSchema[]
+  ) {
+    for (const column of columns) {
+      try {
+        const query = `
+          ALTER TABLE "${schema}"."${tableName}"
+          ADD COLUMN IF NOT EXISTS "${column.column_name}" ${column.data_type}
+          ${column.is_nullable === "NO" ? "NOT NULL" : ""}
+          ${column.column_default ? `DEFAULT ${column.column_default}` : ""}
+        `;
+        await this.connections.targetPool.query(query);
+
+        // Add unique constraint if needed
+        if (column.constraint_type === "UNIQUE") {
+          const constraintName = `${tableName}_${column.column_name}_unique`;
+          const uniqueQuery = `
+            DO $$
+            BEGIN
+              IF NOT EXISTS (
+                SELECT 1 FROM pg_constraint WHERE conname = '${constraintName}'
+              ) THEN
+                ALTER TABLE "${schema}"."${tableName}"
+                ADD CONSTRAINT "${constraintName}" UNIQUE ("${column.column_name}");
+              END IF;
+            END $$;
+          `;
+          await this.connections.targetPool.query(uniqueQuery);
+        }
+      } catch (error) {
+        this.logger.error(
+          `Error creating column ${column.column_name}: ${error.message}`
+        );
+        throw error;
+      }
+    }
+  }
+
+  async createSchema(schemaName: string): Promise<void> {
+    try {
+      // Create schema
+      await this.connections.targetPool.query(
+        `CREATE SCHEMA IF NOT EXISTS "${schemaName}"`
+      );
+
+      // Copy table structure from public schema
+      const tables = await this.getPublicTables();
+
+      for (const table of tables) {
+        await this.connections.targetPool.query(`
+          CREATE TABLE IF NOT EXISTS "${schemaName}"."${table}" (
+            LIKE public."${table}" INCLUDING ALL
+          );
+        `);
+      }
+
+      this.logger.log(`Created schema ${schemaName} with all tables`);
+    } catch (error) {
+      this.logger.error(
+        `Error creating schema ${schemaName}: ${error.message}`
+      );
+      throw error;
+    }
+  }
+
+  private async getPublicTables(): Promise<string[]> {
+    const result = await this.connections.targetPool.query(`
+      SELECT tablename 
+      FROM pg_tables 
+      WHERE schemaname = 'public'
+    `);
+    return result.rows.map((row) => row.tablename);
+  }
+
+  async getTableColumns(
+    schema: string,
+    table: string
+  ): Promise<ColumnSchema[]> {
+    const query = `
+      SELECT 
+        column_name,
+        data_type,
+        is_nullable,
+        column_default,
+        character_maximum_length,
+        numeric_precision,
+        numeric_scale
+      FROM information_schema.columns
+      WHERE table_schema = $1
+        AND table_name = $2
+      ORDER BY ordinal_position;
+    `;
+
+    try {
+      const result = await this.connections.sourcePool.query(query, [
+        schema,
+        table,
+      ]);
+      return result.rows.map((row: any) => ({
+        column_name: row.column_name,
+        data_type: row.data_type,
+        is_nullable: row.is_nullable,
+        column_default: row.column_default,
+        character_maximum_length: row.character_maximum_length,
+        numeric_precision: row.numeric_precision,
+        numeric_scale: row.numeric_scale,
+      }));
+    } catch (error) {
+      this.logger.error(
+        `Error obteniendo columnas para ${schema}.${table}: ${error.message}`
+      );
+      throw error;
+    }
+  }
+}