@javalabs/prisma-client 1.0.0

package/src/scripts/data-migration/dependency-resolver.ts

@@ -0,0 +1,319 @@
+import { Logger } from "@nestjs/common";
+import { Pool } from "pg";
+
+interface TableDependency {
+  table: string;
+  dependencies: string[];
+  level?: number;
+}
+
+export class DependencyResolver {
+  private readonly logger = new Logger("DependencyResolver");
+  private dependencyGraph: Map<string, TableDependency> = new Map();
+
+  constructor(
+    private readonly sourcePool: Pool,
+    private readonly targetPool: Pool
+  ) {}
+
+  async analyzeDependencies(): Promise<string[]> {
+    try {
+      // Get all tables
+      const tables = await this.getTables();
+
+      // Build dependency graph
+      for (const table of tables) {
+        const foreignKeys = await this.getForeignKeys(table);
+
+        // Add manual dependencies for specific cases
+        const manualDependencies = this.getManualDependencies(table);
+        const allDependencies = [
+          ...new Set([...foreignKeys, ...manualDependencies]),
+        ];
+
+        this.dependencyGraph.set(table, {
+          table,
+          dependencies: allDependencies,
+        });
+      }
+
+      // Assign levels to tables based on dependencies
+      this.assignLevels();
+
+      // Sort tables by dependency level
+      const sortedTables = Array.from(this.dependencyGraph.values())
+        .sort((a, b) => (a.level || 0) - (b.level || 0))
+        .map((dep) => dep.table);
+
+      this.logger.log(`Migration order: ${sortedTables.join(" -> ")}`);
+      return sortedTables;
+    } catch (error) {
+      this.logger.error(`Error analyzing dependencies: ${error.message}`);
+      throw error;
+    }
+  }
+
+  private getManualDependencies(tableName: string): string[] {
+    // Define manual dependencies for specific cases
+    const manualDependencyMap: Record<string, string[]> = {
+      api_keys: ["users", "providers"],
+      balances: ["users"],
+      customers: ["users"],
+      global_user_transactions: ["users", "providers", "transactions"],
+      invoices: ["transactions"],
+      credit_requests: ["users", "invoices"],
+      notifications: ["users", "transactions"],
+      pending_references: ["users", "providers"],
+      daily_logs: ["transactions"],
+      transaction_updates: ["transactions"],
+      toku: ["transactions"],
+      providers: ["countries"],
+      users: ["countries"],
+    };
+
+    return manualDependencyMap[tableName] || [];
+  }
+
+  private async getTables(): Promise<string[]> {
+    const query = `
+      SELECT table_name 
+      FROM information_schema.tables 
+      WHERE table_schema = 'public' 
+      AND table_type = 'BASE TABLE'
+      AND table_name NOT IN ('_prisma_migrations', 'schema_migrations')
+    `;
+
+    const result = await this.sourcePool.query(query);
+    return result.rows.map((row) => row.table_name);
+  }
+
+  private async getForeignKeys(tableName: string): Promise<string[]> {
+    try {
+      // Get explicit foreign keys (mantener el query existente)
+      const foreignKeyQuery = `
+              SELECT DISTINCT
+                  ccu.table_name AS foreign_table_name,
+                  kcu.column_name AS column_name
+              FROM 
+                  information_schema.table_constraints AS tc 
+                  JOIN information_schema.constraint_column_usage AS ccu
+                      ON ccu.constraint_name = tc.constraint_name
+                  JOIN information_schema.key_column_usage AS kcu
+                      ON kcu.constraint_name = tc.constraint_name
+              WHERE 
+                  tc.constraint_type = 'FOREIGN KEY' 
+                  AND tc.table_name = $1
+                  AND tc.table_schema = 'public'
+          `;
+
+      // Expanded implicit dependencies patterns
+      const implicitDependencyQuery = `
+              SELECT DISTINCT
+                  c.column_name,
+                  c.udt_name,
+                  c.column_default,
+                  c.data_type
+              FROM 
+                  information_schema.columns c
+              WHERE 
+                  c.table_schema = 'public'
+                  AND c.table_name = $1
+                  AND (
+                      -- Common ID patterns
+                      c.column_name LIKE '%_id'
+                      OR c.column_name LIKE '%_ids'
+                      OR c.column_name LIKE 'id_%'
+                      -- Reference patterns
+                      OR c.column_name LIKE '%_ref%'
+                      OR c.column_name LIKE '%_key'
+                      OR c.column_name LIKE '%_code'
+                      -- Relationship patterns
+                      OR c.column_name LIKE '%_by'
+                      OR c.column_name LIKE '%_to'
+                      OR c.column_name LIKE '%_from'
+                      OR c.column_name LIKE 'parent_%'
+                      OR c.column_name LIKE 'child_%'
+                      -- JSON/JSONB columns that might contain references
+                      OR (c.data_type IN ('json', 'jsonb') AND c.column_name LIKE '%_data')
+                      -- Array columns that might contain IDs
+                      OR (c.data_type = 'ARRAY' AND c.column_name LIKE '%_ids')
+                      -- Enum columns that might indicate relationships
+                      OR (c.udt_name LIKE 'enum_%' AND c.column_name LIKE '%_type')
+                  )
+          `;
+
+      // Get referenced tables through column comments or descriptions
+      const referencedTablesQuery = `
+              SELECT DISTINCT
+                  obj_description(c.table_name::regclass, 'pg_class') as table_comment
+              FROM 
+                  information_schema.columns c
+              WHERE 
+                  c.table_schema = 'public'
+                  AND c.table_name = $1
+          `;
+
+      const [fkResult, implicitResult, referencedResult] = await Promise.all([
+        this.sourcePool.query(foreignKeyQuery, [tableName]),
+        this.sourcePool.query(implicitDependencyQuery, [tableName]),
+        this.sourcePool.query(referencedTablesQuery, [tableName]),
+      ]);
+
+      const allDependencies = new Set<string>();
+
+      // Add explicit foreign key dependencies
+      fkResult.rows.forEach((row) =>
+        allDependencies.add(row.foreign_table_name)
+      );
+
+      // Add implicit dependencies
+      implicitResult.rows.forEach((row) => {
+        const columnName = row.column_name;
+        // Convert column name to potential table name (e.g., user_id -> users)
+        const potentialTable = this.inferTableNameFromColumn(columnName);
+        if (potentialTable) {
+          allDependencies.add(potentialTable);
+        }
+      });
+
+      // Parse table comments for additional dependencies
+      referencedResult.rows.forEach((row) => {
+        if (row.table_comment) {
+          const referencedTables = this.parseTableComment(row.table_comment);
+          referencedTables.forEach((table) => allDependencies.add(table));
+        }
+      });
+
+      // Añadir lógica adicional para procesar los resultados
+      implicitResult.rows.forEach((row) => {
+        // Procesar columnas JSON/JSONB
+        if (row.data_type === "json" || row.data_type === "jsonb") {
+          const potentialRefs = this.extractJsonReferences(row.column_name);
+          potentialRefs.forEach((ref) => allDependencies.add(ref));
+        }
+
+        // Procesar columnas de tipo enum
+        if (row.udt_name?.startsWith("enum_")) {
+          const enumTable = this.inferTableFromEnum(row.udt_name);
+          if (enumTable) allDependencies.add(enumTable);
+        }
+
+        // Procesar arrays
+        if (row.data_type === "ARRAY") {
+          const arrayTable = this.inferTableFromArrayColumn(row.column_name);
+          if (arrayTable) allDependencies.add(arrayTable);
+        }
+      });
+
+      return Array.from(allDependencies);
+    } catch (error) {
+      this.logger.error(
+        `Error getting dependencies for ${tableName}: ${error.message}`
+      );
+      return [];
+    }
+  }
+
+  private inferTableFromEnum(enumType: string): string | null {
+    // enum_transaction_status -> transactions
+    const parts = enumType.split("_");
+    if (parts.length > 1) {
+      return parts[1];
+    }
+    return null;
+  }
+
+  private inferTableFromArrayColumn(columnName: string): string | null {
+    // user_ids -> users
+    if (columnName.endsWith("_ids")) {
+      return columnName.slice(0, -4) + "s";
+    }
+    return null;
+  }
+
+  private extractJsonReferences(columnName: string): string[] {
+    // metadata_data -> buscar referencias en el nombre
+    const refs: string[] = [];
+    const parts = columnName.split("_");
+    if (parts.length > 1) {
+      const potentialTable = parts[0] + "s";
+      refs.push(potentialTable);
+    }
+    return refs;
+  }
+
+  private inferTableNameFromColumn(columnName: string): string | null {
+    // Remove common suffixes
+    const suffixes = ["_id", "_by", "_ref", "_fk"];
+    let tableName = columnName;
+
+    for (const suffix of suffixes) {
+      if (tableName.endsWith(suffix)) {
+        tableName = tableName.slice(0, -suffix.length);
+        break;
+      }
+    }
+
+    // Convert to plural form (simple conversion)
+    if (!tableName.endsWith("s")) {
+      tableName += "s";
+    }
+
+    return tableName;
+  }
+
+  private parseTableComment(comment: string): string[] {
+    // Extract table references from comments
+    // Example comment format: "References: users, transactions"
+    const referencesMatch = comment.match(/References:\s*([^;]+)/i);
+    if (referencesMatch) {
+      return referencesMatch[1]
+        .split(",")
+        .map((table) => table.trim())
+        .filter((table) => table.length > 0);
+    }
+    return [];
+  }
+
+  private assignLevels(): void {
+    const visited = new Set<string>();
+    const visiting = new Set<string>();
+
+    const visit = (tableName: string, level = 0): number => {
+      if (visiting.has(tableName)) {
+        this.logger.warn(
+          `Circular dependency detected involving table: ${tableName}`
+        );
+        return level;
+      }
+
+      if (visited.has(tableName)) {
+        return this.dependencyGraph.get(tableName)?.level || 0;
+      }
+
+      visiting.add(tableName);
+
+      const node = this.dependencyGraph.get(tableName);
+      if (!node) return level;
+
+      let maxDepLevel = level;
+      for (const dep of node.dependencies) {
+        const depLevel = visit(dep, level + 1);
+        maxDepLevel = Math.max(maxDepLevel, depLevel + 1);
+      }
+
+      node.level = maxDepLevel;
+      visited.add(tableName);
+      visiting.delete(tableName);
+
+      return maxDepLevel;
+    };
+
+    // Start with all tables
+    for (const tableName of this.dependencyGraph.keys()) {
+      if (!visited.has(tableName)) {
+        visit(tableName);
+      }
+    }
+  }
+}

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

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

