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

package/dist/plugins/enrichment/MountPointResolver.js

@@ -1,16 +1,23 @@
 /**
  * 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 { dirname, resolve, join } from 'path';
+import { existsSync } from 'fs';
 export class MountPointResolver extends Plugin {
     get metadata() {
         return {
@@ -18,172 +25,191 @@ 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.
+     */
+    resolveImportSource(importSource, containingFile) {
+        // 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) {
         try {
             const { graph } = context;
-            let endpointsUpdated = 0;
+            const logger = this.log(context);
+            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');
-            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();
-            for (const mountPoint of mountPoints) {
-                if (!processedMountPoints.has(mountPoint.id)) {
-                    const updated = await this.resolveMountPoint(graph, mountPoint, '', processedMountPoints);
-                    endpointsUpdated += updated;
-                    mountPointsProcessed++;
+            // Step 1: Find all mount points (express:middleware with mountPath)
+            const mountNodes = [];
+            for await (const node of graph.queryNodes({ type: 'express:middleware' })) {
+                const mount = node;
+                // Only include mounts with a meaningful path (not global middleware)
+                if (mount.mountPath && mount.mountPath !== '/' && mount.name) {
+                    mountNodes.push(mount);
                 }
             }
-            // 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
+            // Also check for express:mount (from ExpressAnalyzer, if enabled)
+            for await (const node of graph.queryNodes({ type: 'express:mount' })) {
+                const mount = node;
+                if (mount.mountPath || mount.prefix) {
+                    // express:mount uses 'prefix' field
+                    const prefix = mount.mountPath || mount.prefix;
+                    if (prefix && prefix !== '/') {
+                        mountNodes.push({
+                            ...mount,
+                            mountPath: prefix
+                        });
+                    }
+                }
+            }
+            logger.info('Found mount points', { count: mountNodes.length });
+            // 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
                 });
-                for (const mountsEdge of mountsEdges) {
-                    const targetModuleId = mountsEdge.dst;
-                    // Find MODULE --EXPOSES--> ENDPOINT edges
-                    const exposesEdges = await this.findEdges(graph, {
-                        type: 'EXPOSES',
-                        src: targetModuleId
-                    });
-                    for (const exposesEdge of exposesEdges) {
-                        const endpointId = exposesEdge.dst;
-                        const endpoint = await graph.getNode(endpointId);
-                        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 = {
-                                ...endpoint,
-                                mountPrefixes,
-                                fullPaths,
-                                mountPrefix: endpoint.mountPrefix || prefix,
-                                fullPath: endpoint.fullPath || fullPath
-                            };
-                            await graph.addNode(updatedEndpoint);
-                            endpointsUpdated++;
-                        }
+            }
+            if (mountNodes.length === 0) {
+                return createSuccessResult({ nodes: 0, edges: 0 }, { routesUpdated: 0, mountPointsProcessed: 0 });
+            }
+            // Step 2: Build import map for files that contain mount points
+            // Map<file, Map<localName, resolvedFile>>
+            const importMaps = new Map();
+            const mountFiles = new Set(mountNodes.map(m => m.file).filter((f) => Boolean(f)));
+            for (const mountFile of mountFiles) {
+                const importMap = new Map();
+                // Query IMPORT nodes in this file
+                for await (const node of graph.queryNodes({ type: 'IMPORT' })) {
+                    const importNode = node;
+                    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`);
-            return createSuccessResult({ nodes: 0, edges: 0 }, { endpointsUpdated, mountPointsProcessed });
-        }
-        catch (error) {
-            console.error(`[MountPointResolver] Error:`, error);
-            return createErrorResult(error);
-        }
-    }
-    /**
-     * Recursively resolve mount point and all nested mount points
-     */
-    async resolveMountPoint(graph, mountPoint, parentPrefix, processedMountPoints) {
-        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
+            logger.debug('Import maps built', {
+                files: importMaps.size,
+                totalMappings: [...importMaps.values()].reduce((sum, m) => sum + m.size, 0)
             });
-            for (const exposesEdge of exposesEdges) {
-                const endpointId = exposesEdge.dst;
-                const endpoint = await graph.getNode(endpointId);
-                if (endpoint && endpoint.type === 'ENDPOINT') {
+            // Step 3: Collect all routes by file
+            const routesByFile = new Map();
+            for await (const node of graph.queryNodes({ type: 'http:route' })) {
+                const route = node;
+                if (route.file) {
+                    if (!routesByFile.has(route.file)) {
+                        routesByFile.set(route.file, []);
+                    }
+                    routesByFile.get(route.file).push(route);
+                }
+            }
+            // Step 4: For each mount point, find and update routes
+            for (const mount of mountNodes) {
+                if (!mount.file || !mount.mountPath || !mount.name)
+                    continue;
+                // 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;
+                }
+                // 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;
+                }
+                // 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;
                     // Support multiple mount points
-                    const mountPrefixes = endpoint.mountPrefixes || [];
-                    const fullPaths = endpoint.fullPaths || [];
-                    const fullPath = fullPrefix + (endpoint.localPath || endpoint.path || '');
-                    // Only add if not already added
-                    if (!mountPrefixes.includes(fullPrefix)) {
-                        mountPrefixes.push(fullPrefix);
+                    const mountPrefixes = route.mountPrefixes || [];
+                    const fullPaths = route.fullPaths || [];
+                    if (!mountPrefixes.includes(mount.mountPath)) {
+                        mountPrefixes.push(mount.mountPath);
                         fullPaths.push(fullPath);
                     }
-                    // Update endpoint node with new data
-                    const updatedEndpoint = {
-                        ...endpoint,
+                    // Update route node
+                    const updatedRoute = {
+                        ...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);
+                    routesUpdated++;
                 }
+                mountPointsProcessed++;
             }
-            // 2. Recursively process nested MOUNT_POINT in this module
-            const definesEdges = await this.findEdges(graph, {
-                type: 'DEFINES',
-                src: targetModuleId
+            logger.info('Updated routes with mount prefixes', {
+                routes: routesUpdated,
+                mountPoints: mountPointsProcessed
             });
-            for (const definesEdge of definesEdges) {
-                const nestedMountPointId = definesEdge.dst;
-                const nestedMountPoint = await graph.getNode(nestedMountPointId);
-                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);
-                }
-            }
-        }
-        return endpointsUpdated;
-    }
-    /**
-     * Helper method for finding edges by criteria
-     */
-    async findEdges(graph, criteria) {
-        const result = [];
-        // Get all edges using RFDBServerBackend API
-        if (!graph.getAllEdges) {
-            return result;
+            return createSuccessResult({ nodes: 0, edges: 0 }, { routesUpdated, mountPointsProcessed });
         }
-        const allEdges = await graph.getAllEdges();
-        for (const edge of allEdges) {
-            let matches = true;
-            for (const [key, value] of Object.entries(criteria)) {
-                const edgeRecord = edge;
-                if (edgeRecord[key] !== value) {
-                    matches = false;
-                    break;
-                }
-            }
-            if (matches) {
-                result.push(edge);
-            }
+        catch (error) {
+            const logger = this.log(context);
+            logger.error('Error in MountPointResolver', { error });
+            return createErrorResult(error);
         }
-        return result;
     }
 }

package/dist/plugins/enrichment/NodejsBuiltinsResolver.d.ts

@@ -0,0 +1,44 @@
+/**
+ * NodejsBuiltinsResolver - Creates EXTERNAL_FUNCTION nodes for Node.js builtin calls (REG-218)
+ *
+ * This ENRICHMENT plugin:
+ * 1. Queries all CALL nodes
+ * 2. For each call that targets a builtin function:
+ *    - Checks if call's `object` matches a builtin module (fs, path, etc.)
+ *    - Or traces via IMPORT node to find the module source
+ * 3. Creates EXTERNAL_FUNCTION node lazily (if not exists)
+ * 4. Creates CALLS edge from CALL to EXTERNAL_FUNCTION
+ *
+ * Architecture:
+ * - Nodes are created lazily - only when a call is detected
+ * - ID format: EXTERNAL_FUNCTION:fs.readFile
+ * - Metadata includes: isBuiltin:true, security?, pure?
+ *
+ * Also creates:
+ * - EXTERNAL_MODULE nodes for imported builtin modules
+ * - IMPORTS_FROM edges from IMPORT to EXTERNAL_MODULE
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class NodejsBuiltinsResolver extends Plugin {
+    private registry;
+    constructor(config?: Record<string, unknown>);
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Build index of imports for tracking module sources.
+     *
+     * Maps: file:localName -> {source, imported, importNodeId, importType}
+     */
+    private buildImportIndex;
+    /**
+     * Resolve a CALL node to its builtin module and function.
+     *
+     * Handles:
+     * 1. Method calls: fs.readFile() -> {module: 'fs', function: 'readFile'}
+     * 2. Direct calls from imports: readFile() -> trace to import source
+     * 3. Aliased imports: rf() where rf = readFile from 'fs'
+     */
+    private resolveBuiltinCall;
+}
+//# sourceMappingURL=NodejsBuiltinsResolver.d.ts.map

package/dist/plugins/enrichment/NodejsBuiltinsResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodejsBuiltinsResolver.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/NodejsBuiltinsResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAsBhF,qBAAa,sBAAuB,SAAQ,MAAM;IAChD,OAAO,CAAC,QAAQ,CAAkB;gBAEtB,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;IAKhD,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA6K5D;;;;OAIG;YACW,gBAAgB;IA2C9B;;;;;;;OAOG;IACH,OAAO,CAAC,kBAAkB;CAsE3B"}