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

package/src/plugins/analysis/SocketIOAnalyzer.ts

@@ -23,6 +23,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;
@@ -55,6 +56,7 @@ interface SocketListenerNode {
   handlerLine: number;
   file: string;
   line: number;
+  column: number;
 }
 
 /**
@@ -67,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
 }
 
 /**
@@ -85,26 +100,29 @@ 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']
     };
   }
 
   async execute(context: PluginContext): Promise<PluginResult> {
+    const logger = this.log(context);
+
     try {
       const { graph } = context;
 
       // Получаем все модули
       const modules = await this.getModules(graph);
-      console.log(`[SocketIOAnalyzer] Processing ${modules.length} modules...`);
+      logger.info('Processing modules', { count: modules.length });
 
       let emitsCount = 0;
       let listenersCount = 0;
       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);
@@ -116,29 +134,127 @@ export class SocketIOAnalyzer 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(
-            `[SocketIOAnalyzer] 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(
-        `[SocketIOAnalyzer] Found ${emitsCount} emits, ${listenersCount} listeners, ${roomsCount} rooms`
-      );
+      // 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) {
-      console.error('[SocketIOAnalyzer] Error:', error);
+      logger.error('Analysis failed', { error });
       return createErrorResult(error as Error);
     }
   }
 
+  /**
+   * 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']
@@ -178,8 +294,8 @@ export class SocketIOAnalyzer extends Plugin {
           ) {
             const objectName = this.getObjectName(callee.object);
             const event = this.extractStringArg(node.arguments[0]);
-            const line = node.loc!.start.line;
-            const column = node.loc!.start.column;
+            const line = getLine(node);
+            const column = getColumn(node);
 
             // io.to('room').emit() - room-based emit
             let room: string | null = null;
@@ -232,7 +348,7 @@ export class SocketIOAnalyzer extends Plugin {
           ) {
             const objectName = this.getObjectName(callee.object);
             const event = this.extractStringArg(node.arguments[0]);
-            const line = node.loc!.start.line;
+            const line = getLine(node);
             const handler = node.arguments[1];
 
             // Извлекаем имя handler функции
@@ -243,8 +359,8 @@ export class SocketIOAnalyzer extends Plugin {
                 handler.type === 'FunctionExpression' ||
                 handler.type === 'ArrowFunctionExpression'
               ) {
-                handlerName = `anonymous:${handler.loc!.start.line}`;
-                handlerLine = handler.loc!.start.line;
+                handlerName = `anonymous:${getLine(handler)}`;
+                handlerLine = getLine(handler);
               } else if (handler.type === 'Identifier') {
                 handlerName = (handler as Identifier).name;
               }
@@ -258,7 +374,8 @@ export class SocketIOAnalyzer extends Plugin {
               handlerName: handlerName,
               handlerLine: handlerLine,
               file: module.file!,
-              line: line
+              line: line,
+              column: getColumn(node)
             });
           }
 
@@ -270,7 +387,7 @@ export class SocketIOAnalyzer extends Plugin {
           ) {
             const objectName = this.getObjectName(callee.object);
             const roomName = this.extractStringArg(node.arguments[0]);
-            const line = node.loc!.start.line;
+            const line = getLine(node);
 
             if (objectName === 'socket') {
               rooms.push({
@@ -279,7 +396,8 @@ export class SocketIOAnalyzer extends Plugin {
                 room: roomName,
                 objectName: objectName,
                 file: module.file!,
-                line: line
+                line: line,
+                column: getColumn(node)
               });
             }
           }
@@ -308,15 +426,23 @@ export class SocketIOAnalyzer extends Plugin {
           dst: listener.id
         });
 
-        // Ищем FUNCTION node для handler и создаём ребро LISTENS_TO
-        const handlerFunctionId = `FUNCTION#${listener.handlerName}#${listener.file}#${listener.handlerLine}`;
-        const handlerFunction = await graph.getNode(handlerFunctionId);
+        // Find FUNCTION node for handler by name and file (supports both legacy and semantic IDs)
+        const handlerFunctions = await graph.getAllNodes({
+          type: 'FUNCTION',
+          name: listener.handlerName,
+          file: listener.file
+        });
+
+        // Find the handler at the matching line
+        const handlerFunction = handlerFunctions.find(fn =>
+          fn.line === listener.handlerLine
+        );
 
         if (handlerFunction) {
           await graph.addEdge({
             type: 'LISTENS_TO',
             src: listener.id,
-            dst: handlerFunctionId
+            dst: handlerFunction.id
           });
         }
       }
@@ -338,10 +464,7 @@ export class SocketIOAnalyzer extends Plugin {
         rooms: rooms.length
       };
     } catch (error) {
-      console.error(
-        `[SocketIOAnalyzer] Error analyzing ${module.file}:`,
-        (error as Error).message
-      );
+      // Silent - per-module errors shouldn't spam logs
       return { emits: 0, listeners: 0, rooms: 0 };
     }
   }

package/src/plugins/analysis/SystemDbAnalyzer.ts

@@ -58,6 +58,8 @@ export class SystemDbAnalyzer extends Plugin {
   }
 
   async execute(context: PluginContext): Promise<PluginResult> {
+    const logger = this.log(context);
+
     try {
       const { graph } = context;
 
@@ -67,9 +69,7 @@ export class SystemDbAnalyzer extends Plugin {
       // Get all MODULE nodes
       const modules = await this.getModules(graph);
 
-      console.log(
-        `[SystemDbAnalyzer] Analyzing ${modules.length} modules for system_db patterns...\n`
-      );
+      logger.info('Analyzing modules for system_db patterns', { count: modules.length });
 
       for (const module of modules) {
         if (!module.file) continue;
@@ -169,9 +169,13 @@ export class SystemDbAnalyzer extends Plugin {
           for (const reg of registrations) {
             const nodeId = `${module.file}:SYSTEM_DB_VIEW_REGISTRATION:${reg.viewName}:${reg.line}`;
 
-            console.log(
-              `   📌 Found: ${reg.type}('${reg.viewName}', '${reg.serverName}') at ${module.file!.split('/').pop()}:${reg.line}`
-            );
+            logger.debug('Found registration', {
+              type: reg.type,
+              viewName: reg.viewName,
+              serverName: reg.serverName,
+              file: module.file!.split('/').pop(),
+              line: reg.line
+            });
 
             await graph.addNode({
               id: nodeId,
@@ -221,21 +225,22 @@ export class SystemDbAnalyzer extends Plugin {
         } catch (err) {
           // Skip files that can't be parsed
           if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
-            console.error(`   ⚠️  Failed to analyze ${module.file}: ${(err as Error).message}`);
+            logger.warn('Failed to analyze module', {
+              file: module.file,
+              error: (err as Error).message
+            });
           }
         }
       }
 
-      console.log(
-        `[SystemDbAnalyzer] Created ${nodesCreated} system_db nodes, ${edgesCreated} edges\n`
-      );
+      logger.info('Analysis complete', { nodesCreated, edgesCreated });
 
       return createSuccessResult(
         { nodes: nodesCreated, edges: edgesCreated },
         { modulesAnalyzed: modules.length }
       );
     } catch (error) {
-      console.error(`[SystemDbAnalyzer] Error:`, error);
+      logger.error('Analysis failed', { error });
       return createErrorResult(error as Error);
     }
   }