package/src/scripts/data-migration/foreign-key-manager.ts

@@ -0,0 +1,95 @@
+import { Logger } from "@nestjs/common";
+import { PrismaClient } from "@prisma/client";
+import { DatabaseConnections } from "./types";
+
+export class ForeignKeyManager {
+  private readonly logger = new Logger("ForeignKeyManager");
+
+  constructor(private readonly connections: DatabaseConnections) {}
+
+  async getForeignKeyDependencies(
+    schemaName: string,
+    tableName: string
+  ): Promise<
+    Array<{ column: string; foreignTable: string; foreignColumn: string }>
+  > {
+    try {
+      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;
+      `;
+
+      const { rows } = await this.connections.targetPool.query(query, [
+        schemaName,
+        tableName,
+      ]);
+      return rows.map((row) => ({
+        column: row.column_name,
+        foreignTable: row.foreign_table_name,
+        foreignColumn: row.foreign_column_name,
+      }));
+    } catch (error) {
+      this.logger.error(
+        `Error getting foreign key dependencies for ${tableName}: ${error.message}`
+      );
+      return [];
+    }
+  }
+
+  async checkForeignKeyDependencies(
+    prisma: PrismaClient,
+    schemaName: string,
+    row: any,
+    dependencies: Array<{
+      column: string;
+      foreignTable: string;
+      foreignColumn: string;
+    }>
+  ): Promise<string[]> {
+    const missingDependencies: string[] = [];
+
+    for (const dep of dependencies) {
+      if (row[dep.column] !== null) {
+        const query = `
+          SELECT 1 FROM "${schemaName}"."${dep.foreignTable}" 
+          WHERE "${dep.foreignColumn}" = $1 
+          LIMIT 1
+        `;
+
+        try {
+          const result = await prisma.$queryRawUnsafe(query, row[dep.column]);
+          if (!result || (Array.isArray(result) && result.length === 0)) {
+            missingDependencies.push(
+              `${dep.foreignTable}.${dep.foreignColumn}=${row[dep.column]}`
+            );
+          }
+        } catch (error) {
+          this.logger.error(
+            `Error checking dependency ${dep.foreignTable}.${dep.foreignColumn}: ${error.message}`
+          );
+          missingDependencies.push(
+            `${dep.foreignTable}.${dep.foreignColumn}=${
+              row[dep.column]
+            } (error)`
+          );
+        }
+      }
+    }
+
+    return missingDependencies;
+  }
+}