@javalabs/prisma-client 1.0.18 → 1.0.20

package/src/scripts/data-migration/entity-discovery.ts

@@ -1,197 +1,197 @@
-import { Logger } from "@nestjs/common";
-import { Pool } from "pg";
-import { EntityType } from "./types";
-
-export class EntityDiscovery {
-  private readonly logger = new Logger("EntityDiscovery");
-
-  constructor(private readonly targetPool: Pool) {}
-
-  async discoverEntityTypes(
-    schemaName: string,
-    tables: string[]
-  ): Promise<EntityType[]> {
-    try {
-      const entityTypes: EntityType[] = [];
-      
-      for (const tableName of tables) {
-        // Obtener la clave primaria de la tabla
-        const primaryKey = await this.getPrimaryKey(schemaName, tableName);
-        
-        if (!primaryKey) {
-          this.logger.warn(`No primary key found for table ${tableName}, skipping`);
-          continue;
-        }
-        
-        // Obtener las claves foráneas que podrían conectar con un proveedor
-        const foreignKeys = await this.getForeignKeys(schemaName, tableName);
-        
-        // Buscar una clave foránea que podría ser provider_id
-        const providerForeignKey = foreignKeys.find(fk => 
-          fk.column_name.includes('provider_id') || 
-          fk.foreign_table_name === 'providers'
-        );
-        
-        // Crear la entidad
-        const entity: EntityType = {
-          name: tableName,
-          idField: primaryKey,
-          foreignKey: providerForeignKey?.column_name,
-        };
-        
-        // Si no hay una clave foránea directa a providers, buscar relaciones indirectas
-        if (!entity.foreignKey) {
-          // Buscar tablas de unión que podrían conectar esta tabla con providers
-          const joinTables = await this.findJoinTables(
-            schemaName, 
-            tableName, 
-            'providers'
-          );
-          
-          if (joinTables.length > 0) {
-            const joinTable = joinTables[0];
-            entity.joinTable = joinTable.join_table;
-            entity.joinField = joinTable.source_column;
-            entity.joinForeignKey = joinTable.target_column;
-          }
-        }
-        
-        entityTypes.push(entity);
-      }
-      
-      return entityTypes;
-    } catch (error) {
-      this.logger.error(`Error discovering entity types: ${error.message}`);
-      return [];
-    }
-  }
-
-  private async getPrimaryKey(
-    schemaName: string,
-    tableName: string
-  ): Promise<string | null> {
-    const query = `
-      SELECT a.attname
-      FROM   pg_index i
-      JOIN   pg_attribute a ON a.attrelid = i.indrelid
-                           AND a.attnum = ANY(i.indkey)
-      WHERE  i.indrelid = '"${schemaName}"."${tableName}"'::regclass
-      AND    i.indisprimary;
-    `;
-    
-    try {
-      const { rows } = await this.targetPool.query(query);
-      return rows.length > 0 ? rows[0].attname : null;
-    } catch (error) {
-      this.logger.error(`Error getting primary key for ${tableName}: ${error.message}`);
-      return null;
-    }
-  }
-
-  private async getForeignKeys(
-    schemaName: string,
-    tableName: string
-  ): Promise<Array<{
-    column_name: string;
-    foreign_table_name: string;
-    foreign_column_name: string;
-  }>> {
-    const query = `
-      SELECT
-        kcu.column_name,
-        ccu.table_name AS foreign_table_name,
-        ccu.column_name AS foreign_column_name
-      FROM
-        information_schema.table_constraints tc
-        JOIN information_schema.key_column_usage kcu
-          ON tc.constraint_name = kcu.constraint_name
-          AND tc.table_schema = kcu.table_schema
-        JOIN information_schema.constraint_column_usage ccu
-          ON ccu.constraint_name = tc.constraint_name
-          AND ccu.table_schema = tc.table_schema
-      WHERE
-        tc.constraint_type = 'FOREIGN KEY'
-        AND tc.table_schema = $1
-        AND tc.table_name = $2;
-    `;
-    
-    try {
-      const { rows } = await this.targetPool.query(query, [schemaName, tableName]);
-      return rows;
-    } catch (error) {
-      this.logger.error(`Error getting foreign keys for ${tableName}: ${error.message}`);
-      return [];
-    }
-  }
-
-  private async findJoinTables(
-    schemaName: string,
-    sourceTable: string,
-    targetTable: string
-  ): Promise<Array<{
-    join_table: string;
-    source_column: string;
-    target_column: string;
-  }>> {
-    // Buscar tablas que tienen claves foráneas tanto a sourceTable como a targetTable
-    const query = `
-      WITH source_fks AS (
-        SELECT
-          tc.table_name,
-          kcu.column_name,
-          ccu.table_name AS referenced_table
-        FROM
-          information_schema.table_constraints tc
-          JOIN information_schema.key_column_usage kcu
-            ON tc.constraint_name = kcu.constraint_name
-            AND tc.table_schema = kcu.table_schema
-          JOIN information_schema.constraint_column_usage ccu
-            ON ccu.constraint_name = tc.constraint_name
-            AND ccu.table_schema = tc.table_schema
-        WHERE
-          tc.constraint_type = 'FOREIGN KEY'
-          AND tc.table_schema = $1
-          AND ccu.table_name = $2
-      ),
-      target_fks AS (
-        SELECT
-          tc.table_name,
-          kcu.column_name,
-          ccu.table_name AS referenced_table
-        FROM
-          information_schema.table_constraints tc
-          JOIN information_schema.key_column_usage kcu
-            ON tc.constraint_name = kcu.constraint_name
-            AND tc.table_schema = kcu.table_schema
-          JOIN information_schema.constraint_column_usage ccu
-            ON ccu.constraint_name = tc.constraint_name
-            AND ccu.table_schema = tc.table_schema
-        WHERE
-          tc.constraint_type = 'FOREIGN KEY'
-          AND tc.table_schema = $1
-          AND ccu.table_name = $3
-      )
-      SELECT
-        s.table_name AS join_table,
-        s.column_name AS source_column,
-        t.column_name AS target_column
-      FROM
-        source_fks s
-        JOIN target_fks t ON s.table_name = t.table_name
-    `;
-    
-    try {
-      const { rows } = await this.targetPool.query(query, [
-        schemaName,
-        sourceTable,
-        targetTable,
-      ]);
-      return rows;
-    } catch (error) {
-      this.logger.error(
-        `Error finding join tables between ${sourceTable} and ${targetTable}: ${error.message}`
-      );
-      return [];
-    }
-  }
+import { Logger } from "@nestjs/common";
+import { Pool } from "pg";
+import { EntityType } from "./types";
+
+export class EntityDiscovery {
+  private readonly logger = new Logger("EntityDiscovery");
+
+  constructor(private readonly targetPool: Pool) {}
+
+  async discoverEntityTypes(
+    schemaName: string,
+    tables: string[]
+  ): Promise<EntityType[]> {
+    try {
+      const entityTypes: EntityType[] = [];
+      
+      for (const tableName of tables) {
+        // Obtener la clave primaria de la tabla
+        const primaryKey = await this.getPrimaryKey(schemaName, tableName);
+        
+        if (!primaryKey) {
+          this.logger.warn(`No primary key found for table ${tableName}, skipping`);
+          continue;
+        }
+        
+        // Obtener las claves foráneas que podrían conectar con un proveedor
+        const foreignKeys = await this.getForeignKeys(schemaName, tableName);
+        
+        // Buscar una clave foránea que podría ser provider_id
+        const providerForeignKey = foreignKeys.find(fk => 
+          fk.column_name.includes('provider_id') || 
+          fk.foreign_table_name === 'providers'
+        );
+        
+        // Crear la entidad
+        const entity: EntityType = {
+          name: tableName,
+          idField: primaryKey,
+          foreignKey: providerForeignKey?.column_name,
+        };
+        
+        // Si no hay una clave foránea directa a providers, buscar relaciones indirectas
+        if (!entity.foreignKey) {
+          // Buscar tablas de unión que podrían conectar esta tabla con providers
+          const joinTables = await this.findJoinTables(
+            schemaName, 
+            tableName, 
+            'providers'
+          );
+          
+          if (joinTables.length > 0) {
+            const joinTable = joinTables[0];
+            entity.joinTable = joinTable.join_table;
+            entity.joinField = joinTable.source_column;
+            entity.joinForeignKey = joinTable.target_column;
+          }
+        }
+        
+        entityTypes.push(entity);
+      }
+      
+      return entityTypes;
+    } catch (error) {
+      this.logger.error(`Error discovering entity types: ${error.message}`);
+      return [];
+    }
+  }
+
+  private async getPrimaryKey(
+    schemaName: string,
+    tableName: string
+  ): Promise<string | null> {
+    const query = `
+      SELECT a.attname
+      FROM   pg_index i
+      JOIN   pg_attribute a ON a.attrelid = i.indrelid
+                           AND a.attnum = ANY(i.indkey)
+      WHERE  i.indrelid = '"${schemaName}"."${tableName}"'::regclass
+      AND    i.indisprimary;
+    `;
+    
+    try {
+      const { rows } = await this.targetPool.query(query);
+      return rows.length > 0 ? rows[0].attname : null;
+    } catch (error) {
+      this.logger.error(`Error getting primary key for ${tableName}: ${error.message}`);
+      return null;
+    }
+  }
+
+  private async getForeignKeys(
+    schemaName: string,
+    tableName: string
+  ): Promise<Array<{
+    column_name: string;
+    foreign_table_name: string;
+    foreign_column_name: string;
+  }>> {
+    const query = `
+      SELECT
+        kcu.column_name,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name
+      FROM
+        information_schema.table_constraints tc
+        JOIN information_schema.key_column_usage kcu
+          ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+        JOIN information_schema.constraint_column_usage ccu
+          ON ccu.constraint_name = tc.constraint_name
+          AND ccu.table_schema = tc.table_schema
+      WHERE
+        tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_schema = $1
+        AND tc.table_name = $2;
+    `;
+    
+    try {
+      const { rows } = await this.targetPool.query(query, [schemaName, tableName]);
+      return rows;
+    } catch (error) {
+      this.logger.error(`Error getting foreign keys for ${tableName}: ${error.message}`);
+      return [];
+    }
+  }
+
+  private async findJoinTables(
+    schemaName: string,
+    sourceTable: string,
+    targetTable: string
+  ): Promise<Array<{
+    join_table: string;
+    source_column: string;
+    target_column: string;
+  }>> {
+    // Buscar tablas que tienen claves foráneas tanto a sourceTable como a targetTable
+    const query = `
+      WITH source_fks AS (
+        SELECT
+          tc.table_name,
+          kcu.column_name,
+          ccu.table_name AS referenced_table
+        FROM
+          information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          JOIN information_schema.constraint_column_usage ccu
+            ON ccu.constraint_name = tc.constraint_name
+            AND ccu.table_schema = tc.table_schema
+        WHERE
+          tc.constraint_type = 'FOREIGN KEY'
+          AND tc.table_schema = $1
+          AND ccu.table_name = $2
+      ),
+      target_fks AS (
+        SELECT
+          tc.table_name,
+          kcu.column_name,
+          ccu.table_name AS referenced_table
+        FROM
+          information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          JOIN information_schema.constraint_column_usage ccu
+            ON ccu.constraint_name = tc.constraint_name
+            AND ccu.table_schema = tc.table_schema
+        WHERE
+          tc.constraint_type = 'FOREIGN KEY'
+          AND tc.table_schema = $1
+          AND ccu.table_name = $3
+      )
+      SELECT
+        s.table_name AS join_table,
+        s.column_name AS source_column,
+        t.column_name AS target_column
+      FROM
+        source_fks s
+        JOIN target_fks t ON s.table_name = t.table_name
+    `;
+    
+    try {
+      const { rows } = await this.targetPool.query(query, [
+        schemaName,
+        sourceTable,
+        targetTable,
+      ]);
+      return rows;
+    } catch (error) {
+      this.logger.error(
+        `Error finding join tables between ${sourceTable} and ${targetTable}: ${error.message}`
+      );
+      return [];
+    }
+  }
 }