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

package/src/plugins/analysis/ExpressRouteAnalyzer.ts

@@ -16,6 +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, getColumn } from './ast/utils/location.js';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const traverse = (traverseModule as any).default || traverseModule;
@@ -30,8 +31,10 @@ interface EndpointNode {
   path: string;
   file: string;
   line: number;
+  column: number;
   routerName: string;
   handlerLine: number;
+  handlerColumn: number;
 }
 
 /**
@@ -43,6 +46,7 @@ interface MiddlewareNode {
   name: string;
   file: string;
   line: number;
+  column: number;
   endpointId?: string;
   order?: number;
   mountPath?: string;
@@ -75,12 +79,14 @@ export class ExpressRouteAnalyzer extends Plugin {
   }
 
   async execute(context: PluginContext): Promise<PluginResult> {
+    const logger = this.log(context);
+
     try {
       const { graph } = context;
 
       // Получаем все MODULE ноды
       const modules = await this.getModules(graph);
-      console.log(`[ExpressRouteAnalyzer] Processing ${modules.length} modules...`);
+      logger.info('Processing modules', { count: modules.length });
 
       let endpointsCreated = 0;
       let middlewareCreated = 0;
@@ -99,15 +105,16 @@ export class ExpressRouteAnalyzer extends Plugin {
         if ((i + 1) % 20 === 0 || i === modules.length - 1) {
           const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
           const avgTime = ((Date.now() - startTime) / (i + 1)).toFixed(0);
-          console.log(
-            `[ExpressRouteAnalyzer] Progress: ${i + 1}/${modules.length} (${elapsed}s, avg ${avgTime}ms/module)`
-          );
+          logger.debug('Progress', {
+            current: i + 1,
+            total: modules.length,
+            elapsed: `${elapsed}s`,
+            avgTime: `${avgTime}ms/module`
+          });
         }
       }
 
-      console.log(
-        `[ExpressRouteAnalyzer] Found ${endpointsCreated} endpoints, ${middlewareCreated} middleware`
-      );
+      logger.info('Analysis complete', { endpointsCreated, middlewareCreated });
 
       return createSuccessResult(
         {
@@ -117,7 +124,7 @@ export class ExpressRouteAnalyzer extends Plugin {
         { modulesAnalyzed: modules.length }
       );
     } catch (error) {
-      console.error(`[ExpressRouteAnalyzer] Error:`, error);
+      logger.error('Analysis failed', { error });
       return createErrorResult(error as Error);
     }
   }
@@ -212,11 +219,38 @@ 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);
 
                   // Создаём http:route
-                  const endpointId = `http:route#${method.toUpperCase()}:${routePath}#${module.file}#${node.loc!.start.line}`;
+                  const endpointId = `http:route#${method.toUpperCase()}:${routePath}#${module.file}#${getLine(node)}`;
 
                   endpoints.push({
                     id: endpointId,
@@ -224,11 +258,15 @@ export class ExpressRouteAnalyzer extends Plugin {
                     method: method.toUpperCase(),
                     path: routePath,
                     file: module.file!,
-                    line: node.loc!.start.line,
+                    line: getLine(node),
+                    column: getColumn(node),
                     routerName: objectName,
-                    handlerLine: (mainHandler as Node).loc
-                      ? (mainHandler as Node).loc!.start.line
-                      : node.loc!.start.line
+                    handlerLine: actualHandler.loc
+                      ? getLine(actualHandler)
+                      : getLine(node),
+                    handlerColumn: actualHandler.loc
+                      ? getColumn(actualHandler)
+                      : getColumn(node)
                   });
 
                   // Обрабатываем middleware
@@ -249,18 +287,19 @@ export class ExpressRouteAnalyzer extends Plugin {
                       mwNode.type === 'ArrowFunctionExpression' ||
                       mwNode.type === 'FunctionExpression'
                     ) {
-                      middlewareName = `inline:${mwNode.loc!.start.line}`;
+                      middlewareName = `inline:${getLine(mwNode)}`;
                     }
 
                     if (middlewareName) {
-                      const middlewareId = `express:middleware#${middlewareName}#${module.file}#${mwNode.loc!.start.line}`;
+                      const middlewareId = `express:middleware#${middlewareName}#${module.file}#${getLine(mwNode)}`;
 
                       middlewares.push({
                         id: middlewareId,
                         type: 'express:middleware',
                         name: middlewareName,
                         file: module.file!,
-                        line: mwNode.loc ? mwNode.loc.start.line : node.loc!.start.line,
+                        line: mwNode.loc ? getLine(mwNode) : getLine(node),
+                        column: mwNode.loc ? getColumn(mwNode) : getColumn(node),
                         endpointId: endpointId,
                         order: index // Порядок в цепочке
                       });
@@ -297,14 +336,15 @@ export class ExpressRouteAnalyzer extends Plugin {
                   }
 
                   if (middlewareName) {
-                    const middlewareId = `express:middleware#${middlewareName}#${module.file}#${node.loc!.start.line}`;
+                    const middlewareId = `express:middleware#${middlewareName}#${module.file}#${getLine(node)}`;
 
                     middlewares.push({
                       id: middlewareId,
                       type: 'express:middleware',
                       name: middlewareName,
                       file: module.file!,
-                      line: node.loc!.start.line,
+                      line: getLine(node),
+                      column: getColumn(node),
                       mountPath: mountPath,
                       isGlobal: mountPath === '/' // Global middleware если нет path
                     });
@@ -318,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++;
@@ -334,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;
+            }
           }
         }
       }
@@ -399,10 +442,7 @@ export class ExpressRouteAnalyzer extends Plugin {
         }
       }
     } catch (error) {
-      console.error(
-        `[ExpressRouteAnalyzer] Error analyzing ${module.file}:`,
-        (error as Error).message
-      );
+      // Silent - per-module errors shouldn't spam logs
     }
 
     return {

package/src/plugins/analysis/FetchAnalyzer.ts

@@ -17,6 +17,8 @@ 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 { NetworkRequestNode } from '../../core/nodes/NetworkRequestNode.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;
@@ -27,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;
 }
 
 /**
@@ -44,6 +62,9 @@ interface AnalysisResult {
 }
 
 export class FetchAnalyzer extends Plugin {
+  private networkNodeCreated = false;
+  private networkNodeId: string | null = null;
+
   get metadata(): PluginMetadata {
     return {
       name: 'FetchAnalyzer',
@@ -58,12 +79,16 @@ export class FetchAnalyzer extends Plugin {
   }
 
   async execute(context: PluginContext): Promise<PluginResult> {
+    const logger = this.log(context);
+
     try {
       const { graph } = context;
 
+      // net:request singleton created lazily in analyzeModule when first request found
+
       // Получаем все модули
       const modules = await this.getModules(graph);
-      console.log(`[FetchAnalyzer] Processing ${modules.length} modules...`);
+      logger.info('Processing modules', { count: modules.length });
 
       let requestsCount = 0;
       let apisCount = 0;
@@ -79,30 +104,48 @@ export class FetchAnalyzer extends Plugin {
         if ((i + 1) % 20 === 0 || i === modules.length - 1) {
           const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
           const avgTime = ((Date.now() - startTime) / (i + 1)).toFixed(0);
-          console.log(
-            `[FetchAnalyzer] Progress: ${i + 1}/${modules.length} (${elapsed}s, avg ${avgTime}ms/module)`
-          );
+          logger.debug('Progress', {
+            current: i + 1,
+            total: modules.length,
+            elapsed: `${elapsed}s`,
+            avgTime: `${avgTime}ms/module`
+          });
         }
       }
 
-      console.log(`[FetchAnalyzer] Found ${requestsCount} HTTP requests, ${apisCount} external APIs`);
+      logger.info('Analysis complete', { requestsCount, apisCount });
 
       return createSuccessResult(
         {
-          nodes: requestsCount + apisCount,
-          edges: 0
+          nodes: requestsCount + apisCount + (this.networkNodeCreated ? 1 : 0),
+          edges: requestsCount  // CALLS edges from http:request to net:request
         },
         {
           requestsCount,
-          apisCount
+          apisCount,
+          networkSingletonCreated: this.networkNodeCreated
         }
       );
     } catch (error) {
-      console.error('[FetchAnalyzer] Error:', error);
+      logger.error('Analysis failed', { error });
       return createErrorResult(error as Error);
     }
   }
 
+  /**
+   * 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']
@@ -124,7 +167,7 @@ export class FetchAnalyzer extends Plugin {
         ] as ParserPlugin[]
       });
 
-      const httpRequests: HttpRequestNode[] = [];
+      const fetchCalls: FetchCallInfo[] = [];
       const externalAPIs = new Set<string>();
 
       // Детект HTTP request паттернов
@@ -138,20 +181,24 @@ export class FetchAnalyzer extends Plugin {
             const urlArg = node.arguments[0];
             const url = this.extractURL(urlArg);
             const method = this.extractMethod(node.arguments[1]) || 'GET';
-            const line = node.loc!.start.line;
+            const line = getLine(node);
 
             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)) {
@@ -169,20 +216,23 @@ export class FetchAnalyzer extends Plugin {
             const method = ((callee as MemberExpression).property as Identifier).name.toUpperCase();
             const urlArg = node.arguments[0];
             const url = this.extractURL(urlArg);
-            const line = node.loc!.start.line;
+            const line = getLine(node);
 
             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));
@@ -213,20 +263,23 @@ export class FetchAnalyzer extends Plugin {
               const method = methodProp
                 ? this.extractString((methodProp as { value: Node }).value) || 'GET'
                 : 'GET';
-              const line = node.loc!.start.line;
+              const line = getLine(node);
 
               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));
@@ -245,20 +298,24 @@ export class FetchAnalyzer extends Plugin {
               const urlArg = node.arguments[0];
               const url = this.extractURL(urlArg);
               const method = this.extractMethod(node.arguments[1]) || 'GET';
-              const line = node.loc!.start.line;
+              const line = getLine(node);
 
               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));
@@ -268,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
@@ -279,6 +354,14 @@ export class FetchAnalyzer extends Plugin {
           dst: request.id
         });
 
+        // http:request --CALLS--> net:request singleton (created lazily)
+        const networkId = await this.ensureNetworkNode(graph);
+        await graph.addEdge({
+          type: 'CALLS',
+          src: request.id,
+          dst: networkId
+        });
+
         // Ищем FUNCTION node которая делает запрос
         const functions: NodeRecord[] = [];
         for await (const fn of graph.queryNodes({ type: 'FUNCTION' })) {
@@ -305,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
@@ -335,11 +437,11 @@ export class FetchAnalyzer extends Plugin {
       }
 
       return {
-        requests: httpRequests.length,
+        requests: fetchCalls.length,
         apis: externalAPIs.size
       };
     } catch (error) {
-      console.error(`[FetchAnalyzer] Error analyzing ${module.file}:`, (error as Error).message);
+      // Silent - per-module errors shouldn't spam logs
       return { requests: 0, apis: 0 };
     }
   }
@@ -413,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
    */
@@ -438,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;
+  }
 }