@grafema/core 0.1.0-alpha.1

package/src/plugins/enrichment/MethodCallResolver.ts

@@ -0,0 +1,333 @@
+/**
+ * MethodCallResolver - обогащает METHOD_CALL ноды связями CALLS к определениям методов
+ *
+ * Находит вызовы методов (CALL с "object" атрибутом) и пытается связать их с:
+ * 1. Методами классов в том же файле
+ * 2. Методами классов в импортированных модулях
+ * 3. Методами объектов переменных
+ *
+ * СОЗДАЁТ РЁБРА:
+ * - METHOD_CALL -> CALLS -> METHOD (для методов классов)
+ * - METHOD_CALL -> CALLS -> FUNCTION (для методов объектов)
+ */
+
+import { Plugin, createSuccessResult } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+import type { BaseNodeRecord } from '@grafema/types';
+
+/**
+ * Extended call node with method properties
+ */
+interface MethodCallNode extends BaseNodeRecord {
+  object?: string;
+  method?: string;
+}
+
+/**
+ * Class entry in method index
+ */
+interface ClassEntry {
+  classNode: BaseNodeRecord;
+  methods: Map<string, BaseNodeRecord>;
+}
+
+export class MethodCallResolver extends Plugin {
+  private _containingClassCache?: Map<string, BaseNodeRecord | null>;
+
+  get metadata(): PluginMetadata {
+    return {
+      name: 'MethodCallResolver',
+      phase: 'ENRICHMENT',
+      priority: 50,
+      creates: {
+        nodes: [],
+        edges: ['CALLS']
+      }
+    };
+  }
+
+  async execute(context: PluginContext): Promise<PluginResult> {
+    const { graph, onProgress } = context;
+
+    console.log('[MethodCallResolver] Starting method call resolution...');
+
+    let methodCallsProcessed = 0;
+    let edgesCreated = 0;
+    let unresolved = 0;
+
+    // Собираем все METHOD_CALL ноды (CALL с object атрибутом)
+    const methodCalls: MethodCallNode[] = [];
+    for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
+      const callNode = node as MethodCallNode;
+      if (callNode.object) {
+        methodCalls.push(callNode);
+      }
+    }
+
+    console.log(`[MethodCallResolver] Found ${methodCalls.length} method calls to resolve`);
+
+    // Собираем все классы и их методы для быстрого поиска
+    const classMethodIndex = await this.buildClassMethodIndex(graph);
+    console.log(`[MethodCallResolver] Indexed ${classMethodIndex.size} classes`);
+
+    // Собираем переменные и их типы (если известны)
+    const variableTypes = await this.buildVariableTypeIndex(graph);
+
+    const startTime = Date.now();
+
+    for (const methodCall of methodCalls) {
+      methodCallsProcessed++;
+
+      // Report progress every 50 calls
+      if (onProgress && methodCallsProcessed % 50 === 0) {
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        onProgress({
+          phase: 'enrichment',
+          currentPlugin: 'MethodCallResolver',
+          message: `Resolving method calls ${methodCallsProcessed}/${methodCalls.length} (${elapsed}s)`,
+          totalFiles: methodCalls.length,
+          processedFiles: methodCallsProcessed
+        });
+      }
+
+      // Log every 10 calls with timing
+      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)`);
+      }
+
+      // Пропускаем внешние методы (console, Array.prototype, etc.)
+      if (this.isExternalMethod(methodCall.object!, methodCall.method!)) {
+        continue;
+      }
+
+      // Проверяем есть ли уже CALLS ребро
+      const existingEdges = await graph.getOutgoingEdges(methodCall.id, ['CALLS']);
+      if (existingEdges.length > 0) {
+        continue; // Уже есть связь
+      }
+
+      // Пытаемся найти определение метода
+      const targetMethod = await this.resolveMethodCall(
+        methodCall,
+        classMethodIndex,
+        variableTypes,
+        graph
+      );
+
+      if (targetMethod) {
+        await graph.addEdge({
+          src: methodCall.id,
+          dst: targetMethod.id,
+          type: 'CALLS'
+        });
+        edgesCreated++;
+      } else {
+        unresolved++;
+      }
+    }
+
+    const summary = {
+      methodCallsProcessed,
+      edgesCreated,
+      unresolved,
+      classesIndexed: classMethodIndex.size
+    };
+
+    console.log('[MethodCallResolver] Summary:', summary);
+
+    return createSuccessResult({ nodes: 0, edges: edgesCreated }, summary);
+  }
+
+  /**
+   * Строит индекс классов и их методов
+   */
+  private async buildClassMethodIndex(graph: PluginContext['graph']): Promise<Map<string, ClassEntry>> {
+    const index = new Map<string, ClassEntry>();
+    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}...`);
+      }
+
+      const className = classNode.name as string;
+      if (!className) continue;
+
+      const classEntry: ClassEntry = {
+        classNode,
+        methods: new Map()
+      };
+
+      const containsEdges = await graph.getOutgoingEdges(classNode.id, ['CONTAINS']);
+      for (const edge of containsEdges) {
+        const childNode = await graph.getNode(edge.dst);
+        if (childNode && (childNode.type === 'METHOD' || childNode.type === 'FUNCTION')) {
+          if (childNode.name) {
+            classEntry.methods.set(childNode.name as string, childNode);
+          }
+        }
+      }
+
+      index.set(className, classEntry);
+
+      // Также индексируем по файлу для локального резолвинга
+      const fileKey = `${classNode.file}:${className}`;
+      index.set(fileKey, classEntry);
+    }
+
+    const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
+    console.log(`[MethodCallResolver] Indexed ${index.size} class entries in ${totalTime}s`);
+
+    return index;
+  }
+
+  /**
+   * Строит индекс переменных и их типов (из INSTANCE_OF рёбер)
+   */
+  private async buildVariableTypeIndex(graph: PluginContext['graph']): Promise<Map<string, string>> {
+    const startTime = Date.now();
+    const index = new Map<string, string>();
+
+    for await (const classNode of graph.queryNodes({ nodeType: 'CLASS' })) {
+      if (!classNode.name) continue;
+
+      const incomingEdges = await graph.getIncomingEdges(classNode.id, ['INSTANCE_OF']);
+      for (const edge of incomingEdges) {
+        index.set(edge.src.toString(), classNode.name as string);
+      }
+    }
+
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+    console.log(`[MethodCallResolver] Built variable type index: ${index.size} entries in ${elapsed}s`);
+    return index;
+  }
+
+  /**
+   * Пытается найти определение метода
+   */
+  private async resolveMethodCall(
+    methodCall: MethodCallNode,
+    classMethodIndex: Map<string, ClassEntry>,
+    variableTypes: Map<string, string>,
+    graph: PluginContext['graph']
+  ): Promise<BaseNodeRecord | null> {
+    const { object, method, file } = methodCall;
+
+    if (!object || !method) return null;
+
+    // 1. Проверяем если object - это имя класса напрямую (статический вызов)
+    if (classMethodIndex.has(object)) {
+      const classEntry = classMethodIndex.get(object)!;
+      if (classEntry.methods.has(method)) {
+        return classEntry.methods.get(method)!;
+      }
+    }
+
+    // 2. Проверяем локальный класс в том же файле
+    const localKey = `${file}:${object}`;
+    if (classMethodIndex.has(localKey)) {
+      const classEntry = classMethodIndex.get(localKey)!;
+      if (classEntry.methods.has(method)) {
+        return classEntry.methods.get(method)!;
+      }
+    }
+
+    // 3. Проверяем если object - это "this" (ссылка на текущий класс)
+    if (object === 'this') {
+      if (!this._containingClassCache) this._containingClassCache = new Map();
+
+      let containingClass = this._containingClassCache.get(methodCall.id);
+      if (containingClass === undefined) {
+        containingClass = await this.findContainingClass(methodCall, graph);
+        this._containingClassCache.set(methodCall.id, containingClass);
+      }
+
+      if (containingClass && classMethodIndex.has(containingClass.name as string)) {
+        const classEntry = classMethodIndex.get(containingClass.name as string)!;
+        if (classEntry.methods.has(method)) {
+          return classEntry.methods.get(method)!;
+        }
+      }
+    }
+
+    // 4. Используем variableTypes индекс
+    for (const [, className] of variableTypes.entries()) {
+      if (className && classMethodIndex.has(className)) {
+        const classEntry = classMethodIndex.get(className)!;
+        if (classEntry.methods.has(method)) {
+          return classEntry.methods.get(method)!;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Находит класс, содержащий данный method call
+   */
+  private async findContainingClass(
+    methodCall: MethodCallNode,
+    graph: PluginContext['graph']
+  ): Promise<BaseNodeRecord | null> {
+    const incomingEdges = await graph.getIncomingEdges(methodCall.id, ['CONTAINS']);
+
+    for (const edge of incomingEdges) {
+      const parentNode = await graph.getNode(edge.src);
+      if (!parentNode) continue;
+
+      if (parentNode.type === 'CLASS') {
+        return parentNode;
+      }
+
+      const found = await this.findContainingClassRecursive(parentNode, graph, new Set());
+      if (found) return found;
+    }
+
+    return null;
+  }
+
+  private async findContainingClassRecursive(
+    node: BaseNodeRecord,
+    graph: PluginContext['graph'],
+    visited: Set<string>
+  ): Promise<BaseNodeRecord | null> {
+    if (visited.has(node.id.toString())) return null;
+    visited.add(node.id.toString());
+
+    const incomingEdges = await graph.getIncomingEdges(node.id, ['CONTAINS']);
+
+    for (const edge of incomingEdges) {
+      const parentNode = await graph.getNode(edge.src);
+      if (!parentNode) continue;
+
+      if (parentNode.type === 'CLASS') {
+        return parentNode;
+      }
+
+      const found = await this.findContainingClassRecursive(parentNode, graph, visited);
+      if (found) return found;
+    }
+
+    return null;
+  }
+
+  /**
+   * Проверяет является ли метод внешним (console, Array, Promise, etc.)
+   */
+  private isExternalMethod(object: string, method: string): boolean {
+    const externalObjects = new Set([
+      'console', 'Math', 'JSON', 'Object', 'Array', 'String', 'Number',
+      'Boolean', 'Date', 'RegExp', 'Error', 'Promise', 'Set', 'Map',
+      'WeakSet', 'WeakMap', 'Symbol', 'Proxy', 'Reflect', 'Intl',
+      'process', 'global', 'window', 'document', 'Buffer',
+      'fs', 'path', 'http', 'https', 'crypto', 'os', 'url', 'util'
+    ]);
+
+    return externalObjects.has(object);
+  }
+}

package/src/plugins/enrichment/MountPointResolver.ts

@@ -0,0 +1,264 @@
+/**
+ * MountPointResolver - ENRICHMENT plugin for resolving mount points
+ *
+ * Updates ENDPOINT nodes by adding fullPath based on MOUNT_POINT prefixes.
+ *
+ * Graph traversal:
+ * MOUNT_POINT --MOUNTS--> MODULE --EXPOSES--> ENDPOINT
+ *
+ * Updates:
+ * endpoint.fullPath = mountPoint.prefix + endpoint.localPath
+ */
+
+import { Plugin } from '../Plugin.js';
+import { createSuccessResult, createErrorResult } from '@grafema/types';
+import type { PluginMetadata, PluginContext, PluginResult, GraphBackend } from '@grafema/types';
+import type { BaseNodeRecord } from '@grafema/types';
+import type { EdgeRecord } from '@grafema/types';
+
+interface EdgeCriteria {
+  type?: string;
+  src?: string;
+  dst?: string;
+}
+
+interface MountPointNode extends BaseNodeRecord {
+  prefix: string;
+}
+
+interface EndpointNode extends BaseNodeRecord {
+  localPath?: string;
+  path?: string;
+  mountPrefixes?: string[];
+  fullPaths?: string[];
+  mountPrefix?: string;
+  fullPath?: string;
+}
+
+export class MountPointResolver extends Plugin {
+  get metadata(): PluginMetadata {
+    return {
+      name: 'MountPointResolver',
+      phase: 'ENRICHMENT',
+      priority: 90,  // High priority - one of first enrichment plugins
+      creates: {
+        nodes: [],  // Doesn't create new nodes
+        edges: []   // Doesn't create new edges
+      },
+      dependencies: ['JSModuleIndexer', 'JSASTAnalyzer']
+    };
+  }
+
+  async execute(context: PluginContext): Promise<PluginResult> {
+    try {
+      const { graph } = context;
+
+      let endpointsUpdated = 0;
+      let mountPointsProcessed = 0;
+
+      // Find all MOUNT_POINT nodes
+      const allNodes = await graph.getAllNodes();
+      const mountPoints = allNodes.filter(node => node.type === 'MOUNT_POINT') as MountPointNode[];
+
+      console.log(`[MountPointResolver] Found ${mountPoints.length} mount points`);
+
+      // For each top-level mount point (from app.use in index.js)
+      // apply recursive resolver
+      const processedMountPoints = new Set<string>();
+
+      for (const mountPoint of mountPoints) {
+        if (!processedMountPoints.has(mountPoint.id)) {
+          const updated = await this.resolveMountPoint(graph, mountPoint, '', processedMountPoints);
+          endpointsUpdated += updated;
+          mountPointsProcessed++;
+        }
+      }
+
+      // Fallback: process mount points without recursion (old logic for compatibility)
+      for (const mountPoint of mountPoints) {
+        if (processedMountPoints.has(mountPoint.id)) continue;
+        // Find MOUNT_POINT --MOUNTS--> MODULE edge
+        const mountsEdges = await this.findEdges(graph, {
+          type: 'MOUNTS',
+          src: mountPoint.id
+        });
+
+        for (const mountsEdge of mountsEdges) {
+          const targetModuleId = mountsEdge.dst;
+
+          // Find MODULE --EXPOSES--> ENDPOINT edges
+          const exposesEdges = await this.findEdges(graph, {
+            type: 'EXPOSES',
+            src: targetModuleId
+          });
+
+          for (const exposesEdge of exposesEdges) {
+            const endpointId = exposesEdge.dst;
+            const endpoint = await graph.getNode(endpointId) as EndpointNode | null;
+
+            if (endpoint && endpoint.type === 'ENDPOINT') {
+              // Support multiple mount points for one endpoint
+              // Store all prefixes and fullPaths in arrays
+              const mountPrefixes = endpoint.mountPrefixes || [];
+              const fullPaths = endpoint.fullPaths || [];
+
+              const prefix = mountPoint.prefix;
+              const fullPath = prefix + (endpoint.localPath || endpoint.path || '');
+
+              // Only add if not already added (avoid duplicates)
+              if (!mountPrefixes.includes(prefix)) {
+                mountPrefixes.push(prefix);
+                fullPaths.push(fullPath);
+              }
+
+              // Update endpoint node
+              const updatedEndpoint: EndpointNode = {
+                ...endpoint,
+                mountPrefixes,
+                fullPaths,
+                mountPrefix: endpoint.mountPrefix || prefix,
+                fullPath: endpoint.fullPath || fullPath
+              };
+
+              await graph.addNode(updatedEndpoint);
+              endpointsUpdated++;
+            }
+          }
+        }
+
+        mountPointsProcessed++;
+      }
+
+      console.log(`[MountPointResolver] Updated ${endpointsUpdated} endpoints from ${mountPointsProcessed} mount points`);
+
+      return createSuccessResult(
+        { nodes: 0, edges: 0 },
+        { endpointsUpdated, mountPointsProcessed }
+      );
+
+    } catch (error) {
+      console.error(`[MountPointResolver] Error:`, error);
+      return createErrorResult(error as Error);
+    }
+  }
+
+  /**
+   * Recursively resolve mount point and all nested mount points
+   */
+  private async resolveMountPoint(
+    graph: GraphBackend,
+    mountPoint: MountPointNode,
+    parentPrefix: string,
+    processedMountPoints: Set<string>
+  ): Promise<number> {
+    let endpointsUpdated = 0;
+
+    // Mark as processed
+    processedMountPoints.add(mountPoint.id);
+
+    // Calculate full prefix (parent + current)
+    const fullPrefix = parentPrefix + mountPoint.prefix;
+
+    // Find MOUNT_POINT --MOUNTS--> MODULE edge
+    const mountsEdges = await this.findEdges(graph, {
+      type: 'MOUNTS',
+      src: mountPoint.id
+    });
+
+    for (const mountsEdge of mountsEdges) {
+      const targetModuleId = mountsEdge.dst;
+
+      // 1. Process ENDPOINT in this module
+      const exposesEdges = await this.findEdges(graph, {
+        type: 'EXPOSES',
+        src: targetModuleId
+      });
+
+      for (const exposesEdge of exposesEdges) {
+        const endpointId = exposesEdge.dst;
+        const endpoint = await graph.getNode(endpointId) as EndpointNode | null;
+
+        if (endpoint && endpoint.type === 'ENDPOINT') {
+          // Support multiple mount points
+          const mountPrefixes = endpoint.mountPrefixes || [];
+          const fullPaths = endpoint.fullPaths || [];
+
+          const fullPath = fullPrefix + (endpoint.localPath || endpoint.path || '');
+
+          // Only add if not already added
+          if (!mountPrefixes.includes(fullPrefix)) {
+            mountPrefixes.push(fullPrefix);
+            fullPaths.push(fullPath);
+          }
+
+          // Update endpoint node with new data
+          const updatedEndpoint: EndpointNode = {
+            ...endpoint,
+            mountPrefixes,
+            fullPaths,
+            mountPrefix: endpoint.mountPrefix || fullPrefix,
+            fullPath: endpoint.fullPath || fullPath
+          };
+
+          await graph.addNode(updatedEndpoint);
+          endpointsUpdated++;
+        }
+      }
+
+      // 2. Recursively process nested MOUNT_POINT in this module
+      const definesEdges = await this.findEdges(graph, {
+        type: 'DEFINES',
+        src: targetModuleId
+      });
+
+      for (const definesEdge of definesEdges) {
+        const nestedMountPointId = definesEdge.dst;
+        const nestedMountPoint = await graph.getNode(nestedMountPointId) as MountPointNode | null;
+
+        if (nestedMountPoint && nestedMountPoint.type === 'MOUNT_POINT' &&
+            !processedMountPoints.has(nestedMountPointId)) {
+          // Recursively process nested mount point
+          endpointsUpdated += await this.resolveMountPoint(
+            graph,
+            nestedMountPoint,
+            fullPrefix,  // Pass accumulated prefix
+            processedMountPoints
+          );
+        }
+      }
+    }
+
+    return endpointsUpdated;
+  }
+
+  /**
+   * Helper method for finding edges by criteria
+   */
+  private async findEdges(graph: GraphBackend, criteria: EdgeCriteria): Promise<EdgeRecord[]> {
+    const result: EdgeRecord[] = [];
+
+    // Get all edges using RFDBServerBackend API
+    if (!graph.getAllEdges) {
+      return result;
+    }
+    const allEdges = await graph.getAllEdges();
+
+    for (const edge of allEdges) {
+      let matches = true;
+
+      for (const [key, value] of Object.entries(criteria)) {
+        const edgeRecord = edge as unknown as Record<string, unknown>;
+        if (edgeRecord[key] !== value) {
+          matches = false;
+          break;
+        }
+      }
+
+      if (matches) {
+        result.push(edge);
+      }
+    }
+
+    return result;
+  }
+}