@grafema/core 0.1.1-alpha → 0.2.0-beta

package/src/plugins/analysis/ExpressRouteAnalyzer.ts

@@ -16,7 +16,7 @@ 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 { getLine } from './ast/utils/location.js';
+import { getLine, getColumn } from './ast/utils/location.js';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const traverse = (traverseModule as any).default || traverseModule;
@@ -31,8 +31,10 @@ interface EndpointNode {
   path: string;
   file: string;
   line: number;
+  column: number;
   routerName: string;
   handlerLine: number;
+  handlerColumn: number;
 }
 
 /**
@@ -44,6 +46,7 @@ interface MiddlewareNode {
   name: string;
   file: string;
   line: number;
+  column: number;
   endpointId?: string;
   order?: number;
   mountPath?: string;
@@ -216,6 +219,33 @@ export class ExpressRouteAnalyzer extends Plugin {
                   // Последний handler - это route handler
                   const mainHandler = handlers[handlers.length - 1];
 
+                  // Unwrap wrapper functions (asyncHandler, catchAsync, etc.)
+                  // Pattern: wrapper(async (req, res) => {...}) -> extract inner function
+                  // Also handles nested wrappers: outer(inner(handler))
+                  let actualHandler = mainHandler as Node;
+                  while (actualHandler.type === 'CallExpression') {
+                    const callExpr = actualHandler as CallExpression;
+                    const firstArg = callExpr.arguments[0] as Node | undefined;
+                    if (!firstArg) {
+                      // No arguments - not a wrapper pattern
+                      break;
+                    }
+                    if (
+                      firstArg.type === 'ArrowFunctionExpression' ||
+                      firstArg.type === 'FunctionExpression'
+                    ) {
+                      // Found the actual handler function
+                      actualHandler = firstArg;
+                      break;
+                    } else if (firstArg.type === 'CallExpression') {
+                      // Nested wrapper: outer(inner(...)) - continue unwrapping
+                      actualHandler = firstArg;
+                    } else {
+                      // First arg is not a function or CallExpression - not a wrapper pattern
+                      break;
+                    }
+                  }
+
                   // Все предыдущие - middleware
                   const middlewareHandlers = handlers.slice(0, -1);
 
@@ -229,10 +259,14 @@ export class ExpressRouteAnalyzer extends Plugin {
                     path: routePath,
                     file: module.file!,
                     line: getLine(node),
+                    column: getColumn(node),
                     routerName: objectName,
-                    handlerLine: (mainHandler as Node).loc
-                      ? getLine(mainHandler as Node)
-                      : getLine(node)
+                    handlerLine: actualHandler.loc
+                      ? getLine(actualHandler)
+                      : getLine(node),
+                    handlerColumn: actualHandler.loc
+                      ? getColumn(actualHandler)
+                      : getColumn(node)
                   });
 
                   // Обрабатываем middleware
@@ -265,6 +299,7 @@ export class ExpressRouteAnalyzer extends Plugin {
                         name: middlewareName,
                         file: module.file!,
                         line: mwNode.loc ? getLine(mwNode) : getLine(node),
+                        column: mwNode.loc ? getColumn(mwNode) : getColumn(node),
                         endpointId: endpointId,
                         order: index // Порядок в цепочке
                       });
@@ -309,6 +344,7 @@ export class ExpressRouteAnalyzer extends Plugin {
                       name: middlewareName,
                       file: module.file!,
                       line: getLine(node),
+                      column: getColumn(node),
                       mountPath: mountPath,
                       isGlobal: mountPath === '/' // Global middleware если нет path
                     });
@@ -322,10 +358,11 @@ export class ExpressRouteAnalyzer extends Plugin {
 
       // Создаём ENDPOINT ноды
       for (const endpoint of endpoints) {
-        // Сохраняем handlerLine ПЕРЕД destructuring
+        // Сохраняем handler location ПЕРЕД destructuring
         const handlerLine = endpoint.handlerLine;
+        const handlerColumn = endpoint.handlerColumn;
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { handlerLine: _, routerName, ...endpointData } = endpoint;
+        const { handlerLine: _hl, handlerColumn: _hc, routerName, ...endpointData } = endpoint;
 
         await graph.addNode(endpointData as unknown as NodeRecord);
         endpointsCreated++;
@@ -338,22 +375,24 @@ export class ExpressRouteAnalyzer extends Plugin {
         });
         edgesCreated++;
 
-        // Ищем FUNCTION ноду для handler (arrow function на той же строке)
+        // Ищем FUNCTION ноду для handler по line+column
+        // NOTE: queryNodes не поддерживает line/column фильтрацию, поэтому фильтруем вручную
         if (handlerLine) {
-          // Используем queryNodes вместо прямого доступа к graph.nodes
           for await (const fn of graph.queryNodes({
             type: 'FUNCTION',
-            file: module.file,
-            line: handlerLine
+            file: module.file
           })) {
-            // ENDPOINT -> HANDLED_BY -> FUNCTION
-            await graph.addEdge({
-              type: 'HANDLED_BY',
-              src: endpoint.id,
-              dst: fn.id
-            });
-            edgesCreated++;
-            break; // Берём только первую найденную функцию
+            // Проверяем точное совпадение 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;
+            }
           }
         }
       }

package/src/plugins/analysis/FetchAnalyzer.ts

@@ -18,7 +18,7 @@ import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 import type { NodeRecord } from '@grafema/types';
 import { NetworkRequestNode } from '../../core/nodes/NetworkRequestNode.js';
-import { getLine } from './ast/utils/location.js';
+import { getLine, getColumn } from './ast/utils/location.js';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const traverse = (traverseModule as any).default || traverseModule;
@@ -29,12 +29,28 @@ const traverse = (traverseModule as any).default || traverseModule;
 interface HttpRequestNode {
   id: string;
   type: 'http:request';
+  name: string;  // Human-readable name like "GET /api/users"
   method: string;
   url: string;
   library: string;
   file: string;
   line: number;
+  column: number;
   staticUrl: 'yes' | 'no';
+  responseDataNode?: string | null;  // ID of CALL node for response.json(), response.text(), etc.
+}
+
+/**
+ * Response consumption methods for fetch API
+ */
+const RESPONSE_CONSUMPTION_METHODS = ['json', 'text', 'blob', 'arrayBuffer', 'formData'];
+
+/**
+ * Fetch call info with response variable name (for responseDataNode tracking)
+ */
+interface FetchCallInfo {
+  request: HttpRequestNode;
+  responseVarName: string | null;
 }
 
 /**
@@ -47,6 +63,7 @@ interface AnalysisResult {
 
 export class FetchAnalyzer extends Plugin {
   private networkNodeCreated = false;
+  private networkNodeId: string | null = null;
 
   get metadata(): PluginMetadata {
     return {
@@ -67,10 +84,7 @@ export class FetchAnalyzer extends Plugin {
     try {
       const { graph } = context;
 
-      // Create net:request singleton (GraphBackend handles deduplication)
-      const networkNode = NetworkRequestNode.create();
-      await graph.addNode(networkNode);
-      this.networkNodeCreated = true;
+      // net:request singleton created lazily in analyzeModule when first request found
 
       // Получаем все модули
       const modules = await this.getModules(graph);
@@ -82,7 +96,7 @@ export class FetchAnalyzer extends Plugin {
 
       for (let i = 0; i < modules.length; i++) {
         const module = modules[i];
-        const result = await this.analyzeModule(module, graph, networkNode.id);
+        const result = await this.analyzeModule(module, graph);
         requestsCount += result.requests;
         apisCount += result.apis;
 
@@ -118,10 +132,23 @@ export class FetchAnalyzer extends Plugin {
     }
   }
 
+  /**
+   * Ensures net:request singleton exists, creating it if necessary.
+   * Called lazily when first HTTP request is detected.
+   */
+  private async ensureNetworkNode(graph: PluginContext['graph']): Promise<string> {
+    if (!this.networkNodeId) {
+      const networkNode = NetworkRequestNode.create();
+      await graph.addNode(networkNode);
+      this.networkNodeCreated = true;
+      this.networkNodeId = networkNode.id;
+    }
+    return this.networkNodeId;
+  }
+
   private async analyzeModule(
     module: NodeRecord,
-    graph: PluginContext['graph'],
-    networkId: string
+    graph: PluginContext['graph']
   ): Promise<AnalysisResult> {
     try {
       const code = readFileSync(module.file!, 'utf-8');
@@ -140,7 +167,7 @@ export class FetchAnalyzer extends Plugin {
         ] as ParserPlugin[]
       });
 
