@grafema/core 0.2.3-beta → 0.2.5-beta

package/src/plugins/analysis/ExpressResponseAnalyzer.ts

@@ -13,16 +13,17 @@
  */
 
 import { readFileSync } from 'fs';
-import { parse, ParserPlugin } from '@babel/parser';
+import type { ParserPlugin } from '@babel/parser';
+import { parse } from '@babel/parser';
 import traverseModule from '@babel/traverse';
 import type { CallExpression, Identifier, MemberExpression, Node, ArrowFunctionExpression, FunctionExpression } from '@babel/types';
 import type { NodePath } from '@babel/traverse';
 import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 import type { NodeRecord } from '@grafema/types';
+import { NodeFactory } from '../../core/NodeFactory.js';
 import { getLine } from './ast/utils/location.js';
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const traverse = (traverseModule as any).default || traverseModule;
 
 const RESPONSE_METHODS = ['json', 'send'];
@@ -46,7 +47,6 @@ export class ExpressResponseAnalyzer extends Plugin {
     return {
       name: 'ExpressResponseAnalyzer',
       phase: 'ANALYSIS',
-      priority: 74, // After ExpressRouteAnalyzer (75)
       creates: {
         nodes: [],
         edges: ['RESPONDS_WITH']
@@ -70,21 +70,30 @@ export class ExpressResponseAnalyzer extends Plugin {
       logger.info('Processing routes', { count: routes.length });
 
       let edgesCreated = 0;
+      let nodesCreated = 0;
+      const allNodes: NodeRecord[] = [];
+      const allEdges: Array<{ type: string; src: string; dst: string; metadata?: unknown }> = [];
 
       for (const route of routes) {
-        const result = await this.analyzeRouteResponses(route, graph);
-        edgesCreated += result;
+        const result = await this.analyzeRouteResponses(route, graph, allNodes, allEdges);
+        edgesCreated += result.edges;
+        nodesCreated += result.nodes;
       }
 
-      logger.info('Analysis complete', { edgesCreated });
+      // Flush all nodes and edges
+      await graph.addNodes(allNodes);
+      await graph.addEdges(allEdges);
+
+      logger.info('Analysis complete', { nodesCreated, edgesCreated });
 
       return createSuccessResult(
-        { nodes: 0, edges: edgesCreated },
+        { nodes: nodesCreated, edges: edgesCreated },
         { routesAnalyzed: routes.length }
       );
     } catch (error) {
       logger.error('Analysis failed', { error });
-      return createErrorResult(error as Error);
+      const err = error instanceof Error ? error : new Error(String(error));
+      return createErrorResult(err);
     }
   }
 
@@ -93,16 +102,19 @@ export class ExpressResponseAnalyzer extends Plugin {
    */
   private async analyzeRouteResponses(
     route: NodeRecord,
-    graph: PluginContext['graph']
-  ): Promise<number> {
+    graph: PluginContext['graph'],
+    nodes: NodeRecord[],
+    edges: Array<{ type: string; src: string; dst: string; metadata?: unknown }>
+  ): Promise<{ nodes: number; edges: number }> {
     let edgesCreated = 0;
+    let nodesCreated = 0;
 
     try {
       // Get HANDLED_BY edges to find handler function
       const handledByEdges = await graph.getOutgoingEdges(route.id, ['HANDLED_BY']);
 
       if (handledByEdges.length === 0) {
-        return 0;
+        return { nodes: 0, edges: 0 };
       }
 
       // Get handler function node
@@ -110,7 +122,7 @@ export class ExpressResponseAnalyzer extends Plugin {
       const handlerNode = await graph.getNode(handlerEdge.dst);
 
       if (!handlerNode || !handlerNode.file) {
-        return 0;
+        return { nodes: 0, edges: 0 };
       }
 
       // Parse the file and find response calls in handler
@@ -130,18 +142,21 @@ export class ExpressResponseAnalyzer extends Plugin {
       // Create RESPONDS_WITH edges
       for (const call of responseCalls) {
         // Try to resolve to existing variable, or create a unique response node
-        const dstNodeId = await this.resolveOrCreateResponseNode(
+        const result = await this.resolveOrCreateResponseNode(
           graph,
           handlerNode.file,
           call,
           route.id,
-          handlerNode.id // Handler's semantic ID for scope resolution
+          handlerNode.id, // Handler's semantic ID for scope resolution
+          nodes
         );
 
-        await graph.addEdge({
+        nodesCreated += result.nodesCreated;
+
+        edges.push({
           type: 'RESPONDS_WITH',
           src: route.id,
-          dst: dstNodeId,
+          dst: result.nodeId,
           metadata: {
             responseMethod: call.method
           }
@@ -152,7 +167,7 @@ export class ExpressResponseAnalyzer extends Plugin {
       // Silent - per-route errors shouldn't spam logs
     }
 
-    return edgesCreated;
+    return { nodes: nodesCreated, edges: edgesCreated };
   }
 
   /**
@@ -327,15 +342,17 @@ export class ExpressResponseAnalyzer extends Plugin {
    * @param call - Response call info (includes identifierName)
    * @param routeId - Route ID (for metadata)
    * @param handlerSemanticId - Handler function's semantic ID (for scope matching)
-   * @returns Node ID (existing or newly created)
+   * @param nodes - Array to collect nodes for batch insertion
+   * @returns Object with nodeId and nodesCreated count
    */
   private async resolveOrCreateResponseNode(
     graph: PluginContext['graph'],
     file: string,
     call: ResponseCallInfo,
     routeId: string,
-    handlerSemanticId: string
-  ): Promise<string> {
+    handlerSemanticId: string,
+    nodes: NodeRecord[]
+  ): Promise<{ nodeId: string; nodesCreated: number }> {
     const { argLine, argColumn, argType, identifierName } = call;
 
     // For Identifier arguments, try to find existing variable/parameter
@@ -349,20 +366,21 @@ export class ExpressResponseAnalyzer extends Plugin {
       );
 
       if (existingNodeId) {
-        return existingNodeId; // Use existing node, no stub needed
+        return { nodeId: existingNodeId, nodesCreated: 0 }; // Use existing node, no stub needed
       }
       // Fall through to create stub if not found (external/global variables)
     }
 
     // For non-Identifier or not-found, create stub node (existing logic)
-    return this.createResponseArgumentNode(
-      graph,
+    const nodeId = this.createResponseArgumentNode(
       file,
       argLine,
       argColumn,
       argType,
-      routeId
+      routeId,
+      nodes
     );
+    return { nodeId, nodesCreated: 1 };
   }
 
   /**
@@ -552,84 +570,50 @@ export class ExpressResponseAnalyzer extends Plugin {
   /**
    * Create a node for the response argument
    */
-  private async createResponseArgumentNode(
-    graph: PluginContext['graph'],
+  private createResponseArgumentNode(
     file: string,
     line: number,
     column: number,
     astType: string,
-    routeId: string
-  ): Promise<string> {
-    // Map AST type to node type and create appropriate node
+    _routeId: string,
+    nodes: NodeRecord[]
+  ): string {
+    const counter = this.responseNodeCounter++;
+
+    // Map AST type to node type and create appropriate node via NodeFactory
     switch (astType) {
       case 'ObjectExpression': {
-        // Include counter to make the node unique even for same location
-        const counter = this.responseNodeCounter++;
-        const id = `OBJECT_LITERAL#response:${counter}#${file}#${line}:${column}`;
-        await graph.addNode({
-          id,
-          type: 'OBJECT_LITERAL',
-          name: '<response>',
-          file,
-          line,
-          column,
-          parentRouteId: routeId
-        } as NodeRecord);
-        return id;
+        const node = NodeFactory.createObjectLiteral(file, line, column, {
+          argIndex: counter
+        });
+        nodes.push(node as NodeRecord);
+        return node.id;
       }
       case 'Identifier': {
-        // For identifiers, we link to the variable that's being returned
-        const counter = this.responseNodeCounter++;
-        const id = `VARIABLE#response:${counter}#${file}#${line}:${column}`;
-        await graph.addNode({
-          id,
-          type: 'VARIABLE',
-          name: '<response>',
-          file,
-          line,
-          column
-        } as NodeRecord);
-        return id;
+        const node = NodeFactory.createVariableDeclaration('<response>', file, line, column, {
+          counter
+        });
+        nodes.push(node as NodeRecord);
+        return node.id;
       }
       case 'CallExpression': {
-        const counter = this.responseNodeCounter++;
-        const id = `CALL#response:${counter}#${file}#${line}:${column}`;
-        await graph.addNode({
-          id,
-          type: 'CALL',
-          name: '<response>',
-          file,
-          line,
-          column
-        } as NodeRecord);
-        return id;
+        const node = NodeFactory.createCallSite('<response>', file, line, column, {
+          counter
+        });
+        nodes.push(node as NodeRecord);
+        return node.id;
       }
       case 'ArrayExpression': {
-        const counter = this.responseNodeCounter++;
-        const id = `ARRAY_LITERAL#response:${counter}#${file}#${line}:${column}`;
-        await graph.addNode({
-          id,
-          type: 'ARRAY_LITERAL',
-          name: '<response>',
-          file,
-          line,
-          column
-        } as NodeRecord);
-        return id;
+        const node = NodeFactory.createArrayLiteral(file, line, column, {
+          argIndex: counter
+        });
+        nodes.push(node as NodeRecord);
+        return node.id;
       }
       default: {
-        // Generic expression node
-        const counter = this.responseNodeCounter++;
-        const id = `EXPRESSION#response:${counter}#${file}#${line}:${column}`;
-        await graph.addNode({
-          id,
-          type: 'EXPRESSION',
-          name: '<response>',
-          file,
-          line,
-          column
-        } as NodeRecord);
-        return id;
+        const node = NodeFactory.createExpression(astType, file, line, column);
+        nodes.push(node as NodeRecord);
+        return node.id;
       }
     }
   }

package/src/plugins/analysis/ExpressRouteAnalyzer.ts

@@ -9,7 +9,8 @@
  */
 
 import { readFileSync } from 'fs';
-import { parse, ParserPlugin } from '@babel/parser';
+import type { ParserPlugin } from '@babel/parser';
+import { parse } from '@babel/parser';
 import traverseModule from '@babel/traverse';
 import type { CallExpression, Identifier, MemberExpression, Node } from '@babel/types';
 import type { NodePath } from '@babel/traverse';
@@ -18,7 +19,6 @@ import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 import type { NodeRecord } from '@grafema/types';
 import { getLine, getColumn } from './ast/utils/location.js';
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const traverse = (traverseModule as any).default || traverseModule;
 
 /**
@@ -35,6 +35,8 @@ interface EndpointNode {
   routerName: string;
   handlerLine: number;
   handlerColumn: number;
+  handlerStart?: number;  // Byte offset for inline handlers
+  handlerName?: string;   // Function name for named handler references
 }
 
 /**
@@ -69,7 +71,6 @@ export class ExpressRouteAnalyzer extends Plugin {
     return {
       name: 'ExpressRouteAnalyzer',
       phase: 'ANALYSIS',
-      priority: 75, // После JSASTAnalyzer (80) - меньший приоритет = позже
       creates: {
         nodes: ['http:route', 'express:middleware'],
         edges: ['CONTAINS', 'USES_MIDDLEWARE', 'HANDLED_BY']
@@ -252,6 +253,18 @@ export class ExpressRouteAnalyzer extends Plugin {
                   // Создаём http:route
                   const endpointId = `http:route#${method.toUpperCase()}:${routePath}#${module.file}#${getLine(node)}`;
 
+                  // Determine handler identification for HANDLED_BY linking:
+                  // - Inline functions (arrow/function expressions): use byte offset (start)
+                  // - Named references (Identifier): use function name
+                  let handlerStart: number | undefined;
+                  let handlerName: string | undefined;
+                  if (actualHandler.type === 'ArrowFunctionExpression' ||
+                      actualHandler.type === 'FunctionExpression') {
+                    handlerStart = (actualHandler as { start?: number }).start;
+                  } else if (actualHandler.type === 'Identifier') {
+                    handlerName = (actualHandler as Identifier).name;
+                  }
+
                   endpoints.push({
                     id: endpointId,
                     type: 'http:route',
@@ -266,7 +279,9 @@ export class ExpressRouteAnalyzer extends Plugin {
                       : getLine(node),
                     handlerColumn: actualHandler.loc
                       ? getColumn(actualHandler)
-                      : getColumn(node)
+                      : getColumn(node),
+                    handlerStart,
+                    handlerName
                   });
 
                   // Обрабатываем middleware
@@ -356,56 +371,47 @@ export class ExpressRouteAnalyzer extends Plugin {
         }
       });
 
-      // Создаём ENDPOINT ноды
+      // Collect all nodes and edges for batch operations
+      const nodes: NodeRecord[] = [];
+      const edges: Array<{ type: string; src: string; dst: string }> = [];
+
+      // Prepare ENDPOINT nodes
       for (const endpoint of endpoints) {
-        // Сохраняем handler location ПЕРЕД destructuring
-        const handlerLine = endpoint.handlerLine;
-        const handlerColumn = endpoint.handlerColumn;
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { handlerLine: _hl, handlerColumn: _hc, routerName, ...endpointData } = endpoint;
-
-        await graph.addNode(endpointData as unknown as NodeRecord);
+        const { handlerLine: _hl, handlerColumn: _hc, handlerStart, handlerName, routerName, ...endpointData } = endpoint;
+
+        // Store handler identification in metadata for ExpressHandlerLinker enricher
+        const nodeData = {
+          ...endpointData,
+          metadata: {
+            ...(handlerStart !== undefined && { handlerStart }),
+            ...(handlerName !== undefined && { handlerName })
+          }
+        };
+        nodes.push(nodeData as unknown as NodeRecord);
         endpointsCreated++;
 
         // MODULE -> CONTAINS -> ENDPOINT
-        await graph.addEdge({
+        edges.push({
           type: 'CONTAINS',
           src: module.id,
           dst: endpoint.id
         });
         edgesCreated++;
 
-        // Ищем FUNCTION ноду для handler по line+column
-        // NOTE: queryNodes не поддерживает line/column фильтрацию, поэтому фильтруем вручную
-        if (handlerLine) {
-          for await (const fn of graph.queryNodes({
-            type: 'FUNCTION',
-            file: module.file
-          })) {
-            // Проверяем точное совпадение line и column
-            if (fn.line === handlerLine && fn.column === handlerColumn) {
-              // ENDPOINT -> HANDLED_BY -> FUNCTION
-              await graph.addEdge({
-                type: 'HANDLED_BY',
-                src: endpoint.id,
-                dst: fn.id
-              });
-              edgesCreated++;
-              break;
-            }
-          }
-        }
+        // NOTE: HANDLED_BY edges are created by ExpressHandlerLinker enricher
+        // using handlerStart (byte offset) or handlerName stored in node metadata
       }
 
-      // Создаём MIDDLEWARE ноды и связи
+      // Prepare MIDDLEWARE nodes
       for (const middleware of middlewares) {
-        const { endpointId, order, ...middlewareData } = middleware;
+        const { endpointId, order: _order, ...middlewareData } = middleware;
 
-        await graph.addNode(middlewareData as unknown as NodeRecord);
+        nodes.push(middlewareData as unknown as NodeRecord);
         middlewareCreated++;
 
         // MODULE -> CONTAINS -> MIDDLEWARE
-        await graph.addEdge({
+        edges.push({
           type: 'CONTAINS',
           src: module.id,
           dst: middleware.id
@@ -415,14 +421,20 @@ export class ExpressRouteAnalyzer extends Plugin {
         // Если есть связанный endpoint
         if (endpointId) {
           // ENDPOINT -> USES_MIDDLEWARE -> MIDDLEWARE
-          await graph.addEdge({
+          edges.push({
             type: 'USES_MIDDLEWARE',
             src: endpointId,
             dst: middleware.id
           });
           edgesCreated++;
         }
+      }
 
+      // Flush nodes first so they exist for edge queries
+      await graph.addNodes(nodes);
+
+      // Query for HANDLED_BY edges (needs nodes to exist first)
+      for (const middleware of middlewares) {
         // Ищем FUNCTION ноду для middleware (если это именованная функция)
         if (!middleware.name.startsWith('inline:')) {
           for await (const fn of graph.queryNodes({
@@ -431,7 +443,7 @@ export class ExpressRouteAnalyzer extends Plugin {
             name: middleware.name
           })) {
             // MIDDLEWARE -> HANDLED_BY -> FUNCTION
-            await graph.addEdge({
+            edges.push({
               type: 'HANDLED_BY',
               src: middleware.id,
               dst: fn.id
@@ -441,7 +453,10 @@ export class ExpressRouteAnalyzer extends Plugin {
           }
         }
       }
-    } catch (error) {
+
+      // Flush all edges
+      await graph.addEdges(edges);
+    } catch {
       // Silent - per-module errors shouldn't spam logs
     }