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

package/dist/plugins/enrichment/HTTPConnectionEnricher.js

@@ -17,13 +17,14 @@ 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) {
         const { graph } = context;
+        const logger = this.log(context);
         try {
             // Собираем все http:route (backend endpoints)
             const routes = [];
@@ -35,11 +36,17 @@ export class HTTPConnectionEnricher extends Plugin {
             for await (const node of graph.queryNodes({ type: 'http:request' })) {
                 requests.push(node);
             }
-            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 = [];
             // Для каждого request ищем matching route
@@ -53,32 +60,52 @@ 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,
                             dst: route.id,
                             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}`,
                             requestFile: request.file,
                             routeFile: route.file
                         });
-                        edgesCreated++;
                         break; // Один request → один route
                     }
                 }
             }
             // Логируем найденные связи
             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({ nodes: 0, edges: edgesCreated }, {
                 connections: connections.length,
@@ -87,36 +114,60 @@ 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}.
+     */
+    normalizeUrl(url) {
+        return url
+            .replace(/:[^/]+/g, '{param}') // :id -> {param}
+            .replace(/\$\{[^}]*\}/g, '{param}'); // ${...} -> {param}, ${userId} -> {param}
+    }
+    /**
+     * Check if URL has any parameter placeholders (after normalization)
+     */
+    hasParamsNormalized(normalizedUrl) {
+        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)
      */
     pathsMatch(requestUrl, routePath) {
-        // Точное совпадение
-        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, '\\/'); // / → \/
-        const regex = new RegExp(`^${regexPattern}$`);
-        return regex.test(requestUrl);
+        // 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, '\\/'); // / -> \/
+        return new RegExp(`^${routeRegex}$`).test(normRequest);
     }
     /**
-     * Проверяет есть ли параметры в пути
+     * Check if path has parameters (for edge matchType metadata)
      */
     hasParams(path) {
-        return Boolean(path && path.includes(':'));
+        if (!path)
+            return false;
+        // Check for Express params or template literals
+        return path.includes(':') || path.includes('${');
     }
     /**
      * Убирает дубликаты по ID

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

@@ -1 +1 @@
-{"version":3,"file":"ImportExportLinker.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/ImportExportLinker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAmBhF,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAyH5D;;;OAGG;YACW,gBAAgB;IA+B9B;;OAEG;YACW,iBAAiB;CAWhC"}
+{"version":3,"file":"ImportExportLinker.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/ImportExportLinker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAmBhF,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA2I5D;;;OAGG;YACW,gBAAgB;IA+B9B;;OAEG;YACW,iBAAiB;CAWhC"}

package/dist/plugins/enrichment/ImportExportLinker.js

@@ -22,28 +22,29 @@ export class ImportExportLinker extends Plugin {
             priority: 90, // Run early in enrichment, after analysis
             creates: {
                 nodes: [],
-                edges: ['IMPORTS_FROM']
+                edges: ['IMPORTS', 'IMPORTS_FROM']
             },
             dependencies: ['JSASTAnalyzer'] // Requires IMPORT and EXPORT nodes
         };
     }
     async execute(context) {
         const { graph, onProgress } = context;
-        console.log('[ImportExportLinker] Starting import-export linking...');
+        const logger = this.log(context);
+        logger.info('Starting import-export linking');
         const startTime = Date.now();
         // Step 1: Build EXPORT index - Map<file, Map<exportKey, exportNode>>
         const exportIndex = await this.buildExportIndex(graph);
         const indexTime = Date.now() - startTime;
-        console.log(`[ImportExportLinker] Indexed exports from ${exportIndex.size} files in ${indexTime}ms`);
+        logger.debug('Indexed exports', { files: exportIndex.size, time: `${indexTime}ms` });
         // Step 2: Build MODULE lookup - Map<file, moduleNode>
         const modulesByFile = await this.buildModuleLookup(graph);
-        console.log(`[ImportExportLinker] Indexed ${modulesByFile.size} modules`);
+        logger.debug('Indexed modules', { count: modulesByFile.size });
         // Step 3: Process all IMPORT nodes
         const imports = [];
         for await (const node of graph.queryNodes({ nodeType: 'IMPORT' })) {
             imports.push(node);
         }
-        console.log(`[ImportExportLinker] Found ${imports.length} imports to link`);
+        logger.info('Found imports to link', { count: imports.length });
         let edgesCreated = 0;
         let skipped = 0;
         let notFound = 0;
@@ -90,6 +91,17 @@ export class ImportExportLinker extends Plugin {
                 notFound++;
                 continue;
             }
+            // Create MODULE -> IMPORTS -> MODULE edge for relative imports
+            const sourceModule = modulesByFile.get(imp.file);
+            const targetModule = modulesByFile.get(targetFile);
+            if (sourceModule && targetModule) {
+                await graph.addEdge({
+                    type: 'IMPORTS',
+                    src: sourceModule.id,
+                    dst: targetModule.id
+                });
+                edgesCreated++;
+            }
             // Find matching export based on import type
             const importType = imp.importType; // 'default', 'named', or 'namespace'
             let targetExport;
@@ -120,7 +132,12 @@ export class ImportExportLinker extends Plugin {
             }
         }
         const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
-        console.log(`[ImportExportLinker] Complete: ${edgesCreated} edges created, ${skipped} skipped, ${notFound} not found (${totalTime}s)`);
+        logger.info('Complete', {
+            edgesCreated,
+            skipped,
+            notFound,
+            time: `${totalTime}s`
+        });
         return createSuccessResult({ nodes: 0, edges: edgesCreated }, {
             importsProcessed: imports.length,
             edgesCreated,

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

@@ -1 +1 @@
-{"version":3,"file":"MethodCallResolver.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/MethodCallResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAmBhF,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C,OAAO,CAAC,qBAAqB,CAAC,CAAqC;IAEnE,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA8F5D;;OAEG;YACW,qBAAqB;IA0CnC;;OAEG;YACW,sBAAsB;IAkBpC;;OAEG;YACW,iBAAiB;IA0D/B;;OAEG;YACW,mBAAmB;YAqBnB,4BAA4B;IAyB1C;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAWzB"}
+{"version":3,"file":"MethodCallResolver.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/MethodCallResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAoBhF,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C,OAAO,CAAC,qBAAqB,CAAC,CAAqC;IAEnE,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAuH5D;;OAEG;YACW,qBAAqB;IA0CnC;;OAEG;YACW,sBAAsB;IAkBpC;;OAEG;YACW,iBAAiB;IA0D/B;;OAEG;YACW,mBAAmB;YAqBnB,4BAA4B;IAyB1C;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAWzB"}

package/dist/plugins/enrichment/MethodCallResolver.js

@@ -11,6 +11,7 @@
  * - METHOD_CALL -> CALLS -> FUNCTION (для методов объектов)
  */
 import { Plugin, createSuccessResult } from '../Plugin.js';
+import { StrictModeError } from '../../errors/GrafemaError.js';
 export class MethodCallResolver extends Plugin {
     _containingClassCache;
     get metadata() {
@@ -26,10 +27,12 @@ export class MethodCallResolver extends Plugin {
     }
     async execute(context) {
         const { graph, onProgress } = context;
-        console.log('[MethodCallResolver] Starting method call resolution...');
+        const logger = this.log(context);
+        logger.info('Starting method call resolution');
         let methodCallsProcessed = 0;
         let edgesCreated = 0;
         let unresolved = 0;
+        const errors = [];
         // Собираем все METHOD_CALL ноды (CALL с object атрибутом)
         const methodCalls = [];
         for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
@@ -38,12 +41,12 @@ export class MethodCallResolver extends Plugin {
                 methodCalls.push(callNode);
             }
         }
-        console.log(`[MethodCallResolver] Found ${methodCalls.length} method calls to resolve`);
+        logger.info('Found method calls to resolve', { count: methodCalls.length });
         // Собираем все классы и их методы для быстрого поиска
-        const classMethodIndex = await this.buildClassMethodIndex(graph);
-        console.log(`[MethodCallResolver] Indexed ${classMethodIndex.size} classes`);
+        const classMethodIndex = await this.buildClassMethodIndex(graph, logger);
+        logger.info('Indexed classes', { count: classMethodIndex.size });
         // Собираем переменные и их типы (если известны)
-        const variableTypes = await this.buildVariableTypeIndex(graph);
+        const variableTypes = await this.buildVariableTypeIndex(graph, logger);
         const startTime = Date.now();
         for (const methodCall of methodCalls) {
             methodCallsProcessed++;
@@ -62,7 +65,12 @@ export class MethodCallResolver extends Plugin {
             if (methodCallsProcessed % 10 === 0) {
                 const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
                 const avgTime = ((Date.now() - startTime) / methodCallsProcessed).toFixed(0);
-                console.log(`[MethodCallResolver] Progress: ${methodCallsProcessed}/${methodCalls.length} (${elapsed}s, avg ${avgTime}ms/call)`);
+                logger.debug('Progress', {
+                    processed: methodCallsProcessed,
+                    total: methodCalls.length,
+                    elapsed: `${elapsed}s`,
+                    avgTime: `${avgTime}ms/call`
+                });
             }
             // Пропускаем внешние методы (console, Array.prototype, etc.)
             if (this.isExternalMethod(methodCall.object, methodCall.method)) {
@@ -85,6 +93,18 @@ export class MethodCallResolver extends Plugin {
             }
             else {
                 unresolved++;
+                // In strict mode, collect error for later reporting
+                if (context.strictMode) {
+                    const error = new StrictModeError(`Cannot resolve method call: ${methodCall.object}.${methodCall.method}`, 'STRICT_UNRESOLVED_METHOD', {
+                        filePath: methodCall.file,
+                        lineNumber: methodCall.line,
+                        phase: 'ENRICHMENT',
+                        plugin: 'MethodCallResolver',
+                        object: methodCall.object,
+                        method: methodCall.method,
+                    }, `Check if class "${methodCall.object}" is imported and has method "${methodCall.method}"`);
+                    errors.push(error);
+                }
             }
         }
         const summary = {
@@ -93,20 +113,20 @@ export class MethodCallResolver extends Plugin {
             unresolved,
             classesIndexed: classMethodIndex.size
         };
-        console.log('[MethodCallResolver] Summary:', summary);
-        return createSuccessResult({ nodes: 0, edges: edgesCreated }, summary);
+        logger.info('Summary', summary);
+        return createSuccessResult({ nodes: 0, edges: edgesCreated }, summary, errors);
     }
     /**
      * Строит индекс классов и их методов
      */
-    async buildClassMethodIndex(graph) {
+    async buildClassMethodIndex(graph, logger) {
         const index = new Map();
         const startTime = Date.now();
         let classCount = 0;
         for await (const classNode of graph.queryNodes({ nodeType: 'CLASS' })) {
             classCount++;
             if (classCount % 50 === 0) {
-                console.log(`[MethodCallResolver] Indexing classes: ${classCount}...`);
+                logger.debug('Indexing classes', { count: classCount });
             }
             const className = classNode.name;
             if (!className)
@@ -130,13 +150,13 @@ export class MethodCallResolver extends Plugin {
             index.set(fileKey, classEntry);
         }
         const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
-        console.log(`[MethodCallResolver] Indexed ${index.size} class entries in ${totalTime}s`);
+        logger.debug('Indexed class entries', { count: index.size, time: `${totalTime}s` });
         return index;
     }
     /**
      * Строит индекс переменных и их типов (из INSTANCE_OF рёбер)
      */
-    async buildVariableTypeIndex(graph) {
+    async buildVariableTypeIndex(graph, logger) {
         const startTime = Date.now();
         const index = new Map();
         for await (const classNode of graph.queryNodes({ nodeType: 'CLASS' })) {
@@ -148,7 +168,7 @@ export class MethodCallResolver extends Plugin {
             }
         }
         const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
-        console.log(`[MethodCallResolver] Built variable type index: ${index.size} entries in ${elapsed}s`);
+        logger.debug('Built variable type index', { entries: index.size, time: `${elapsed}s` });
         return index;
     }
     /**

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

@@ -1,26 +1,28 @@
 /**
  * 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 type { PluginMetadata, PluginContext, PluginResult } from '@grafema/types';
 export declare class MountPointResolver extends Plugin {
     get metadata(): PluginMetadata;
-    execute(context: PluginContext): Promise<PluginResult>;
-    /**
-     * Recursively resolve mount point and all nested mount points
-     */
-    private resolveMountPoint;
     /**
-     * Helper method for finding edges by criteria
+     * Resolve relative import source to absolute file path.
+     * Replicates JSModuleIndexer.resolveModulePath() logic.
      */
-    private findEdges;
+    private resolveImportSource;
+    execute(context: PluginContext): Promise<PluginResult>;
 }
 //# sourceMappingURL=MountPointResolver.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"MountPointResolver.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/MountPointResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,YAAY,EAAgB,MAAM,gBAAgB,CAAC;AAuBhG,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA6F5D;;OAEG;YACW,iBAAiB;IAsF/B;;OAEG;YACW,SAAS;CA2BxB"}
+{"version":3,"file":"MountPointResolver.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/MountPointResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AA6BlF,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAED;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IA0BrB,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAwL7D"}