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

package/src/plugins/enrichment/MountPointResolver.ts

@@ -1,38 +1,49 @@
 /**
  * MountPointResolver - ENRICHMENT plugin for resolving mount points
  *
- * Updates ENDPOINT nodes by adding fullPath based on MOUNT_POINT prefixes.
+ * REG-248 Fix: Now works with ExpressRouteAnalyzer's node types:
+ * - express:middleware (with mountPath) instead of MOUNT_POINT
+ * - http:route instead of ENDPOINT
  *
- * Graph traversal:
- * MOUNT_POINT --MOUNTS--> MODULE --EXPOSES--> ENDPOINT
+ * REG-318 Fix: Uses IMPORT nodes to determine which file a router variable
+ * comes from, then applies mount prefix ONLY to routes in that specific file.
  *
- * Updates:
- * endpoint.fullPath = mountPoint.prefix + endpoint.localPath
+ * Algorithm:
+ * 1. Find express:middleware nodes with mountPath
+ * 2. Build import map: for each mount file, map local variable names to resolved file paths
+ * 3. For each mount, find the specific imported file matching mount.name
+ * 4. Apply mount prefix only to routes in that specific file
  */
 
 import { Plugin } from '../Plugin.js';
 import { createSuccessResult, createErrorResult } from '@grafema/types';
-import type { PluginMetadata, PluginContext, PluginResult, GraphBackend } from '@grafema/types';
+import type { PluginMetadata, PluginContext, PluginResult } from '@grafema/types';
 import type { BaseNodeRecord } from '@grafema/types';
