@javalabs/prisma-client 1.0.4 → 1.0.6

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

@@ -1,319 +1,174 @@
 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();
+  private readonly visitedTables = new Set<string>();
+  private readonly temporaryMark = new Set<string>();
+  private readonly tableOrder: string[] = [];
+  private config: any;
 
   constructor(
     private readonly sourcePool: Pool,
     private readonly targetPool: Pool
   ) {}
 
+  setConfig(config: any) {
+    this.config = config;
+  }
+
   async analyzeDependencies(): Promise<string[]> {
     try {
-      // Get all tables
-      const tables = await this.getTables();
+      this.logger.log("Iniciando análisis de dependencias...");
 
-      // Build dependency graph
-      for (const table of tables) {
-        const foreignKeys = await this.getForeignKeys(table);
+      // Obtener todas las tablas del esquema
+      const tables = await this.getAllTables();
 
-        // Add manual dependencies for specific cases
-        const manualDependencies = this.getManualDependencies(table);
-        const allDependencies = [
-          ...new Set([...foreignKeys, ...manualDependencies]),
-        ];
+      // Resetear estado
+      this.visitedTables.clear();
+      this.temporaryMark.clear();
+      this.tableOrder.length = 0;
 
-        this.dependencyGraph.set(table, {
-          table,
-          dependencies: allDependencies,
-        });
-      }
+      // Ordenar tablas por prioridad primero
+      const priorityOrder = this.getPriorityOrder(tables);
 
-      // 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);
+      // Realizar ordenamiento topológico para cada grupo de prioridad
+      for (const priorityGroup of priorityOrder) {
+        for (const table of priorityGroup) {
+          if (!this.visitedTables.has(table)) {
+            await this.visit(table);
+          }
+        }
+      }
 
-      this.logger.log(`Migration order: ${sortedTables.join(" -> ")}`);
-      return sortedTables;
+      this.logger.log(
+        `Orden de migración determinado: ${this.tableOrder.join(" -> ")}`
+      );
+      return this.tableOrder;
     } catch (error) {
-      this.logger.error(`Error analyzing dependencies: ${error.message}`);
+      this.logger.error(`Error analizando dependencias: ${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"],
+  private getPriorityOrder(tables: string[]): string[][] {
+    const priorities = {
+      high: new Set(this.config?.migrationPriorities?.high || []),
+      medium: new Set(this.config?.migrationPriorities?.medium || []),
+      low: new Set(this.config?.migrationPriorities?.low || []),
     };
 
-    return manualDependencyMap[tableName] || [];
+    // Agrupar tablas por prioridad
+    const highPriority = tables.filter((t) => priorities.high.has(t));
+    const mediumPriority = tables.filter((t) => priorities.medium.has(t));
+    const lowPriority = tables.filter((t) => priorities.low.has(t));
+    const noPriority = tables.filter(
+      (t) =>
+        !priorities.high.has(t) &&
+        !priorities.medium.has(t) &&
+        !priorities.low.has(t)
+    );
+
+    return [highPriority, mediumPriority, noPriority, lowPriority];
   }
 
-  private async getTables(): Promise<string[]> {
+  private async visit(table: string, path: string[] = []): Promise<void> {
+    // Detectar ciclos
+    if (this.temporaryMark.has(table)) {
+      const cycle = [...path, table].join(" -> ");
+      this.logger.warn(`Detectado ciclo de dependencias: ${cycle}`);
+      return;
+    }
+
+    if (this.visitedTables.has(table)) {
+      return;
+    }
+
+    this.temporaryMark.add(table);
+    path.push(table);
+
+    // Obtener dependencias tanto de la configuración como de la base de datos
+    const dependencies = await this.getTableDependencies(table);
+
+    for (const dep of dependencies) {
+      if (!this.visitedTables.has(dep)) {
+        await this.visit(dep, [...path]);
+      }
+    }
+
+    this.temporaryMark.delete(table);
+    this.visitedTables.add(table);
+    this.tableOrder.push(table);
+  }
+
+  private async getAllTables(): 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
-          `;
+  private async getTableDependencies(table: string): Promise<string[]> {
+    const dependencies = new Set<string>();
 
-      const [fkResult, implicitResult, referencedResult] = await Promise.all([
-        this.sourcePool.query(foreignKeyQuery, [tableName]),
-        this.sourcePool.query(implicitDependencyQuery, [tableName]),
-        this.sourcePool.query(referencedTablesQuery, [tableName]),
-      ]);
+    // Obtener dependencias de la configuración
+    const configDeps = this.config?.tables?.[table]?.dependencies || [];
+    configDeps.forEach((dep) => dependencies.add(dep));
 
-      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);
-        }
-      });
+    // Obtener dependencias de la base de datos
+    const query = `
+      SELECT
+        ccu.table_name AS foreign_table
+      FROM
+        information_schema.table_constraints tc
+        JOIN information_schema.constraint_column_usage ccu
+          ON ccu.constraint_name = tc.constraint_name
+      WHERE
+        tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_name = $1
+        AND tc.table_schema = 'public'
+    `;
 
-      return Array.from(allDependencies);
+    try {
+      const result = await this.sourcePool.query(query, [table]);
+      result.rows.forEach((row) => dependencies.add(row.foreign_table));
     } catch (error) {
-      this.logger.error(
-        `Error getting dependencies for ${tableName}: ${error.message}`
+      this.logger.warn(
+        `Error obteniendo dependencias para ${table}: ${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;
+    return Array.from(dependencies);
   }
 
-  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)) {
+  async validateDependencies(
+    table: string,
+    dependencies: string[]
+  ): Promise<boolean> {
+    for (const dep of dependencies) {
+      const query = `
+        SELECT EXISTS (
+          SELECT 1 
+          FROM information_schema.tables 
+          WHERE table_schema = 'public' 
+          AND table_name = $1
+        )
+      `;
+
+      const result = await this.sourcePool.query(query, [dep]);
+      if (!result.rows[0].exists) {
         this.logger.warn(
-          `Circular dependency detected involving table: ${tableName}`
+          `Dependencia ${dep} no encontrada para tabla ${table}`
         );
-        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);
+        return false;
       }
     }
+
+    return true;
   }
 }