@grafema/core 0.1.0-alpha.5 → 0.2.0-beta

package/src/plugins/enrichment/FunctionCallResolver.ts

@@ -0,0 +1,456 @@
+/**
+ * FunctionCallResolver - creates CALLS edges for imported function calls
+ *
+ * This enrichment plugin runs AFTER ImportExportLinker (priority 80 vs 90) and:
+ * 1. Finds CALL_SITE nodes without CALLS edges (excluding method calls)
+ * 2. For each, looks for IMPORT with matching local name in same file
+ * 3. Follows IMPORTS_FROM -> EXPORT -> FUNCTION chain
+ * 4. Creates CALLS edge to target FUNCTION
+ *
+ * CREATES EDGES:
+ * - CALL_SITE -> CALLS -> FUNCTION (for imported functions)
+ */
+
+import { Plugin, createSuccessResult } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+import type { BaseNodeRecord } from '@grafema/types';
+import { dirname, resolve } from 'path';
+import { StrictModeError } from '../../errors/GrafemaError.js';
+
+// === INTERFACES ===
+
+interface CallNode extends BaseNodeRecord {
+  object?: string; // If present, this is a method call - skip
+}
+
+interface ImportNode extends BaseNodeRecord {
+  source?: string;
+  importType?: string; // 'default' | 'named' | 'namespace'
+  imported?: string; // Original name in source file
+  local?: string; // Local binding name
+}
+
+interface ExportNode extends BaseNodeRecord {
+  exportType?: string; // 'default' | 'named' | 'all'
+  local?: string; // Local name in exporting file
+  source?: string; // Re-export source (if re-exporting)
+}
+
+interface ExportIndexEntry {
+  node: ExportNode;
+  exportKey: string; // "default" | "named:functionName"
+}
+
+interface ExternalModuleResult {
+  type: 'external';
+  packageName: string;
+  exportedName: string;
+}
+
+type ResolveChainResult = ExportNode | ExternalModuleResult | null;
+
+type FunctionNode = BaseNodeRecord;
+
+// === PLUGIN CLASS ===
+
+export class FunctionCallResolver extends Plugin {
+  get metadata(): PluginMetadata {
+    return {
+      name: 'FunctionCallResolver',
+      phase: 'ENRICHMENT',
+      priority: 80, // After ImportExportLinker (90)
+      creates: {
+        nodes: ['EXTERNAL_MODULE'],
+        edges: ['CALLS']
+      },
+      dependencies: ['ImportExportLinker'] // Requires IMPORTS_FROM edges
+    };
+  }
+
+  async execute(context: PluginContext): Promise<PluginResult> {
+    const { graph } = context;
+    const logger = this.log(context);
+
+    logger.info('Starting function call resolution');
+
+    const startTime = Date.now();
+
+    // Step 1: Build Import Index - Map<file:local, ImportNode>
+    const importIndex = new Map<string, ImportNode>();
+    for await (const node of graph.queryNodes({ nodeType: 'IMPORT' })) {
+      const imp = node as ImportNode;
+      if (!imp.file || !imp.local) continue;
+
+      // Skip external imports (non-relative)
+      const isRelative = imp.source && (imp.source.startsWith('./') || imp.source.startsWith('../'));
+      if (!isRelative) continue;
+
+      const key = `${imp.file}:${imp.local}`;
+      importIndex.set(key, imp);
+    }
+    logger.debug('Indexed imports', { count: importIndex.size });
+
+    // Step 2: Build Function Index - Map<file, Map<name, FunctionNode>>
+    const functionIndex = new Map<string, Map<string, FunctionNode>>();
+    for await (const node of graph.queryNodes({ nodeType: 'FUNCTION' })) {
+      const func = node as FunctionNode;
+      if (!func.file || !func.name) continue;
+
+      if (!functionIndex.has(func.file)) {
+        functionIndex.set(func.file, new Map());
+      }
+      functionIndex.get(func.file)!.set(func.name, func);
+    }
+    logger.debug('Indexed functions', { files: functionIndex.size });
+
+    // Step 2.5: Build Export Index - Map<file, Map<exportKey, ExportNode>>
+    // This enables O(1) lookup when following re-export chains
+    const exportIndex = new Map<string, Map<string, ExportNode>>();
+    for await (const node of graph.queryNodes({ nodeType: 'EXPORT' })) {
+      const exp = node as ExportNode;
+      if (!exp.file) continue;
+
+      if (!exportIndex.has(exp.file)) {
+        exportIndex.set(exp.file, new Map());
+      }
+
+      const fileExports = exportIndex.get(exp.file)!;
+      fileExports.set(this.buildExportKey(exp), exp);
+    }
+    logger.debug('Indexed exports', { files: exportIndex.size });
+
+    // Step 2.6: Build set of known files for path resolution
+    const knownFiles = new Set<string>();
+    for (const file of exportIndex.keys()) {
+      knownFiles.add(file);
+    }
+    for (const file of functionIndex.keys()) {
+      knownFiles.add(file);
+    }
+    logger.debug('Indexed known files', { count: knownFiles.size });
+
+    // Step 3: Collect unresolved CALL_SITE nodes
+    const callSitesToResolve: CallNode[] = [];
+    for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
+      const call = node as CallNode;
+
+      // Skip method calls (have object attribute)
+      if (call.object) continue;
+
+      // Skip if already has CALLS edge
+      const existingEdges = await graph.getOutgoingEdges(call.id, ['CALLS']);
+      if (existingEdges.length > 0) continue;
+
+      callSitesToResolve.push(call);
+    }
+    logger.info('Found call sites to resolve', { count: callSitesToResolve.length });
+
+    // Step 4: Resolution
+    let edgesCreated = 0;
+    const skipped = {
+      alreadyResolved: 0,
+      methodCalls: 0,
+      external: 0,
+      missingImport: 0,
+      missingImportsFrom: 0,
+      reExportsBroken: 0     // Re-export chain broken (missing export, file not found, or circular)
+    };
+
+    let reExportsResolved = 0; // Counter for successfully resolved re-export chains
+    const errors: Error[] = [];
+
+    for (const callSite of callSitesToResolve) {
+      const calledName = callSite.name;
+      const file = callSite.file;
+
+      if (!calledName || !file) continue;
+
+      // Step 4.1: Find matching import in same file
+      const importKey = `${file}:${calledName}`;
+      const imp = importIndex.get(importKey);
+
+      if (!imp) {
+        skipped.missingImport++;
+        continue;
+      }
+
+      // Step 4.2: Follow IMPORTS_FROM edge to find EXPORT
+      const importsFromEdges = await graph.getOutgoingEdges(imp.id, ['IMPORTS_FROM']);
+      if (importsFromEdges.length === 0) {
+        skipped.missingImportsFrom++;
+        continue;
+      }
+
+      const exportNodeId = importsFromEdges[0].dst;
+      const exportNode = await graph.getNode(exportNodeId) as ExportNode | null;
+
+      if (!exportNode) {
+        skipped.missingImportsFrom++;
+        continue;
+      }
+
+      // Step 4.3: Resolve re-export chain (if applicable)
+      let finalExport = exportNode;
+
+      if (exportNode.source) {
+        // This is a re-export - follow the chain
+        const resolved = this.resolveExportChain(
+          exportNode,
+          exportIndex,
+          knownFiles
+        );
+
+        if (!resolved) {
+          // Chain broken or circular
+          // Distinguish: if visited set would show cycle, it's circular
+          // For simplicity, count as broken (can add nuance later)
+          skipped.reExportsBroken++;
+
+          // In strict mode, collect error
+          if (context.strictMode) {
+            const error = new StrictModeError(
+              `Cannot resolve re-export chain for: ${calledName}`,
+              'STRICT_BROKEN_IMPORT',
+              {
+                filePath: file,
+                lineNumber: callSite.line as number | undefined,
+                phase: 'ENRICHMENT',
+                plugin: 'FunctionCallResolver',
+                calledFunction: calledName,
+                importSource: imp.source,
+              },
+              `Check if the module "${imp.source}" exists and exports "${calledName}"`
+            );
+            errors.push(error);
+          }
+          continue;
+        }
+
+        // Check if resolved to external module
+        if ('type' in resolved && resolved.type === 'external') {
+          // Type narrowing: resolved is ExternalModuleResult
+          const externalResult = resolved as ExternalModuleResult;
+
+          // Find or create EXTERNAL_MODULE node and create CALLS edge
+          const externalModuleId = `EXTERNAL_MODULE:${externalResult.packageName}`;
+
+          // Check if node exists
+          let externalNode = await graph.getNode(externalModuleId);
+          if (!externalNode) {
+            // Create EXTERNAL_MODULE node
+            await graph.addNode({
+              id: externalModuleId,
+              type: 'EXTERNAL_MODULE',
+              name: externalResult.packageName,
+              file: '',
+              line: 0
+            });
+          }
+
+          // Create CALLS edge with metadata
+          await graph.addEdge({
+            type: 'CALLS',
+            src: callSite.id,
+            dst: externalModuleId,
+            metadata: { exportedName: externalResult.exportedName }
+          });
+
+          edgesCreated++;
+          reExportsResolved++;
+          continue;
+        }
+
+        // At this point, resolved must be ExportNode (not external)
+        finalExport = resolved as ExportNode;
+        reExportsResolved++;
+      }
+
+      // Step 4.4: Find target FUNCTION via final export's local name
+      const targetFile = finalExport.file;
+      const targetFunctionName = finalExport.local || finalExport.name;
+
+      if (!targetFile || !targetFunctionName) continue;
+
+      const fileFunctions = functionIndex.get(targetFile);
+      if (!fileFunctions) continue;
+
+      const targetFunction = fileFunctions.get(targetFunctionName);
+      if (!targetFunction) continue;
+
+      // Step 4.5: Create CALLS edge
+      await graph.addEdge({
+        type: 'CALLS',
+        src: callSite.id,
+        dst: targetFunction.id
+      });
+
+      edgesCreated++;
+    }
+
+    const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
+    logger.info('Complete', {
+      edgesCreated,
+      skipped,
+      time: `${totalTime}s`
+    });
+
+    return createSuccessResult(
+      { nodes: 0, edges: edgesCreated },
+      {
+        callSitesProcessed: callSitesToResolve.length,
+        edgesCreated,
+        reExportsResolved,
+        skipped,
+        timeMs: Date.now() - startTime
+      },
+      errors
+    );
+  }
+
+  /**
+   * Build a key string for export index lookup.
+   *
+   * @param exp - Export node to build key for
+   * @returns Key in format "default" or "named:name"
+   */
+  private buildExportKey(exp: ExportNode): string {
+    if (exp.exportType === 'default') {
+      return 'default';
+    }
+    return `named:${exp.name || exp.local || 'anonymous'}`;
+  }
+
+  /**
+   * Extract package name from import source.
+   * Handles: 'lodash', '@tanstack/react-query', 'lodash/map', '@scope/pkg/sub'
+   */
+  private extractPackageName(source: string): string | null {
+    if (!source) return null;
+
+    // Handle scoped packages (@scope/package)
+    if (source.startsWith('@')) {
+      const parts = source.split('/');
+      if (parts.length >= 2) {
+        return `${parts[0]}/${parts[1]}`;
+      }
+      return null;
+    }
+
+    // Non-scoped package: lodash or lodash/map
+    const slashIndex = source.indexOf('/');
+    if (slashIndex === -1) {
+      return source;
+    }
+    return source.substring(0, slashIndex);
+  }
+
+  /**
+   * Resolve module specifier to actual file path using extension fallbacks.
+   * Pattern reused from ImportExportLinker (lines 101-122).
+   *
+   * @param currentDir - Directory of the file containing the import/re-export
+   * @param specifier - The module specifier (e.g., "./utils", "../lib/helpers")
+   * @param fileIndex - Set or Map of known file paths for existence checking
+   * @returns Resolved file path or null if not found
+   */
+  private resolveModulePath(
+    currentDir: string,
+    specifier: string,
+    fileIndex: Set<string>
+  ): string | null {
+    const basePath = resolve(currentDir, specifier);
+    const extensions = ['', '.js', '.ts', '.jsx', '.tsx', '/index.js', '/index.ts'];
+
+    for (const ext of extensions) {
+      const testPath = basePath + ext;
+      if (fileIndex.has(testPath)) {
+        return testPath;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Follow re-export chain to find the final EXPORT node (without source field).
+   *
+   * Algorithm:
+   * 1. If current export has no source -> return it (base case)
+   * 2. Resolve source path to file
+   * 3. Find matching export in that file
+   * 4. Recurse (with cycle detection)
+   *
+   * @param exportNode - Starting export node (may be re-export)
+   * @param exportIndex - Pre-built export index for O(1) lookups
+   * @param knownFiles - Set of known file paths
+   * @param visited - Set of visited export IDs for cycle detection
+   * @param maxDepth - Maximum chain depth (safety limit)
+   * @returns Final export node (without source), external module result, or null if chain broken/circular
+   */
+  private resolveExportChain(
+    exportNode: ExportNode,
+    exportIndex: Map<string, Map<string, ExportNode>>,
+    knownFiles: Set<string>,
+    visited: Set<string> = new Set(),
+    maxDepth: number = 10
+  ): ResolveChainResult {
+    // Safety: max depth exceeded
+    if (maxDepth <= 0) {
+      return null;
+    }
+
+    // Cycle detection
+    if (visited.has(exportNode.id)) {
+      return null;
+    }
+    visited.add(exportNode.id);
+
+    // Base case: not a re-export
+    if (!exportNode.source) {
+      return exportNode;
+    }
+
+    // Recursive case: follow re-export
+    const currentDir = dirname(exportNode.file!);
+    const targetFile = this.resolveModulePath(currentDir, exportNode.source, knownFiles);
+
+    if (!targetFile) {
+      // Check if this is an external module (non-relative source)
+      const source = exportNode.source!;
+      const isExternal = !source.startsWith('./') && !source.startsWith('../');
+
+      if (isExternal) {
+        const packageName = this.extractPackageName(source);
+        if (packageName) {
+          return {
+            type: 'external',
+            packageName,
+            exportedName: exportNode.local || exportNode.name || ''
+          };
+        }
+      }
+      return null; // Source file not found and not external
+    }
+
+    const targetExports = exportIndex.get(targetFile);
+    if (!targetExports) {
+      return null; // No exports in target file
+    }
+
+    // Find matching export by name
+    // Re-export: export { foo } from './other' - look for named:foo
+    // Re-export default: export { default } from './other' - look for default
+    const nextExport = targetExports.get(this.buildExportKey(exportNode));
+    if (!nextExport) {
+      return null; // Export not found in target
+    }
+
+    return this.resolveExportChain(
+      nextExport,
+      exportIndex,
+      knownFiles,
+      visited,
+      maxDepth - 1
+    );
+  }
+}

package/src/plugins/enrichment/HTTPConnectionEnricher.ts

@@ -19,6 +19,7 @@ import type { BaseNodeRecord } from '@grafema/types';
 interface HTTPRouteNode extends BaseNodeRecord {
   method?: string;
   path?: string;
+  fullPath?: string;  // Set by MountPointResolver for mounted routes
   url?: string;
 }
 
@@ -28,6 +29,7 @@ interface HTTPRouteNode extends BaseNodeRecord {
 interface HTTPRequestNode extends BaseNodeRecord {
   method?: string;
   url?: string;
+  responseDataNode?: string;  // ID of response.json() CALL node (set by FetchAnalyzer)
 }
 
 /**
@@ -48,14 +50,15 @@ export class HTTPConnectionEnricher extends Plugin {
       priority: 50,  // После основных enrichers
       creates: {
         nodes: [],
-        edges: ['INTERACTS_WITH']
+        edges: ['INTERACTS_WITH', 'HTTP_RECEIVES']
       },
-      dependencies: ['ExpressRouteAnalyzer', 'FetchAnalyzer']
+      dependencies: ['ExpressRouteAnalyzer', 'FetchAnalyzer', 'ExpressResponseAnalyzer']
     };
   }
 
   async execute(context: PluginContext): Promise<PluginResult> {
     const { graph } = context;
+    const logger = this.log(context);
 
     try {
       // Собираем все http:route (backend endpoints)
@@ -70,13 +73,19 @@ export class HTTPConnectionEnricher extends Plugin {
         requests.push(node as HTTPRequestNode);
       }
 
-      console.log(`[HTTPConnectionEnricher] Found ${routes.length} routes, ${requests.length} requests`);
+      logger.debug('Found routes and requests', {
+        routes: routes.length,
+        requests: requests.length
+      });
 
       // Дедуплицируем по ID (из-за multi-service анализа)
       const uniqueRoutes = this.deduplicateById(routes);
       const uniqueRequests = this.deduplicateById(requests);
 
-      console.log(`[HTTPConnectionEnricher] Unique: ${uniqueRoutes.length} routes, ${uniqueRequests.length} requests`);
+      logger.info('Unique routes and requests', {
+        routes: uniqueRoutes.length,
+        requests: uniqueRequests.length
+      });
 
       let edgesCreated = 0;
       const connections: ConnectionInfo[] = [];
@@ -94,10 +103,11 @@ export class HTTPConnectionEnricher extends Plugin {
         // Ищем matching route
         for (const route of uniqueRoutes) {
           const routeMethod = (route.method || 'GET').toUpperCase();
-          const routePath = route.path;
+          // Use fullPath (from MountPointResolver) if available, fallback to local path
+          const routePath = route.fullPath || route.path;
 
           if (routePath && method === routeMethod && this.pathsMatch(url, routePath)) {
-            // Создаём edge
+            // 1. Create INTERACTS_WITH edge (existing)
             await graph.addEdge({
               type: 'INTERACTS_WITH',
               src: request.id,
@@ -105,6 +115,28 @@ export class HTTPConnectionEnricher extends Plugin {
               matchType: this.hasParams(routePath) ? 'parametric' : 'exact'
             });
 
+            edgesCreated++;
+
+            // 2. Create HTTP_RECEIVES edges if both sides have data nodes
+            const responseDataNode = request.responseDataNode;
+            if (responseDataNode) {
+              const respondsWithEdges = await graph.getOutgoingEdges(route.id, ['RESPONDS_WITH']);
+              for (const respEdge of respondsWithEdges) {
+                await graph.addEdge({
+                  type: 'HTTP_RECEIVES',
+                  src: responseDataNode,
+                  dst: respEdge.dst,
+                  metadata: {
+                    method: request.method,
+                    path: request.url,
+                    viaRequest: request.id,
+                    viaRoute: route.id
+                  }
+                });
+                edgesCreated++;
+              }
+            }
+
             connections.push({
               request: `${method} ${url}`,
               route: `${routeMethod} ${routePath}`,
@@ -112,7 +144,6 @@ export class HTTPConnectionEnricher extends Plugin {
               routeFile: route.file
             });
 
-            edgesCreated++;
             break; // Один request → один route
           }
         }
@@ -120,10 +151,10 @@ export class HTTPConnectionEnricher extends Plugin {
 
       // Логируем найденные связи
       if (connections.length > 0) {
-        console.log(`[HTTPConnectionEnricher] Connections found:`);
-        for (const conn of connections) {
-          console.log(`  ${conn.request} → ${conn.route}`);
-        }
+        logger.info('Connections found', {
+          count: connections.length,
+          examples: connections.slice(0, 5).map(c => `${c.request} → ${c.route}`)
+        });
       }
 
       return createSuccessResult(
@@ -136,41 +167,67 @@ export class HTTPConnectionEnricher extends Plugin {
       );
 
     } catch (error) {
-      console.error(`[HTTPConnectionEnricher] Error:`, error);
+      logger.error('Error in HTTPConnectionEnricher', { error });
       return createErrorResult(error instanceof Error ? error : new Error(String(error)));
     }
   }
 
   /**
-   * Проверяет совпадают ли пути
-   * Поддерживает параметризованные пути: /api/users/:id матчится с /api/users/123
+   * Normalize URL to canonical form for comparison.
+   * Converts both Express params (:id) and template literals (${...}) to {param}.
+   */
+  private normalizeUrl(url: string): string {
+    return url
+      .replace(/:[^/]+/g, '{param}')      // :id -> {param}
+      .replace(/\$\{[^}]*\}/g, '{param}'); // ${...} -> {param}, ${userId} -> {param}
+  }
+
+  /**
+   * Check if URL has any parameter placeholders (after normalization)
+   */
+  private hasParamsNormalized(normalizedUrl: string): boolean {
+    return normalizedUrl.includes('{param}');
+  }
+
+  /**
+   * Check if request URL matches route path.
+   * Supports:
+   * - Exact match
+   * - Express params (:id)
+   * - Template literals (${...})
+   * - Concrete values matching params (/users/123 matches /users/:id)
    */
   private pathsMatch(requestUrl: string, routePath: string): boolean {
-    // Точное совпадение
-    if (requestUrl === routePath) {
+    // Normalize both to canonical form
+    const normRequest = this.normalizeUrl(requestUrl);
+    const normRoute = this.normalizeUrl(routePath);
+
+    // If both normalize to same string, they match
+    if (normRequest === normRoute) {
       return true;
     }
 
-    // Если route не имеет параметров, требуем точное совпадение
-    if (!this.hasParams(routePath)) {
+    // If route has no params after normalization, require exact match
+    if (!this.hasParamsNormalized(normRoute)) {
       return false;
     }
 
-    // Преобразуем route path в regex
-    // /api/users/:id → /api/users/[^/]+
-    const regexPattern = routePath
-      .replace(/:[^/]+/g, '[^/]+')  // :param → [^/]+
-      .replace(/\//g, '\\/');        // / → \/
+    // Handle case where request has concrete value (e.g., '/users/123')
+    // and route has param (e.g., '/users/{param}')
+    const routeRegex = normRoute
+      .replace(/\{param\}/g, '[^/]+')  // {param} -> [^/]+
+      .replace(/\//g, '\\/');           // / -> \/
 
-    const regex = new RegExp(`^${regexPattern}$`);
-    return regex.test(requestUrl);
+    return new RegExp(`^${routeRegex}$`).test(normRequest);
   }
 
   /**
-   * Проверяет есть ли параметры в пути
+   * Check if path has parameters (for edge matchType metadata)
    */
   private hasParams(path: string): boolean {
-    return Boolean(path && path.includes(':'));
+    if (!path) return false;
+    // Check for Express params or template literals
+    return path.includes(':') || path.includes('${');
   }
 
   /**