-import type { EdgeRecord } from '@grafema/types';
-
-interface EdgeCriteria {
-  type?: string;
-  src?: string;
-  dst?: string;
-}
-
-interface MountPointNode extends BaseNodeRecord {
-  prefix: string;
+import { dirname, resolve, join } from 'path';
+import { existsSync } from 'fs';
+
+interface MountNode {
+  id: string;
+  type: string;
+  mountPath?: string;
+  prefix?: string;  // Alternative field used by express:mount
+  name?: string;    // The imported router variable name
+  file?: string;
+  [key: string]: unknown;
 }
 
-interface EndpointNode extends BaseNodeRecord {
-  localPath?: string;
+interface RouteNode {
+  id: string;
+  type: string;
   path?: string;
+  fullPath?: string;
+  localPath?: string;
+  mountPrefix?: string;
   mountPrefixes?: string[];
   fullPaths?: string[];
-  mountPrefix?: string;
-  fullPath?: string;
+  file?: string;
+  routerName?: string;
+  [key: string]: unknown;
 }
 
 export class MountPointResolver extends Plugin {
@@ -42,223 +53,225 @@ export class MountPointResolver extends Plugin {
       phase: 'ENRICHMENT',
       priority: 90,  // High priority - one of first enrichment plugins
       creates: {
-        nodes: [],  // Doesn't create new nodes
-        edges: []   // Doesn't create new edges
+        nodes: [],  // Updates existing nodes
+        edges: []   // Doesn't create edges
       },
-      dependencies: ['JSModuleIndexer', 'JSASTAnalyzer']
+      dependencies: ['JSModuleIndexer', 'JSASTAnalyzer', 'ExpressRouteAnalyzer']
     };
   }
 
+  /**
+   * Resolve relative import source to absolute file path.
+   * Replicates JSModuleIndexer.resolveModulePath() logic.
+   */
+  private resolveImportSource(importSource: string, containingFile: string): string | null {
+    // Only handle relative imports
+    if (!importSource.startsWith('./') && !importSource.startsWith('../')) {
+      return null;  // External package
+    }
+
+    const dir = dirname(containingFile);
+    const basePath = resolve(dir, importSource);
+
+    // Try direct path
+    if (existsSync(basePath)) return basePath;
+
+    // Try extensions
+    for (const ext of ['.js', '.mjs', '.jsx', '.ts', '.tsx']) {
+      if (existsSync(basePath + ext)) return basePath + ext;
+    }
+
+    // Try index files
+    for (const indexFile of ['index.js', 'index.ts', 'index.mjs', 'index.tsx']) {
+      const indexPath = join(basePath, indexFile);
+      if (existsSync(indexPath)) return indexPath;
+    }
+
+    return null;
+  }
+
   async execute(context: PluginContext): Promise<PluginResult> {
     try {
       const { graph } = context;
+      const logger = this.log(context);
 
-      let endpointsUpdated = 0;
+      let routesUpdated = 0;
       let mountPointsProcessed = 0;
 
-      // Find all MOUNT_POINT nodes
-      const allNodes = await graph.getAllNodes();
-      const mountPoints = allNodes.filter(node => node.type === 'MOUNT_POINT') as MountPointNode[];
-
-      console.log(`[MountPointResolver] Found ${mountPoints.length} mount points`);
-
-      // For each top-level mount point (from app.use in index.js)
-      // apply recursive resolver
-      const processedMountPoints = new Set<string>();
+      // Step 1: Find all mount points (express:middleware with mountPath)
+      const mountNodes: MountNode[] = [];
+      for await (const node of graph.queryNodes({ type: 'express:middleware' })) {
+        const mount = node as MountNode;
+        // Only include mounts with a meaningful path (not global middleware)
+        if (mount.mountPath && mount.mountPath !== '/' && mount.name) {
+          mountNodes.push(mount);
+        }
+      }
 
-      for (const mountPoint of mountPoints) {
-        if (!processedMountPoints.has(mountPoint.id)) {
-          const updated = await this.resolveMountPoint(graph, mountPoint, '', processedMountPoints);
-          endpointsUpdated += updated;
-          mountPointsProcessed++;
+      // Also check for express:mount (from ExpressAnalyzer, if enabled)
+      for await (const node of graph.queryNodes({ type: 'express:mount' })) {
+        const mount = node as MountNode;
+        if (mount.mountPath || (mount as { prefix?: string }).prefix) {
+          // express:mount uses 'prefix' field
+          const prefix = mount.mountPath || (mount as { prefix?: string }).prefix;
+          if (prefix && prefix !== '/') {
+            mountNodes.push({
+              ...mount,
+              mountPath: prefix
+            });
+          }
         }
       }
 
-      // Fallback: process mount points without recursion (old logic for compatibility)
-      for (const mountPoint of mountPoints) {
-        if (processedMountPoints.has(mountPoint.id)) continue;
-        // Find MOUNT_POINT --MOUNTS--> MODULE edge
-        const mountsEdges = await this.findEdges(graph, {
-          type: 'MOUNTS',
-          src: mountPoint.id
-        });
+      logger.info('Found mount points', { count: mountNodes.length });
 
-        for (const mountsEdge of mountsEdges) {
-          const targetModuleId = mountsEdge.dst;
+      // Debug: log mount point details
+      for (const mount of mountNodes) {
+        logger.debug('Mount point details', {
+          id: mount.id,
+          mountPath: mount.mountPath,
+          name: mount.name,
+          file: mount.file
+        });
+      }
 
-          // Find MODULE --EXPOSES--> ENDPOINT edges
-          const exposesEdges = await this.findEdges(graph, {
-            type: 'EXPOSES',
-            src: targetModuleId
-          });
+      if (mountNodes.length === 0) {
+        return createSuccessResult(
+          { nodes: 0, edges: 0 },
+          { routesUpdated: 0, mountPointsProcessed: 0 }
+        );
+      }
 
-          for (const exposesEdge of exposesEdges) {
-            const endpointId = exposesEdge.dst;
-            const endpoint = await graph.getNode(endpointId) as EndpointNode | null;
-
-            if (endpoint && endpoint.type === 'ENDPOINT') {
-              // Support multiple mount points for one endpoint
-              // Store all prefixes and fullPaths in arrays
-              const mountPrefixes = endpoint.mountPrefixes || [];
-              const fullPaths = endpoint.fullPaths || [];
-
-              const prefix = mountPoint.prefix;
-              const fullPath = prefix + (endpoint.localPath || endpoint.path || '');
-
-              // Only add if not already added (avoid duplicates)
-              if (!mountPrefixes.includes(prefix)) {
-                mountPrefixes.push(prefix);
-                fullPaths.push(fullPath);
-              }
-
-              // Update endpoint node
-              const updatedEndpoint: EndpointNode = {
-                ...endpoint,
-                mountPrefixes,
-                fullPaths,
-                mountPrefix: endpoint.mountPrefix || prefix,
-                fullPath: endpoint.fullPath || fullPath
-              };
-
-              await graph.addNode(updatedEndpoint);
-              endpointsUpdated++;
-            }
+      // Step 2: Build import map for files that contain mount points
+      // Map<file, Map<localName, resolvedFile>>
+      const importMaps = new Map<string, Map<string, string>>();
+      const mountFiles = new Set(mountNodes.map(m => m.file).filter((f): f is string => Boolean(f)));
+
+      for (const mountFile of mountFiles) {
+        const importMap = new Map<string, string>();
+
+        // Query IMPORT nodes in this file
+        for await (const node of graph.queryNodes({ type: 'IMPORT' })) {
+          const importNode = node as { file?: string; local?: string; source?: string };
+
+          if (importNode.file !== mountFile) continue;
+          if (!importNode.local || !importNode.source) continue;
+
+          // Resolve source to absolute path
+          const resolvedPath = this.resolveImportSource(importNode.source, mountFile);
+          if (resolvedPath) {
+            importMap.set(importNode.local, resolvedPath);
+            logger.debug('Import mapped', {
+              local: importNode.local,
+              source: importNode.source,
+              resolved: resolvedPath
+            });
           }
         }
 
-        mountPointsProcessed++;
+        importMaps.set(mountFile, importMap);
       }
 
-      console.log(`[MountPointResolver] Updated ${endpointsUpdated} endpoints from ${mountPointsProcessed} mount points`);
+      logger.debug('Import maps built', {
+        files: importMaps.size,
+        totalMappings: [...importMaps.values()].reduce((sum, m) => sum + m.size, 0)
+      });
 
-      return createSuccessResult(
-        { nodes: 0, edges: 0 },
-        { endpointsUpdated, mountPointsProcessed }
-      );
+      // Step 3: Collect all routes by file
+      const routesByFile = new Map<string, RouteNode[]>();
+      for await (const node of graph.queryNodes({ type: 'http:route' })) {
+        const route = node as RouteNode;
+        if (route.file) {
+          if (!routesByFile.has(route.file)) {
+            routesByFile.set(route.file, []);
+          }
+          routesByFile.get(route.file)!.push(route);
+        }
+      }
 
-    } catch (error) {
-      console.error(`[MountPointResolver] Error:`, error);
-      return createErrorResult(error as Error);
-    }
-  }
+      // Step 4: For each mount point, find and update routes
+      for (const mount of mountNodes) {
+        if (!mount.file || !mount.mountPath || !mount.name) continue;
 
-  /**
-   * Recursively resolve mount point and all nested mount points
-   */
-  private async resolveMountPoint(
-    graph: GraphBackend,
-    mountPoint: MountPointNode,
-    parentPrefix: string,
-    processedMountPoints: Set<string>
-  ): Promise<number> {
-    let endpointsUpdated = 0;
-
-    // Mark as processed
-    processedMountPoints.add(mountPoint.id);
-
-    // Calculate full prefix (parent + current)
-    const fullPrefix = parentPrefix + mountPoint.prefix;
-
-    // Find MOUNT_POINT --MOUNTS--> MODULE edge
-    const mountsEdges = await this.findEdges(graph, {
-      type: 'MOUNTS',
-      src: mountPoint.id
-    });
-
-    for (const mountsEdge of mountsEdges) {
-      const targetModuleId = mountsEdge.dst;
-
-      // 1. Process ENDPOINT in this module
-      const exposesEdges = await this.findEdges(graph, {
-        type: 'EXPOSES',
-        src: targetModuleId
-      });
+        // Get import map for this file
+        const importMap = importMaps.get(mount.file);
+        if (!importMap) {
+          logger.debug('No import map for mount file', { file: mount.file });
+          continue;
+        }
 
-      for (const exposesEdge of exposesEdges) {
-        const endpointId = exposesEdge.dst;
-        const endpoint = await graph.getNode(endpointId) as EndpointNode | null;
+        // Find the specific imported file for this mount variable
+        const importedFile = importMap.get(mount.name);
+        if (!importedFile) {
+          logger.debug('No import found for mount name', {
+            file: mount.file,
+            mountName: mount.name,
+            availableImports: [...importMap.keys()]
+          });
+          continue;
+        }
 
-        if (endpoint && endpoint.type === 'ENDPOINT') {
-          // Support multiple mount points
-          const mountPrefixes = endpoint.mountPrefixes || [];
-          const fullPaths = endpoint.fullPaths || [];
+        // Get routes in that specific file
+        const routes = routesByFile.get(importedFile);
+        if (!routes || routes.length === 0) {
+          logger.debug('No routes in imported file', {
+            importedFile,
+            mountName: mount.name
+          });
+          continue;
+        }
+
+        logger.debug('Applying mount prefix', {
+          mountPath: mount.mountPath,
+          mountName: mount.name,
+          importedFile,
+          routeCount: routes.length
+        });
+
+        // Update routes with fullPath
+        for (const route of routes) {
+          const localPath = route.localPath || route.path || '';
+          const fullPath = mount.mountPath + localPath;
 
-          const fullPath = fullPrefix + (endpoint.localPath || endpoint.path || '');
+          // Support multiple mount points
+          const mountPrefixes = route.mountPrefixes || [];
+          const fullPaths = route.fullPaths || [];
 
-          // Only add if not already added
-          if (!mountPrefixes.includes(fullPrefix)) {
-            mountPrefixes.push(fullPrefix);
+          if (!mountPrefixes.includes(mount.mountPath)) {
+            mountPrefixes.push(mount.mountPath);
             fullPaths.push(fullPath);
           }
 
-          // Update endpoint node with new data
-          const updatedEndpoint: EndpointNode = {
-            ...endpoint,
+          // Update route node
+          const updatedRoute: RouteNode = {
+            ...route,
             mountPrefixes,
             fullPaths,
-            mountPrefix: endpoint.mountPrefix || fullPrefix,
-            fullPath: endpoint.fullPath || fullPath
+            mountPrefix: route.mountPrefix || mount.mountPath,
+            fullPath: route.fullPath || fullPath
           };
 
-          await graph.addNode(updatedEndpoint);
-          endpointsUpdated++;
+          await graph.addNode(updatedRoute as BaseNodeRecord);
+          routesUpdated++;
         }
-      }
 
-      // 2. Recursively process nested MOUNT_POINT in this module
-      const definesEdges = await this.findEdges(graph, {
-        type: 'DEFINES',
-        src: targetModuleId
-      });
-
-      for (const definesEdge of definesEdges) {
-        const nestedMountPointId = definesEdge.dst;
-        const nestedMountPoint = await graph.getNode(nestedMountPointId) as MountPointNode | null;
-
-        if (nestedMountPoint && nestedMountPoint.type === 'MOUNT_POINT' &&
-            !processedMountPoints.has(nestedMountPointId)) {
-          // Recursively process nested mount point
-          endpointsUpdated += await this.resolveMountPoint(
-            graph,
-            nestedMountPoint,
-            fullPrefix,  // Pass accumulated prefix
-            processedMountPoints
-          );
-        }
+        mountPointsProcessed++;
       }
-    }
-
-    return endpointsUpdated;
-  }
-
-  /**
-   * Helper method for finding edges by criteria
-   */
-  private async findEdges(graph: GraphBackend, criteria: EdgeCriteria): Promise<EdgeRecord[]> {
-    const result: EdgeRecord[] = [];
 
-    // Get all edges using RFDBServerBackend API
-    if (!graph.getAllEdges) {
-      return result;
-    }
-    const allEdges = await graph.getAllEdges();
-
-    for (const edge of allEdges) {
-      let matches = true;
+      logger.info('Updated routes with mount prefixes', {
+        routes: routesUpdated,
+        mountPoints: mountPointsProcessed
+      });
 
-      for (const [key, value] of Object.entries(criteria)) {
-        const edgeRecord = edge as unknown as Record<string, unknown>;
-        if (edgeRecord[key] !== value) {
-          matches = false;
-          break;
-        }
-      }
+      return createSuccessResult(
+        { nodes: 0, edges: 0 },
+        { routesUpdated, mountPointsProcessed }
+      );
 
-      if (matches) {
-        result.push(edge);
-      }
+    } catch (error) {
+      const logger = this.log(context);
+      logger.error('Error in MountPointResolver', { error });
+      return createErrorResult(error as Error);
     }
-
-    return result;
   }
 }