@grafema/core 0.2.3-beta → 0.2.5-beta

package/src/plugins/analysis/FetchAnalyzer.ts

@@ -10,7 +10,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, ObjectExpression, Node } from '@babel/types';
 import type { NodePath } from '@babel/traverse';
@@ -20,7 +21,6 @@ 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;
 
 /**
@@ -31,6 +31,7 @@ interface HttpRequestNode {
   type: 'http:request';
   name: string;  // Human-readable name like "GET /api/users"
   method: string;
+  methodSource: MethodSource;
   url: string;
   library: string;
   file: string;
@@ -53,6 +54,8 @@ interface FetchCallInfo {
   responseVarName: string | null;
 }
 
+type MethodSource = 'explicit' | 'default' | 'unknown';
+
 /**
  * Analysis result
  */
@@ -69,7 +72,6 @@ export class FetchAnalyzer extends Plugin {
     return {
       name: 'FetchAnalyzer',
       phase: 'ANALYSIS',
-      priority: 75, // После JSASTAnalyzer (80)
       creates: {
         nodes: ['http:request', 'EXTERNAL'],
         edges: ['CONTAINS', 'MAKES_REQUEST', 'CALLS_API']
@@ -84,7 +86,11 @@ export class FetchAnalyzer extends Plugin {
     try {
       const { graph } = context;
 
-      // net:request singleton created lazily in analyzeModule when first request found
+      // Create net:request singleton once before processing modules
+      const networkNode = NetworkRequestNode.create();
+      await graph.addNode(networkNode);
+      this.networkNodeCreated = true;
+      this.networkNodeId = networkNode.id;
 
       // Получаем все модули
       const modules = await this.getModules(graph);
@@ -128,28 +134,20 @@ export class FetchAnalyzer extends Plugin {
       );
     } 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);
     }
   }
 
-  /**
-   * 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']
   ): Promise<AnalysisResult> {
+    // Batch arrays for nodes and edges
+    const nodes: NodeRecord[] = [];
+    const edges: Array<{ type: string; src: string; dst: string }> = [];
+
     try {
       const code = readFileSync(module.file!, 'utf-8');
 
@@ -167,6 +165,26 @@ export class FetchAnalyzer extends Plugin {
         ] as ParserPlugin[]
       });
 
+      const constStrings = new Map<string, string>();
+      const constObjects = new Map<string, ObjectExpression>();
+
+      // Collect simple const assignments for method resolution
+      traverse(ast, {
+        VariableDeclarator: (path: NodePath) => {
+          const node = path.node as { id: Node; init?: Node | null };
+          const parent = path.parentPath?.node as { type?: string; kind?: string } | undefined;
+          if (!parent || parent.type !== 'VariableDeclaration' || parent.kind !== 'const') return;
+          if (!node.init || node.id.type !== 'Identifier') return;
+
+          const name = (node.id as Identifier).name;
+          if (node.init.type === 'StringLiteral') {
+            constStrings.set(name, (node.init as { value: string }).value);
+          } else if (node.init.type === 'ObjectExpression') {
+            constObjects.set(name, node.init as ObjectExpression);
+          }
+        }
+      });
+
       const fetchCalls: FetchCallInfo[] = [];
       const externalAPIs = new Set<string>();
 
@@ -180,7 +198,8 @@ export class FetchAnalyzer extends Plugin {
           if (callee.type === 'Identifier' && (callee as Identifier).name === 'fetch') {
             const urlArg = node.arguments[0];
             const url = this.extractURL(urlArg);
-            const method = this.extractMethod(node.arguments[1]) || 'GET';
+            const methodInfo = this.extractMethodInfo(node.arguments[1], constStrings, constObjects);
+            const method = methodInfo.method;
             const line = getLine(node);
 
             const request: HttpRequestNode = {
@@ -188,6 +207,7 @@ export class FetchAnalyzer extends Plugin {
               type: 'http:request',
               name: `${method} ${url}`,
               method: method,
+              methodSource: methodInfo.source,
               url: url,
               library: 'fetch',
               file: module.file!,
@@ -223,6 +243,7 @@ export class FetchAnalyzer extends Plugin {
               type: 'http:request',
               name: `${method} ${url}`,
               method: method,
+              methodSource: 'explicit',
               url: url,
               library: 'axios',
               file: module.file!,
@@ -250,19 +271,12 @@ export class FetchAnalyzer extends Plugin {
                   (p.key as Identifier).type === 'Identifier' &&
                   (p.key as Identifier).name === 'url'
               );
-              const methodProp = objExpr.properties.find(
-                p =>
-                  p.type === 'ObjectProperty' &&
-                  (p.key as Identifier).type === 'Identifier' &&
-                  (p.key as Identifier).name === 'method'
-              );
 
               const url = urlProp
                 ? this.extractURL((urlProp as { value: Node }).value)
                 : 'unknown';
-              const method = methodProp
-                ? this.extractString((methodProp as { value: Node }).value) || 'GET'
-                : 'GET';
+              const methodInfo = this.extractMethodInfo(config, constStrings, constObjects);
+              const method = methodInfo.method;
               const line = getLine(node);
 
               const request: HttpRequestNode = {
@@ -270,6 +284,7 @@ export class FetchAnalyzer extends Plugin {
                 type: 'http:request',
                 name: `${method.toUpperCase()} ${url}`,
                 method: method.toUpperCase(),
+                methodSource: methodInfo.source,
                 url: url,
                 library: 'axios',
                 file: module.file!,
@@ -297,7 +312,8 @@ export class FetchAnalyzer extends Plugin {
             ) {
               const urlArg = node.arguments[0];
               const url = this.extractURL(urlArg);
-              const method = this.extractMethod(node.arguments[1]) || 'GET';
+              const methodInfo = this.extractMethodInfo(node.arguments[1], constStrings, constObjects);
+              const method = methodInfo.method;
               const line = getLine(node);
 
               const request: HttpRequestNode = {
@@ -305,6 +321,7 @@ export class FetchAnalyzer extends Plugin {
                 type: 'http:request',
                 name: `${method} ${url}`,
                 method: method,
+                methodSource: methodInfo.source,
                 url: url,
                 library: calleeName,
                 file: module.file!,
@@ -328,15 +345,24 @@ export class FetchAnalyzer extends Plugin {
       // Extract httpRequests for external API handling
       const httpRequests = fetchCalls.map(fc => fc.request);
 
+      // Pre-fetch FUNCTION and CALL nodes for this file once (avoid N+1 IPC queries)
+      const fileFunctions: NodeRecord[] = [];
+      for await (const fn of graph.queryNodes({ type: 'FUNCTION', file: module.file! })) {
+        fileFunctions.push(fn);
+      }
+      const fileCalls: NodeRecord[] = [];
+      for await (const cn of graph.queryNodes({ type: 'CALL', file: module.file! })) {
+        fileCalls.push(cn);
+      }
+
       // Создаём HTTP_REQUEST ноды
       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,
+          const responseDataNodeId = this.findResponseJsonCallInMemory(
+            fileCalls,
             fetchCall.responseVarName,
             request.line
           );
@@ -345,67 +371,58 @@ export class FetchAnalyzer extends Plugin {
           }
         }
 
-        await graph.addNode(request as unknown as NodeRecord);
+        nodes.push(request as unknown as NodeRecord);
 
         // Создаём ребро от модуля к request
-        await graph.addEdge({
+        edges.push({
           type: 'CONTAINS',
           src: module.id,
           dst: request.id
         });
 
-        // http:request --CALLS--> net:request singleton (created lazily)
-        const networkId = await this.ensureNetworkNode(graph);
-        await graph.addEdge({
+        // http:request --CALLS--> net:request singleton
+        edges.push({
           type: 'CALLS',
           src: request.id,
-          dst: networkId
+          dst: this.networkNodeId!
         });
 
-        // Ищем FUNCTION node которая делает запрос
-        const functions: NodeRecord[] = [];
-        for await (const fn of graph.queryNodes({ type: 'FUNCTION' })) {
-          if (
-            fn.file === request.file &&
-            (fn.line ?? 0) <= request.line &&
-            (fn.line ?? 0) + 50 >= request.line
-          ) {
-            functions.push(fn);
-          }
-        }
+        // Ищем FUNCTION node которая делает запрос (in-memory filter)
+        const functions = fileFunctions.filter(fn =>
+          fn.line != null &&
+          fn.line <= request.line &&
+          fn.line + 50 >= request.line
+        );
 
         if (functions.length > 0) {
           // Берём ближайшую функцию
           const closestFunction = functions.reduce((closest, func) => {
-            const currentDistance = Math.abs((func.line ?? 0) - request.line);
-            const closestDistance = Math.abs((closest.line ?? 0) - request.line);
+            const currentDistance = Math.abs(func.line! - request.line);
+            const closestDistance = Math.abs(closest.line! - request.line);
             return currentDistance < closestDistance ? func : closest;
           });
 
-          await graph.addEdge({
+          edges.push({
             type: 'MAKES_REQUEST',
             src: closestFunction.id,
             dst: request.id
           });
         }
 
-        // Find CALL node that makes this request (same file, same line)
-        // Determine expected call name based on library
+        // Find CALL node that makes this request (same file, same line, in-memory)
         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
-          }
+        const matchingCall = fileCalls.find(callNode =>
+          callNode.line === request.line &&
+          expectedCallNames.includes(callNode.name as string)
+        );
+
+        if (matchingCall) {
+          edges.push({
+            type: 'MAKES_REQUEST',
+            src: matchingCall.id,
+            dst: request.id
+          });
         }
       }
 
@@ -416,7 +433,7 @@ export class FetchAnalyzer extends Plugin {
         // Проверяем что нода ещё не создана
         const existingApi = await graph.getNode(apiId);
         if (!existingApi) {
-          await graph.addNode({
+          nodes.push({
             id: apiId,
             type: 'EXTERNAL',
             domain: apiDomain,
@@ -428,7 +445,7 @@ export class FetchAnalyzer extends Plugin {
         const apiRequests = httpRequests.filter(r => r.url.includes(apiDomain));
 
         for (const request of apiRequests) {
-          await graph.addEdge({
+          edges.push({
             type: 'CALLS_API',
             src: request.id,
             dst: apiId
@@ -436,11 +453,19 @@ export class FetchAnalyzer extends Plugin {
         }
       }
 
+      // Flush batched operations
+      if (nodes.length > 0) {
+        await graph.addNodes(nodes);
+      }
+      if (edges.length > 0) {
+        await graph.addEdges(edges);
+      }
+
       return {
         requests: fetchCalls.length,
         apis: externalAPIs.size
       };
-    } catch (error) {
+    } catch {
       // Silent - per-module errors shouldn't spam logs
       return { requests: 0, apis: 0 };
     }
@@ -480,38 +505,77 @@ export class FetchAnalyzer extends Plugin {
   }
 
   /**
-   * Извлекает HTTP method из options объекта
+   * Извлекает HTTP method из options объекта и источник значения
    */
-  private extractMethod(optionsArg: Node | undefined): string | null {
-    if (!optionsArg || optionsArg.type !== 'ObjectExpression') {
-      return null;
+  private extractMethodInfo(
+    optionsArg: Node | undefined,
+    constStrings: Map<string, string>,
+    constObjects: Map<string, ObjectExpression>
+  ): { method: string; source: MethodSource } {
+    if (!optionsArg) {
+      return { method: 'GET', source: 'default' };
+    }
+
+    let optionsNode: Node = optionsArg;
+    if (optionsNode.type === 'Identifier') {
+      const resolvedObject = constObjects.get((optionsNode as Identifier).name);
+      if (resolvedObject) {
+        optionsNode = resolvedObject;
+      } else {
+        return { method: 'UNKNOWN', source: 'unknown' };
+      }
+    }
+
+    if (optionsNode.type !== 'ObjectExpression') {
+      return { method: 'UNKNOWN', source: 'unknown' };
     }
 
-    const objExpr = optionsArg as ObjectExpression;
-    const methodProp = objExpr.properties.find(
-      p =>
-        p.type === 'ObjectProperty' &&
-        (p.key as Identifier).type === 'Identifier' &&
-        (p.key as Identifier).name === 'method'
-    );
+    const objExpr = optionsNode as ObjectExpression;
+    const methodProp = objExpr.properties.find(p => {
+      if (p.type !== 'ObjectProperty') return false;
+      const key = p.key;
+      if (key.type === 'Identifier') return key.name === 'method';
+      if (key.type === 'StringLiteral') return key.value === 'method';
+      return false;
+    });
+
+    if (!methodProp || !(methodProp as { value?: Node }).value) {
+      return { method: 'GET', source: 'default' };
+    }
 
-    if (methodProp && (methodProp as { value: Node }).value) {
-      return this.extractString((methodProp as { value: Node }).value);
+    const methodValue = (methodProp as { value: Node }).value;
+    const methodString = this.extractStaticString(methodValue, constStrings);
+    if (!methodString) {
+      return { method: 'UNKNOWN', source: 'unknown' };
     }
 
-    return null;
+    return { method: methodString.toUpperCase(), source: 'explicit' };
   }
 
   /**
-   * Извлекает строковое значение
+   * Извлекает статическое строковое значение (StringLiteral, простая TemplateLiteral, или const Identifier)
    */
-  private extractString(node: Node | undefined): string | null {
+  private extractStaticString(
+    node: Node | undefined,
+    constStrings: Map<string, string>
+  ): string | null {
     if (!node) return null;
 
     if (node.type === 'StringLiteral') {
       return (node as { value: string }).value;
     }
 
+    if (node.type === 'TemplateLiteral') {
+      const tl = node as { quasis: Array<{ value: { raw: string } }>; expressions: unknown[] };
+      if (tl.expressions.length === 0) {
+        return tl.quasis.map(q => q.value.raw).join('');
+      }
+    }
+
+    if (node.type === 'Identifier') {
+      return constStrings.get((node as Identifier).name) || null;
+    }
+
     return null;
   }
 
@@ -605,48 +669,36 @@ export class FetchAnalyzer extends Plugin {
 
   /**
    * 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.
+   * from pre-fetched CALL nodes for the current file.
    *
-   * Important: Filters to find the response.json() call AFTER the fetch line and
+   * 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 fileCalls - Pre-fetched CALL nodes for this file
    * @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,
+  private findResponseJsonCallInMemory(
+    fileCalls: NodeRecord[],
     responseVarName: string,
     fetchLine: number
-  ): Promise<string | null> {
-    // Collect all matching CALL nodes
-    const candidates: Array<{ id: string; line: number }> = [];
+  ): string | null {
+    let bestId: string | null = null;
+    let bestLine = Infinity;
 
-    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
+    for (const node of fileCalls) {
       const callNode = node as unknown as { object?: string; method?: string };
       if (callNode.object !== responseVarName) continue;
+      if (!callNode.method || !RESPONSE_CONSUMPTION_METHODS.includes(callNode.method)) 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 (node.line == null) continue;
+      if (node.line > fetchLine && node.line < bestLine) {
+        bestId = node.id;
+        bestLine = node.line;
       }
     }
 
-    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;
+    return bestId;
   }
 }

package/src/plugins/analysis/IncrementalAnalysisPlugin.ts

@@ -23,15 +23,16 @@ import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 import type { GraphBackend } from '@grafema/types';
 import type { NodeRecord } from '@grafema/types';
-import { versionManager, VersionedNode } from '../../core/VersionManager.js';
+import type { VersionedNode } from '../../core/VersionManager.js';
+import { versionManager } from '../../core/VersionManager.js';
 import { VCSPluginFactory } from '../vcs/index.js';
 import type { VCSPlugin } from '../vcs/VCSPlugin.js';
-import { parse, ParserPlugin } from '@babel/parser';
+import type { ParserPlugin } from '@babel/parser';
+import { parse } from '@babel/parser';
 import traverseModule from '@babel/traverse';
 import type { NodePath } from '@babel/traverse';
 import { readFile } from 'fs/promises';
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const traverse = (traverseModule as any).default || traverseModule;
 
 /**
@@ -77,7 +78,6 @@ export class IncrementalAnalysisPlugin extends Plugin {
     return {
       name: 'IncrementalAnalysisPlugin',
       phase: 'ANALYSIS',
-      priority: 85, // Запускается после JSModuleIndexer (90) но перед JSASTAnalyzer (80)
       creates: {
         nodes: ['FUNCTION', 'CLASS', 'VARIABLE_DECLARATION'], // Создаёт __local версии
         edges: ['REPLACES', 'CALLS', 'USES']
@@ -184,7 +184,8 @@ export class IncrementalAnalysisPlugin extends Plugin {
       );
     } catch (error) {
       logger.error('Incremental analysis failed', { error: error instanceof Error ? error.message : String(error) });
-      return createErrorResult(error as Error);
+      const err = error instanceof Error ? error : new Error(String(error));
+      return createErrorResult(err);
     }
   }
 
@@ -642,7 +643,6 @@ export class IncrementalAnalysisPlugin extends Plugin {
    * This method was disabled as part of stableId removal (REG-140).
    * The getNodesByStableId method never existed on GraphBackend.
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   private async findCalleeAndCreateEdge(
     _callerId: string,
     _calleeStableId: string,
@@ -656,7 +656,6 @@ export class IncrementalAnalysisPlugin extends Plugin {
   /**
    * Анализировать методы класса
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   private async analyzeClassMethods(
     _classNode: VersionedNode,
     _ast: unknown,