-      const httpRequests: HttpRequestNode[] = [];
+      const fetchCalls: FetchCallInfo[] = [];
       const externalAPIs = new Set<string>();
 
       // Детект HTTP request паттернов
@@ -159,15 +186,19 @@ export class FetchAnalyzer extends Plugin {
             const request: HttpRequestNode = {
               id: `http:request#${method}:${url}#${module.file}#${line}`,
               type: 'http:request',
+              name: `${method} ${url}`,
               method: method,
               url: url,
               library: 'fetch',
               file: module.file!,
               line: line,
+              column: getColumn(node),
               staticUrl: url !== 'dynamic' && url !== 'unknown' ? 'yes' : 'no'
             };
 
-            httpRequests.push(request);
+            // Extract response variable name for responseDataNode tracking
+            const responseVarName = this.getResponseVariableName(path);
+            fetchCalls.push({ request, responseVarName });
 
             // Определяем внешний ли это API
             if (this.isExternalAPI(url)) {
@@ -190,15 +221,18 @@ export class FetchAnalyzer extends Plugin {
             const request: HttpRequestNode = {
               id: `http:request#${method}:${url}#${module.file}#${line}`,
               type: 'http:request',
+              name: `${method} ${url}`,
               method: method,
               url: url,
               library: 'axios',
               file: module.file!,
               line: line,
+              column: getColumn(node),
               staticUrl: url !== 'dynamic' && url !== 'unknown' ? 'yes' : 'no'
             };
 
-            httpRequests.push(request);
+            // Axios uses response.data, not response.json() - out of scope for v1.0
+            fetchCalls.push({ request, responseVarName: null });
 
             if (this.isExternalAPI(url)) {
               externalAPIs.add(this.extractDomain(url));
@@ -234,15 +268,18 @@ export class FetchAnalyzer extends Plugin {
               const request: HttpRequestNode = {
                 id: `http:request#${method.toUpperCase()}:${url}#${module.file}#${line}`,
                 type: 'http:request',
+                name: `${method.toUpperCase()} ${url}`,
                 method: method.toUpperCase(),
                 url: url,
                 library: 'axios',
                 file: module.file!,
                 line: line,
+                column: getColumn(node),
                 staticUrl: url !== 'dynamic' && url !== 'unknown' ? 'yes' : 'no'
               };
 
-              httpRequests.push(request);
+              // Axios uses response.data, not response.json() - out of scope for v1.0
+              fetchCalls.push({ request, responseVarName: null });
 
               if (this.isExternalAPI(url)) {
                 externalAPIs.add(this.extractDomain(url));
@@ -266,15 +303,19 @@ export class FetchAnalyzer extends Plugin {
               const request: HttpRequestNode = {
                 id: `http:request#${method}:${url}#${module.file}#${line}`,
                 type: 'http:request',
+                name: `${method} ${url}`,
                 method: method,
                 url: url,
                 library: calleeName,
                 file: module.file!,
                 line: line,
+                column: getColumn(node),
                 staticUrl: url !== 'dynamic' && url !== 'unknown' ? 'yes' : 'no'
               };
 
-              httpRequests.push(request);
+              // Custom wrappers may use fetch-like response.json() pattern
+              const responseVarName = this.getResponseVariableName(path);
+              fetchCalls.push({ request, responseVarName });
 
               if (this.isExternalAPI(url)) {
                 externalAPIs.add(this.extractDomain(url));
@@ -284,8 +325,26 @@ export class FetchAnalyzer extends Plugin {
         }
       });
 
+      // Extract httpRequests for external API handling
+      const httpRequests = fetchCalls.map(fc => fc.request);
+
       // Создаём HTTP_REQUEST ноды
-      for (const request of httpRequests) {
+      for (const fetchCall of fetchCalls) {
+        const request = fetchCall.request;
+
+        // Find responseDataNode if we have a response variable name
+        if (fetchCall.responseVarName) {
+          const responseDataNodeId = await this.findResponseJsonCall(
+            graph,
+            request.file,
+            fetchCall.responseVarName,
+            request.line
+          );
+          if (responseDataNodeId) {
+            request.responseDataNode = responseDataNodeId;
+          }
+        }
+
         await graph.addNode(request as unknown as NodeRecord);
 
         // Создаём ребро от модуля к request
@@ -295,7 +354,8 @@ export class FetchAnalyzer extends Plugin {
           dst: request.id
         });
 
-        // http:request --CALLS--> net:request singleton
+        // http:request --CALLS--> net:request singleton (created lazily)
+        const networkId = await this.ensureNetworkNode(graph);
         await graph.addEdge({
           type: 'CALLS',
           src: request.id,
@@ -328,6 +388,25 @@ export class FetchAnalyzer extends Plugin {
             dst: request.id
           });
         }
+
+        // Find CALL node that makes this request (same file, same line)
+        // Determine expected call name based on library
+        const expectedCallNames = this.getExpectedCallNames(request.library, request.method);
+
+        for await (const callNode of graph.queryNodes({ type: 'CALL' })) {
+          if (
+            callNode.file === request.file &&
+            callNode.line === request.line &&
+            expectedCallNames.includes(callNode.name as string)
+          ) {
+            await graph.addEdge({
+              type: 'MAKES_REQUEST',
+              src: callNode.id,
+              dst: request.id
+            });
+            break; // Only link to first matching CALL node
+          }
+        }
       }
 
       // Создаём EXTERNAL ноды для внешних API
@@ -358,7 +437,7 @@ export class FetchAnalyzer extends Plugin {
       }
 
       return {
-        requests: httpRequests.length,
+        requests: fetchCalls.length,
         apis: externalAPIs.size
       };
     } catch (error) {
@@ -436,6 +515,28 @@ export class FetchAnalyzer extends Plugin {
     return null;
   }
 
+  /**
+   * Returns expected CALL node names based on library and HTTP method.
+   * Used to match http:request with corresponding CALL node.
+   *
+   * @param library - Library name (fetch, axios, or custom wrapper name)
+   * @param method - HTTP method (GET, POST, etc.)
+   * @returns Array of possible call names
+   */
+  private getExpectedCallNames(library: string, method: string): string[] {
+    if (library === 'fetch') {
+      return ['fetch'];
+    }
+
+    if (library === 'axios') {
+      // axios.get(), axios.post(), etc. or axios() config call
+      return [`axios.${method.toLowerCase()}`, 'axios'];
+    }
+
+    // Custom wrapper (authFetch, apiFetch, etc.)
+    return [library];
+  }
+
   /**
    * Проверяет является ли URL внешним API
    */
@@ -461,4 +562,91 @@ export class FetchAnalyzer extends Plugin {
       return match ? match[1] : url;
     }
   }
+
+  /**
+   * Extracts the variable name that holds the fetch response.
+   * Handles patterns like:
+   * - const response = await fetch(url)
+   * - let res = await fetch(url)
+   * - response = await fetch(url)
+   *
+   * @param path - NodePath of the CallExpression
+   * @returns Variable name or null if not found
+   */
+  private getResponseVariableName(path: NodePath<CallExpression>): string | null {
+    // Walk up the AST to find the variable assignment
+    let current: NodePath | null = path.parentPath;
+
+    // Pattern: await fetch()
+    if (current && current.node.type === 'AwaitExpression') {
+      current = current.parentPath;
+    }
+
+    if (!current) return null;
+
+    // Pattern: const response = await fetch() / let response = await fetch()
+    if (current.node.type === 'VariableDeclarator') {
+      const declarator = current.node as { id: Node };
+      if (declarator.id.type === 'Identifier') {
+        return (declarator.id as Identifier).name;
+      }
+    }
+
+    // Pattern: response = await fetch() (reassignment)
+    if (current.node.type === 'AssignmentExpression') {
+      const assignment = current.node as { left: Node };
+      if (assignment.left.type === 'Identifier') {
+        return (assignment.left as Identifier).name;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Finds the response consumption CALL node (response.json(), response.text(), etc.)
+   * by querying the graph for CALL nodes in the same file with matching object name.
+   *
+   * Important: Filters to find the response.json() call AFTER the fetch line and
+   * closest to it, ensuring we match the correct call in the same function scope.
+   *
+   * @param graph - Graph backend
+   * @param file - File path where fetch call is located
+   * @param responseVarName - Variable name holding the response
+   * @param fetchLine - Line number of the fetch call (response.json must be after this)
+   * @returns CALL node ID or null if not found
+   */
+  private async findResponseJsonCall(
+    graph: PluginContext['graph'],
+    file: string,
+    responseVarName: string,
+    fetchLine: number
+  ): Promise<string | null> {
+    // Collect all matching CALL nodes
+    const candidates: Array<{ id: string; line: number }> = [];
+
+    for await (const node of graph.queryNodes({ type: 'CALL' })) {
+      // Check if it's in the same file
+      if (node.file !== file) continue;
+
+      // Check if object matches response variable name
+      const callNode = node as unknown as { object?: string; method?: string };
+      if (callNode.object !== responseVarName) continue;
+
+      // Check if method is a response consumption method
+      if (callNode.method && RESPONSE_CONSUMPTION_METHODS.includes(callNode.method)) {
+        const nodeLine = node.line ?? 0;
+        // Only consider calls AFTER the fetch line (response.json comes after fetch)
+        if (nodeLine > fetchLine) {
+          candidates.push({ id: node.id, line: nodeLine });
+        }
+      }
+    }
+
+    if (candidates.length === 0) return null;
+
+    // Return the closest match (smallest line number after fetch)
+    candidates.sort((a, b) => a.line - b.line);
+    return candidates[0].id;
+  }
 }