@grafema/core 0.2.4-beta → 0.2.5-beta

package/src/plugins/analysis/ReactAnalyzer.ts

@@ -11,7 +11,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 { NodePath } from '@babel/traverse';
 import type { Node, CallExpression, JSXElement, JSXAttribute, VariableDeclarator, FunctionDeclaration } from '@babel/types';
@@ -20,7 +21,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;
 
 // React event handlers mapping
@@ -203,7 +203,6 @@ export class ReactAnalyzer extends Plugin {
     return {
       name: 'ReactAnalyzer',
       phase: 'ANALYSIS',
-      priority: 70, // After JSASTAnalyzer and ExpressAnalyzer
       creates: {
         nodes: [
           'react:component', 'react:state', 'react:effect', 'react:callback',
@@ -254,7 +253,7 @@ export class ReactAnalyzer extends Plugin {
           stats.browserAPIs += result.browserAPIs;
           stats.issues += result.issues;
           stats.edges += result.edges;
-        } catch (err) {
+        } catch {
           // Silent - per-module errors shouldn't spam logs
         }
       }
@@ -275,7 +274,8 @@ export class ReactAnalyzer 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);
     }
   }
 
@@ -731,7 +731,7 @@ export class ReactAnalyzer extends Plugin {
     const callbackParams = new Set<string>(); // Track parameters of nested callback functions
 
     // Simple recursive AST walker to collect identifiers
-    const collectIdentifiers = (node: Node | null, parentType: string | null = null, isPropertyKey = false): void => {
+    const collectIdentifiers = (node: Node | null, _parentType: string | null = null, isPropertyKey = false): void => {
       if (!node) return;
 
       if (node.type === 'Identifier') {
@@ -879,7 +879,7 @@ export class ReactAnalyzer extends Plugin {
     const hasCleanup = hookData.hasCleanup as boolean;
 
     // Simple recursive AST walker
-    const checkNode = (node: Node | null, parent: Node | null = null): void => {
+    const checkNode = (node: Node | null, _parent: Node | null = null): void => {
       if (!node || typeof node !== 'object') return;
 
       if (node.type === 'CallExpression') {
@@ -1324,11 +1324,14 @@ export class ReactAnalyzer extends Plugin {
     graph: PluginContext['graph'],
     moduleId: string | null
   ): Promise<void> {
-    // Add component nodes
+    const nodes: NodeRecord[] = [];
+    const edges: Array<{ type: string; src: string; dst: string; [key: string]: unknown }> = [];
+
+    // Collect component nodes and DEFINES edges
     for (const component of analysis.components) {
-      await graph.addNode(component as unknown as NodeRecord);
+      nodes.push(component as unknown as NodeRecord);
       if (moduleId) {
-        await graph.addEdge({
+        edges.push({
           type: 'DEFINES',
           src: moduleId,
           dst: component.id
@@ -1336,33 +1339,37 @@ export class ReactAnalyzer extends Plugin {
       }
     }
 
-    // Add hook nodes
+    // Collect hook nodes
     for (const hook of analysis.hooks) {
-      await graph.addNode(hook as unknown as NodeRecord);
+      nodes.push(hook as unknown as NodeRecord);
     }
 
-    // Add event nodes
+    // Collect event nodes
     for (const event of analysis.events) {
-      await graph.addNode(event as unknown as NodeRecord);
+      nodes.push(event as unknown as NodeRecord);
     }
 
-    // Add browser API nodes
+    // Collect browser API nodes
     for (const api of analysis.browserAPIs) {
-      await graph.addNode(api as unknown as NodeRecord);
+      nodes.push(api as unknown as NodeRecord);
     }
 
-    // Add issue nodes
+    // Collect issue nodes
     for (const issue of analysis.issues) {
-      await graph.addNode(issue as unknown as NodeRecord);
+      nodes.push(issue as unknown as NodeRecord);
     }
 
-    // Add edges
+    // Collect edges from analysis
     for (const edge of analysis.edges) {
       const { edgeType, ...rest } = edge;
-      await graph.addEdge({
+      edges.push({
         type: edgeType,
         ...rest
       });
     }
+
+    // Batch write to graph
+    await graph.addNodes(nodes);
+    await graph.addEdges(edges);
   }
 }

package/src/plugins/analysis/RustAnalyzer.ts

@@ -5,7 +5,7 @@
  */
 
 import { readFileSync } from 'fs';
-import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
+import { Plugin, createSuccessResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 import type { NodeRecord } from '@grafema/types';
 
@@ -137,16 +137,27 @@ interface EdgeToAdd {
 }
 
 // NAPI binding - will be exported from packages/rfdb-server after build
+// Loaded lazily on first execute() call to avoid top-level await (CJS compatibility)
 let parseRustFile: ((code: string) => RustParseResult) | undefined;
+let bindingLoaded = false;
+
+/**
+ * Load the native binding lazily on first use.
+ * This avoids top-level await which breaks esbuild CJS bundling.
+ */
+async function loadNativeBinding(): Promise<void> {
+  if (bindingLoaded) return;
+  bindingLoaded = true;
+
+  // Path: from dist/plugins/analysis/ go up 5 levels to reach project root, then packages/rfdb-server/
+  try {
+    const nativeBinding = await import('../../../../../packages/rfdb-server/grafema-graph-engine.node' as any);
+    parseRustFile = nativeBinding.parseRustFile;
+    return;
+  } catch {
+    // Dynamic import failed, try require fallback
+  }
 
-// Try to load the native binding
-// Path: from dist/plugins/analysis/ go up 5 levels to reach project root, then packages/rfdb-server/
-try {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const nativeBinding = await import('../../../../../packages/rfdb-server/grafema-graph-engine.node' as any);
-  parseRustFile = nativeBinding.parseRustFile;
-} catch {
-  // Fallback: try require
   try {
     const { createRequire } = await import('module');
     const require = createRequire(import.meta.url);
@@ -162,7 +173,6 @@ export class RustAnalyzer extends Plugin {
     return {
       name: 'RustAnalyzer',
       phase: 'ANALYSIS',
-      priority: 75, // Lower than JSASTAnalyzer (80)
       creates: {
         nodes: [
           'RUST_FUNCTION',
@@ -182,6 +192,9 @@ export class RustAnalyzer extends Plugin {
     const { graph, onProgress } = context;
     const logger = this.log(context);
 
+    // Load native binding lazily on first use
+    await loadNativeBinding();
+
     if (!parseRustFile) {
       logger.info('Skipping - native binding not available');
       return createSuccessResult(
@@ -239,10 +252,11 @@ export class RustAnalyzer extends Plugin {
           });
         }
       } catch (err) {
-        errors.push({ file: module.file!, error: (err as Error).message });
+        const message = err instanceof Error ? err.message : String(err);
+        errors.push({ file: module.file!, error: message });
         logger.warn('Error parsing module', {
           file: module.file,
-          error: (err as Error).message
+          error: message
         });
       }
     }
@@ -263,20 +277,21 @@ export class RustAnalyzer extends Plugin {
     module: NodeRecord,
     graph: PluginContext['graph']
   ): Promise<AnalysisStats> {
+    const nodes: NodeRecord[] = [];
     const edges: EdgeToAdd[] = [];
     let methodCount = 0;
     let callCount = 0;
 
-    // Helper to process calls within a function/method
-    const processCalls = async (
+    // Helper to collect calls within a function/method
+    const processCalls = (
       calls: RustCall[] | undefined,
       parentId: string,
       parentName: string
-    ): Promise<void> => {
+    ): void => {
       for (const call of calls || []) {
         const callId = `RUST_CALL#${parentName}#${call.line}#${call.column}#${module.file}`;
 
-        await graph.addNode({
+        nodes.push({
           id: callId,
           type: 'RUST_CALL',
           file: module.file,
@@ -299,7 +314,7 @@ export class RustAnalyzer extends Plugin {
     for (const fn of parseResult.functions) {
       const nodeId = `RUST_FUNCTION#${fn.name}#${module.file}#${fn.line}`;
 
-      await graph.addNode({
+      nodes.push({
         id: nodeId,
         type: 'RUST_FUNCTION',
         name: fn.name,
@@ -323,14 +338,14 @@ export class RustAnalyzer extends Plugin {
       edges.push({ src: module.id, dst: nodeId, type: 'CONTAINS' });
 
       // Process calls within this function
-      await processCalls(fn.calls, nodeId, fn.name);
+      processCalls(fn.calls, nodeId, fn.name);
     }
 
     // 2. Process structs
     for (const s of parseResult.structs) {
       const nodeId = `RUST_STRUCT#${s.name}#${module.file}#${s.line}`;
 
-      await graph.addNode({
+      nodes.push({
         id: nodeId,
         type: 'RUST_STRUCT',
         name: s.name,
@@ -348,7 +363,7 @@ export class RustAnalyzer extends Plugin {
     for (const impl of parseResult.impls) {
       const implId = `RUST_IMPL#${impl.targetType}${impl.traitName ? ':' + impl.traitName : ''}#${module.file}#${impl.line}`;
 
-      await graph.addNode({
+      nodes.push({
         id: implId,
         type: 'RUST_IMPL',
         name: impl.targetType,
@@ -372,7 +387,7 @@ export class RustAnalyzer extends Plugin {
       for (const method of impl.methods) {
         const methodId = `RUST_METHOD#${method.name}#${module.file}#${method.line}`;
 
-        await graph.addNode({
+        nodes.push({
           id: methodId,
           type: 'RUST_METHOD',
           name: method.name,
@@ -400,7 +415,7 @@ export class RustAnalyzer extends Plugin {
         methodCount++;
 
         // Process calls within this method
-        await processCalls(method.calls, methodId, `${impl.targetType}::${method.name}`);
+        processCalls(method.calls, methodId, `${impl.targetType}::${method.name}`);
       }
     }
 
@@ -408,7 +423,7 @@ export class RustAnalyzer extends Plugin {
     for (const t of parseResult.traits) {
       const nodeId = `RUST_TRAIT#${t.name}#${module.file}#${t.line}`;
 
-      await graph.addNode({
+      nodes.push({
         id: nodeId,
         type: 'RUST_TRAIT',
         name: t.name,
@@ -425,10 +440,9 @@ export class RustAnalyzer extends Plugin {
       edges.push({ src: module.id, dst: nodeId, type: 'CONTAINS' });
     }
 
-    // 5. Write all edges
-    for (const edge of edges) {
-      await graph.addEdge(edge);
-    }
+    // 5. Write all nodes and edges in batch
+    await graph.addNodes(nodes);
+    await graph.addEdges(edges);
 
     return {
       functions: parseResult.functions.length,

package/src/plugins/analysis/SQLiteAnalyzer.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;
 
 /**
@@ -54,7 +54,6 @@ export class SQLiteAnalyzer extends Plugin {
     return {
       name: 'SQLiteAnalyzer',
       phase: 'ANALYSIS',
-      priority: 75, // После JSASTAnalyzer (80)
       creates: {
         nodes: ['db:query'],
         edges: ['CONTAINS', 'EXECUTES_QUERY']
@@ -270,22 +269,30 @@ export class SQLiteAnalyzer extends Plugin {
       });
 
       // Создаём DATABASE_QUERY ноды
+      const nodes: NodeRecord[] = [];
+      const edges: Array<{ type: string; src: string; dst: string }> = [];
+
       for (const query of queries) {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const { promiseWrapped, ...queryData } = query;
 
-        await graph.addNode(queryData as unknown as NodeRecord);
+        nodes.push(queryData as unknown as NodeRecord);
         queriesCreated++;
 
         // MODULE -> CONTAINS -> DATABASE_QUERY
-        await graph.addEdge({
+        edges.push({
           type: 'CONTAINS',
           src: module.id,
           dst: query.id
         });
         edgesCreated++;
+      }
 
-        // Ищем FUNCTION ноду которая содержит этот query
+      // Flush nodes first so queryNodes can find them
+      await graph.addNodes(nodes);
+
+      // Find containing functions (reads FUNCTION nodes from JSASTAnalyzer)
+      for (const query of queries) {
         const containingFunctions: NodeRecord[] = [];
         for await (const n of graph.queryNodes({ type: 'FUNCTION' })) {
           if (
@@ -304,7 +311,7 @@ export class SQLiteAnalyzer extends Plugin {
           );
 
           // FUNCTION -> EXECUTES_QUERY -> DATABASE_QUERY
-          await graph.addEdge({
+          edges.push({
             type: 'EXECUTES_QUERY',
             src: closestFunction.id,
             dst: query.id
@@ -312,7 +319,10 @@ export class SQLiteAnalyzer extends Plugin {
           edgesCreated++;
         }
       }
-    } catch (error) {
+
+      // Flush all edges
+      await graph.addEdges(edges);
+    } catch {
       // Silent - per-module errors shouldn't spam logs
     }
 

package/src/plugins/analysis/ServiceLayerAnalyzer.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,
@@ -26,7 +27,6 @@ import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 import type { NodeRecord } from '@grafema/types';
 import { getLine } from './ast/utils/location.js';
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const traverse = (traverseModule as any).default || traverseModule;
 
 /**
@@ -90,7 +90,6 @@ export class ServiceLayerAnalyzer extends Plugin {
     return {
       name: 'ServiceLayerAnalyzer',
       phase: 'ANALYSIS',
-      priority: 75, // После JSASTAnalyzer (80)
       creates: {
         nodes: ['SERVICE_CLASS', 'SERVICE_INSTANCE', 'SERVICE_REGISTRATION', 'SERVICE_USAGE'],
         edges: ['CONTAINS', 'INSTANTIATES', 'REGISTERS', 'USES_SERVICE']
@@ -157,7 +156,8 @@ export class ServiceLayerAnalyzer 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);
     }
   }
 
@@ -303,12 +303,14 @@ export class ServiceLayerAnalyzer extends Plugin {
         }
       });
 
-      // Создаём ноды в графе
-      for (const serviceClass of serviceClasses) {
-        await graph.addNode(serviceClass as unknown as NodeRecord);
+      // Batch nodes and edges for IPC optimization
+      const nodes: Array<unknown> = [];
+      const edges: Array<{ type: string; src: string; dst: string }> = [];
 
-        // Создаём ребро от модуля к service class
-        await graph.addEdge({
+      // Collect all nodes
+      for (const serviceClass of serviceClasses) {
+        nodes.push(serviceClass as unknown as NodeRecord);
+        edges.push({
           type: 'CONTAINS',
           src: module.id,
           dst: serviceClass.id
@@ -316,33 +318,17 @@ export class ServiceLayerAnalyzer extends Plugin {
       }
 
       for (const instance of serviceInstances) {
-        await graph.addNode(instance as unknown as NodeRecord);
-
-        // Создаём ребро от модуля к instance
-        await graph.addEdge({
+        nodes.push(instance as unknown as NodeRecord);
+        edges.push({
           type: 'CONTAINS',
           src: module.id,
           dst: instance.id
         });
-
-        // Ищем SERVICE_CLASS ноду и создаём ребро INSTANTIATES
-        for await (const n of graph.queryNodes({ type: 'SERVICE_CLASS' })) {
-          if (n.name === instance.serviceClass) {
-            await graph.addEdge({
-              type: 'INSTANTIATES',
-              src: instance.id,
-              dst: n.id
-            });
-            break;
-          }
-        }
       }
 
       for (const registration of serviceRegistrations) {
-        await graph.addNode(registration as unknown as NodeRecord);
-
-        // Создаём ребро от модуля к registration
-        await graph.addEdge({
+        nodes.push(registration as unknown as NodeRecord);
+        edges.push({
           type: 'CONTAINS',
           src: module.id,
           dst: registration.id
@@ -350,23 +336,41 @@ export class ServiceLayerAnalyzer extends Plugin {
       }
 
       for (const usage of serviceUsages) {
-        await graph.addNode(usage as unknown as NodeRecord);
-
-        // Создаём ребро от модуля к usage
-        await graph.addEdge({
+        nodes.push(usage as unknown as NodeRecord);
+        edges.push({
           type: 'CONTAINS',
           src: module.id,
           dst: usage.id
         });
       }
 
+      // First flush: add all nodes to graph
+      await graph.addNodes(nodes as NodeRecord[]);
+
+      // Create INSTANTIATES edges (requires querying graph)
+      for (const instance of serviceInstances) {
+        for await (const n of graph.queryNodes({ type: 'SERVICE_CLASS' })) {
+          if (n.name === instance.serviceClass) {
+            edges.push({
+              type: 'INSTANTIATES',
+              src: instance.id,
+              dst: n.id
+            });
+            break;
+          }
+        }
+      }
+
+      // Second flush: add all edges to graph
+      await graph.addEdges(edges);
+
       return {
         classes: serviceClasses.length,
         instances: serviceInstances.length,
         registrations: serviceRegistrations.length,
         usages: serviceUsages.length
       };
-    } catch (error) {
+    } catch {
       // Silent - per-module errors shouldn't spam logs
       return { classes: 0, instances: 0, registrations: 0, usages: 0 };
     }

package/src/plugins/analysis/SocketIOAnalyzer.ts

@@ -16,7 +16,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';
@@ -25,7 +26,7 @@ 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;
 
 /**
@@ -98,7 +99,6 @@ export class SocketIOAnalyzer extends Plugin {
     return {
       name: 'SocketIOAnalyzer',
       phase: 'ANALYSIS',
-      priority: 75, // После JSASTAnalyzer (80)
       creates: {
         nodes: ['socketio:emit', 'socketio:on', 'socketio:room', 'socketio:event'],
         edges: ['CONTAINS', 'EMITS_EVENT', 'LISTENS_TO', 'JOINS_ROOM', 'LISTENED_BY']
@@ -162,7 +162,8 @@ export class SocketIOAnalyzer 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);
     }
   }
 
@@ -206,7 +207,10 @@ export class SocketIOAnalyzer extends Plugin {
       logger.debug('Unique events found', { count: eventNames.size });
 
       // Step 3: Create event channel node for each unique event
+      const nodes: NodeRecord[] = [];
+      const edges: Array<{ type: string; src: string; dst: string }> = [];
       let createdCount = 0;
+
       for (const eventName of eventNames) {
         const eventNodeId = `socketio:event#${eventName}`;
 
@@ -218,13 +222,13 @@ export class SocketIOAnalyzer extends Plugin {
           event: eventName
         };
 
-        await graph.addNode(eventNode as unknown as NodeRecord);
+        nodes.push(eventNode as unknown as NodeRecord);
         createdCount++;
 
         // Step 4: Connect all emits of this event to the channel
         const matchingEmits = allEmits.filter(e => e.event === eventName);
         for (const emit of matchingEmits) {
-          await graph.addEdge({
+          edges.push({
             type: 'EMITS_EVENT',
             src: emit.id,
             dst: eventNodeId
@@ -234,7 +238,7 @@ export class SocketIOAnalyzer extends Plugin {
         // Step 5: Connect event channel to all listeners of this event
         const matchingListeners = allListeners.filter(l => l.event === eventName);
         for (const listener of matchingListeners) {
-          await graph.addEdge({
+          edges.push({
             type: 'LISTENED_BY',
             src: eventNodeId,
             dst: listener.id
@@ -248,6 +252,10 @@ export class SocketIOAnalyzer extends Plugin {
         });
       }
 
+      // Flush all nodes and edges
+      await graph.addNodes(nodes);
+      await graph.addEdges(edges);
+
       return createdCount;
     } catch (error) {
       logger.error('Failed to create event channels', { error });
@@ -405,11 +413,14 @@ export class SocketIOAnalyzer extends Plugin {
       });
 
       // Создаём ноды в графе
+      const nodes: NodeRecord[] = [];
+      const edges: Array<{ type: string; src: string; dst: string }> = [];
+
       for (const emit of emits) {
-        await graph.addNode(emit as unknown as NodeRecord);
+        nodes.push(emit as unknown as NodeRecord);
 
         // Создаём ребро от модуля к event
-        await graph.addEdge({
+        edges.push({
           type: 'CONTAINS',
           src: module.id,
           dst: emit.id
@@ -417,10 +428,10 @@ export class SocketIOAnalyzer extends Plugin {
       }
 
       for (const listener of listeners) {
-        await graph.addNode(listener as unknown as NodeRecord);
+        nodes.push(listener as unknown as NodeRecord);
 
         // Создаём ребро от модуля к listener
-        await graph.addEdge({
+        edges.push({
           type: 'CONTAINS',
           src: module.id,
           dst: listener.id
@@ -439,7 +450,7 @@ export class SocketIOAnalyzer extends Plugin {
         );
 
         if (handlerFunction) {
-          await graph.addEdge({
+          edges.push({
             type: 'LISTENS_TO',
             src: listener.id,
             dst: handlerFunction.id
@@ -448,22 +459,26 @@ export class SocketIOAnalyzer extends Plugin {
       }
 
       for (const room of rooms) {
-        await graph.addNode(room as unknown as NodeRecord);
+        nodes.push(room as unknown as NodeRecord);
 
         // Создаём ребро от модуля к room
-        await graph.addEdge({
+        edges.push({
           type: 'CONTAINS',
           src: module.id,
           dst: room.id
         });
       }
 
+      // Flush all nodes and edges
+      await graph.addNodes(nodes);
+      await graph.addEdges(edges);
+
       return {
         emits: emits.length,
         listeners: listeners.length,
         rooms: rooms.length
       };
-    } catch (error) {
+    } catch {
       // Silent - per-module errors shouldn't spam logs
       return { emits: 0, listeners: 0, rooms: 0 };
     }