@grafema/core 0.1.1-alpha → 0.2.0-beta

package/src/plugins/analysis/RustAnalyzer.ts

@@ -136,21 +136,21 @@ interface EdgeToAdd {
   [key: string]: unknown;
 }
 
-// NAPI binding - will be exported from rust-engine after build
+// NAPI binding - will be exported from packages/rfdb-server after build
 let parseRustFile: ((code: string) => RustParseResult) | undefined;
 
 // Try to load the native binding
-// Path: from dist/plugins/analysis/ go up 5 levels to reach project root, then rust-engine/
+// 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('../../../../../rust-engine/grafema-graph-engine.node' as 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);
-    const nativeBinding = require('../../../../../rust-engine/grafema-graph-engine.node');
+    const nativeBinding = require('../../../../../packages/rfdb-server/grafema-graph-engine.node');
     parseRustFile = nativeBinding.parseRustFile;
   } catch {
     // Silent - will be reported during execute if needed

package/src/plugins/analysis/SQLiteAnalyzer.ts

@@ -16,7 +16,7 @@ import type { NodePath } from '@babel/traverse';
 import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 import type { NodeRecord } from '@grafema/types';
-import { getLine } from './ast/utils/location.js';
+import { getLine, getColumn } from './ast/utils/location.js';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const traverse = (traverseModule as any).default || traverseModule;
@@ -34,6 +34,7 @@ interface SQLiteQueryNode {
   tableName: string | null;
   file: string;
   line: number;
+  column: number;
   promiseWrapped?: boolean;
 }
 
@@ -181,7 +182,8 @@ export class SQLiteAnalyzer extends Plugin {
                   operationType: operationType,
                   tableName: tableName,
                   file: module.file!,
-                  line: getLine(node)
+                  line: getLine(node),
+                  column: getColumn(node)
                 });
               }
             }
@@ -254,6 +256,7 @@ export class SQLiteAnalyzer extends Plugin {
                           tableName: tableName,
                           file: module.file!,
                           line: getLine(innerNode),
+                          column: getColumn(innerNode),
                           promiseWrapped: true
                         });
                       }

package/src/plugins/analysis/SocketIOAnalyzer.ts

@@ -56,6 +56,7 @@ interface SocketListenerNode {
   handlerLine: number;
   file: string;
   line: number;
+  column: number;
 }
 
 /**
@@ -68,6 +69,19 @@ interface SocketRoomNode {
   objectName: string;
   file: string;
   line: number;
+  column: number;
+}
+
+/**
+ * Socket event channel node - represents a single event across all emitters/listeners
+ */
+interface SocketEventNode {
+  id: string;
+  type: 'socketio:event';
+  name: string;        // Event name (e.g., "slot:booked")
+  event: string;       // Same as name, for consistency
+  file?: string;       // Not applicable - event is global
+  line?: number;       // Not applicable
 }
 
 /**
@@ -86,8 +100,8 @@ export class SocketIOAnalyzer extends Plugin {
       phase: 'ANALYSIS',
       priority: 75, // После JSASTAnalyzer (80)
       creates: {
-        nodes: ['socketio:emit', 'socketio:on', 'socketio:room'],
-        edges: ['CONTAINS', 'EMITS_EVENT', 'LISTENS_TO', 'JOINS_ROOM']
+        nodes: ['socketio:emit', 'socketio:on', 'socketio:room', 'socketio:event'],
+        edges: ['CONTAINS', 'EMITS_EVENT', 'LISTENS_TO', 'JOINS_ROOM', 'LISTENED_BY']
       },
       dependencies: ['JSModuleIndexer', 'JSASTAnalyzer']
     };
@@ -108,6 +122,7 @@ export class SocketIOAnalyzer extends Plugin {
       let roomsCount = 0;
       const startTime = Date.now();
 
+      // PHASE 1: Analyze modules and create emit/listener/room nodes
       for (let i = 0; i < modules.length; i++) {
         const module = modules[i];
         const result = await this.analyzeModule(module, graph);
@@ -128,14 +143,22 @@ export class SocketIOAnalyzer extends Plugin {
         }
       }
 
-      logger.info('Analysis complete', { emitsCount, listenersCount, roomsCount });
+      // PHASE 2: Create event channel nodes and edges
+      const eventCount = await this.createEventChannels(graph, logger);
+
+      logger.info('Analysis complete', {
+        emitsCount,
+        listenersCount,
+        roomsCount,
+        eventCount
+      });
 
       return createSuccessResult(
         {
-          nodes: emitsCount + listenersCount + roomsCount,
+          nodes: emitsCount + listenersCount + roomsCount + eventCount,
           edges: 0
         },
-        { emitsCount, listenersCount, roomsCount }
+        { emitsCount, listenersCount, roomsCount, eventCount }
       );
     } catch (error) {
       logger.error('Analysis failed', { error });
@@ -143,6 +166,95 @@ export class SocketIOAnalyzer extends Plugin {
     }
   }
 
+  /**
+   * Create event channel nodes and connect them to emits/listeners
+   *
+   * This runs AFTER all modules are analyzed, so all emit/listener nodes exist.
+   * Creates one socketio:event node per unique event name, then connects:
+   * - socketio:emit → EMITS_EVENT → socketio:event
+   * - socketio:event → LISTENED_BY → socketio:on
+   */
+  private async createEventChannels(
+    graph: PluginContext['graph'],
+    logger: ReturnType<typeof this.log>
+  ): Promise<number> {
+    try {
+      // Step 1: Get all emit and listener nodes
+      const allEmits = await graph.getAllNodes({ type: 'socketio:emit' });
+      const allListeners = await graph.getAllNodes({ type: 'socketio:on' });
+
+      logger.debug('Creating event channels', {
+        emits: allEmits.length,
+        listeners: allListeners.length
+      });
+
+      // Step 2: Extract unique event names
+      const eventNames = new Set<string>();
+
+      for (const emit of allEmits) {
+        if (emit.event && typeof emit.event === 'string') {
+          eventNames.add(emit.event);
+        }
+      }
+
+      for (const listener of allListeners) {
+        if (listener.event && typeof listener.event === 'string') {
+          eventNames.add(listener.event);
+        }
+      }
+
+      logger.debug('Unique events found', { count: eventNames.size });
+
+      // Step 3: Create event channel node for each unique event
+      let createdCount = 0;
+      for (const eventName of eventNames) {
+        const eventNodeId = `socketio:event#${eventName}`;
+
+        // Create event channel node
+        const eventNode: SocketEventNode = {
+          id: eventNodeId,
+          type: 'socketio:event',
+          name: eventName,
+          event: eventName
+        };
+
+        await graph.addNode(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({
+            type: 'EMITS_EVENT',
+            src: emit.id,
+            dst: eventNodeId
+          });
+        }
+
+        // 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({
+            type: 'LISTENED_BY',
+            src: eventNodeId,
+            dst: listener.id
+          });
+        }
+
+        logger.debug('Created event channel', {
+          event: eventName,
+          emits: matchingEmits.length,
+          listeners: matchingListeners.length
+        });
+      }
+
+      return createdCount;
+    } catch (error) {
+      logger.error('Failed to create event channels', { error });
+      return 0;
+    }
+  }
+
   private async analyzeModule(
     module: NodeRecord,
     graph: PluginContext['graph']
@@ -262,7 +374,8 @@ export class SocketIOAnalyzer extends Plugin {
               handlerName: handlerName,
               handlerLine: handlerLine,
               file: module.file!,
-              line: line
+              line: line,
+              column: getColumn(node)
             });
           }
 
@@ -283,7 +396,8 @@ export class SocketIOAnalyzer extends Plugin {
                 room: roomName,
                 objectName: objectName,
                 file: module.file!,
-                line: line
+                line: line,
+                column: getColumn(node)
               });
             }
           }