@grafema/core 0.1.0-alpha.1

package/src/plugins/analysis/SocketIOAnalyzer.ts

@@ -0,0 +1,395 @@
+/**
+ * SocketIOAnalyzer - детектит Socket.IO operations
+ *
+ * Паттерны Server:
+ * - io.emit(event, data)
+ * - io.to(room).emit(event, data)
+ * - io.of(namespace).emit(event, data)
+ * - socket.on(event, handler)
+ * - socket.join(room)
+ * - socket.broadcast.emit(event, data)
+ *
+ * Паттерны Client:
+ * - socket.emit(event, data)
+ * - socket.on(event, handler)
+ * - socket.off(event, handler)
+ */
+
+import { readFileSync } from 'fs';
+import { parse, ParserPlugin } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+import type { CallExpression, Identifier, MemberExpression, Node } from '@babel/types';
+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';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const traverse = (traverseModule as any).default || traverseModule;
+
+/**
+ * Socket emit node
+ */
+interface SocketEmitNode {
+  id: string;
+  type: 'socketio:emit';
+  event: string;
+  room: string | null;
+  namespace: string | null;
+  broadcast: boolean;
+  objectName: string;
+  file: string;
+  line: number;
+  column: number;
+}
+
+/**
+ * Socket listener node
+ */
+interface SocketListenerNode {
+  id: string;
+  type: 'socketio:on';
+  event: string;
+  objectName: string;
+  handlerName: string;
+  handlerLine: number;
+  file: string;
+  line: number;
+}
+
+/**
+ * Socket room node
+ */
+interface SocketRoomNode {
+  id: string;
+  type: 'socketio:room';
+  room: string;
+  objectName: string;
+  file: string;
+  line: number;
+}
+
+/**
+ * Analysis result
+ */
+interface AnalysisResult {
+  emits: number;
+  listeners: number;
+  rooms: number;
+}
+
+export class SocketIOAnalyzer extends Plugin {
+  get metadata(): PluginMetadata {
+    return {
+      name: 'SocketIOAnalyzer',
+      phase: 'ANALYSIS',
+      priority: 75, // После JSASTAnalyzer (80)
+      creates: {
+        nodes: ['socketio:emit', 'socketio:on', 'socketio:room'],
+        edges: ['CONTAINS', 'EMITS_EVENT', 'LISTENS_TO', 'JOINS_ROOM']
+      },
+      dependencies: ['JSModuleIndexer', 'JSASTAnalyzer']
+    };
+  }
+
+  async execute(context: PluginContext): Promise<PluginResult> {
+    try {
+      const { graph } = context;
+
+      // Получаем все модули
+      const modules = await this.getModules(graph);
+      console.log(`[SocketIOAnalyzer] Processing ${modules.length} modules...`);
+
+      let emitsCount = 0;
+      let listenersCount = 0;
+      let roomsCount = 0;
+      const startTime = Date.now();
+
+      for (let i = 0; i < modules.length; i++) {
+        const module = modules[i];
+        const result = await this.analyzeModule(module, graph);
+        emitsCount += result.emits;
+        listenersCount += result.listeners;
+        roomsCount += result.rooms;
+
+        // Progress every 20 modules
+        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)`
+          );
+        }
+      }
+
+      console.log(
+        `[SocketIOAnalyzer] Found ${emitsCount} emits, ${listenersCount} listeners, ${roomsCount} rooms`
+      );
+
+      return createSuccessResult(
+        {
+          nodes: emitsCount + listenersCount + roomsCount,
+          edges: 0
+        },
+        { emitsCount, listenersCount, roomsCount }
+      );
+    } catch (error) {
+      console.error('[SocketIOAnalyzer] Error:', error);
+      return createErrorResult(error as Error);
+    }
+  }
+
+  private async analyzeModule(
+    module: NodeRecord,
+    graph: PluginContext['graph']
+  ): Promise<AnalysisResult> {
+    try {
+      const code = readFileSync(module.file!, 'utf-8');
+
+      const ast = parse(code, {
+        sourceType: 'module',
+        plugins: [
+          'jsx',
+          'typescript',
+          'classProperties',
+          'decorators-legacy',
+          'asyncGenerators',
+          'dynamicImport',
+          'optionalChaining',
+          'nullishCoalescingOperator'
+        ] as ParserPlugin[]
+      });
+
+      const emits: SocketEmitNode[] = [];
+      const listeners: SocketListenerNode[] = [];
+      const rooms: SocketRoomNode[] = [];
+
+      // Детект Socket.IO паттернов
+      traverse(ast, {
+        CallExpression: (path: NodePath<CallExpression>) => {
+          const node = path.node;
+          const callee = node.callee;
+
+          // Pattern: socket.emit(event, data) или io.emit(event, data)
+          if (
+            callee.type === 'MemberExpression' &&
+            (callee.property as Identifier).type === 'Identifier' &&
+            (callee.property as Identifier).name === 'emit'
+          ) {
+            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;
+
+            // io.to('room').emit() - room-based emit
+            let room: string | null = null;
+            if (
+              callee.object.type === 'CallExpression' &&
+              (callee.object.callee as MemberExpression).type === 'MemberExpression' &&
+              ((callee.object.callee as MemberExpression).property as Identifier).name === 'to'
+            ) {
+              room = this.extractStringArg(callee.object.arguments[0]);
+            }
+
+            // io.of('/namespace').emit() - namespace emit
+            let namespace: string | null = null;
+            if (
+              callee.object.type === 'CallExpression' &&
+              (callee.object.callee as MemberExpression).type === 'MemberExpression' &&
+              ((callee.object.callee as MemberExpression).property as Identifier).name === 'of'
+            ) {
+              namespace = this.extractStringArg(callee.object.arguments[0]);
+            }
+
+            // socket.broadcast.emit() - broadcast to all except sender
+            let broadcast = false;
+            if (
+              callee.object.type === 'MemberExpression' &&
+              ((callee.object as MemberExpression).property as Identifier).name === 'broadcast'
+            ) {
+              broadcast = true;
+            }
+
+            emits.push({
+              id: `socketio:emit#${event}#${module.file}#${line}`,
+              type: 'socketio:emit',
+              event: event,
+              room: room,
+              namespace: namespace,
+              broadcast: broadcast,
+              objectName: objectName,
+              file: module.file!,
+              line: line,
+              column: column
+            });
+          }
+
+          // Pattern: socket.on(event, handler) или io.on(event, handler)
+          if (
+            callee.type === 'MemberExpression' &&
+            (callee.property as Identifier).type === 'Identifier' &&
+            (callee.property as Identifier).name === 'on'
+          ) {
+            const objectName = this.getObjectName(callee.object);
+            const event = this.extractStringArg(node.arguments[0]);
+            const line = node.loc!.start.line;
+            const handler = node.arguments[1];
+
+            // Извлекаем имя handler функции
+            let handlerName = 'anonymous';
+            let handlerLine = line;
+            if (handler) {
+              if (
+                handler.type === 'FunctionExpression' ||
+                handler.type === 'ArrowFunctionExpression'
+              ) {
+                handlerName = `anonymous:${handler.loc!.start.line}`;
+                handlerLine = handler.loc!.start.line;
+              } else if (handler.type === 'Identifier') {
+                handlerName = (handler as Identifier).name;
+              }
+            }
+
+            listeners.push({
+              id: `socketio:on#${event}#${module.file}#${line}`,
+              type: 'socketio:on',
+              event: event,
+              objectName: objectName,
+              handlerName: handlerName,
+              handlerLine: handlerLine,
+              file: module.file!,
+              line: line
+            });
+          }
+
+          // Pattern: socket.join(room)
+          if (
+            callee.type === 'MemberExpression' &&
+            (callee.property as Identifier).type === 'Identifier' &&
+            (callee.property as Identifier).name === 'join'
+          ) {
+            const objectName = this.getObjectName(callee.object);
+            const roomName = this.extractStringArg(node.arguments[0]);
+            const line = node.loc!.start.line;
+
+            if (objectName === 'socket') {
+              rooms.push({
+                id: `socketio:room#${roomName}#${module.file}#${line}`,
+                type: 'socketio:room',
+                room: roomName,
+                objectName: objectName,
+                file: module.file!,
+                line: line
+              });
+            }
+          }
+        }
+      });
+
+      // Создаём ноды в графе
+      for (const emit of emits) {
+        await graph.addNode(emit as unknown as NodeRecord);
+
+        // Создаём ребро от модуля к event
+        await graph.addEdge({
+          type: 'CONTAINS',
+          src: module.id,
+          dst: emit.id
+        });
+      }
+
+      for (const listener of listeners) {
+        await graph.addNode(listener as unknown as NodeRecord);
+
+        // Создаём ребро от модуля к listener
+        await graph.addEdge({
+          type: 'CONTAINS',
+          src: module.id,
+          dst: listener.id
+        });
+
+        // Ищем FUNCTION node для handler и создаём ребро LISTENS_TO
+        const handlerFunctionId = `FUNCTION#${listener.handlerName}#${listener.file}#${listener.handlerLine}`;
+        const handlerFunction = await graph.getNode(handlerFunctionId);
+
+        if (handlerFunction) {
+          await graph.addEdge({
+            type: 'LISTENS_TO',
+            src: listener.id,
+            dst: handlerFunctionId
+          });
+        }
+      }
+
+      for (const room of rooms) {
+        await graph.addNode(room as unknown as NodeRecord);
+
+        // Создаём ребро от модуля к room
+        await graph.addEdge({
+          type: 'CONTAINS',
+          src: module.id,
+          dst: room.id
+        });
+      }
+
+      return {
+        emits: emits.length,
+        listeners: listeners.length,
+        rooms: rooms.length
+      };
+    } catch (error) {
+      console.error(
+        `[SocketIOAnalyzer] Error analyzing ${module.file}:`,
+        (error as Error).message
+      );
+      return { emits: 0, listeners: 0, rooms: 0 };
+    }
+  }
+
+  /**
+   * Извлекает имя объекта из MemberExpression
+   * Например: socket.emit → 'socket', io.to('room').emit → 'io'
+   */
+  private getObjectName(node: Node): string {
+    if (node.type === 'Identifier') {
+      return (node as Identifier).name;
+    } else if (node.type === 'MemberExpression') {
+      return this.getObjectName((node as MemberExpression).object);
+    } else if (node.type === 'CallExpression') {
+      return this.getObjectName((node as CallExpression).callee);
+    }
+    return 'unknown';
+  }
+
+  /**
+   * Извлекает строковое значение из аргумента
+   */
+  private extractStringArg(arg: Node | undefined): string {
+    if (!arg) return 'unknown';
+
+    if (arg.type === 'StringLiteral') {
+      return (arg as { value: string }).value;
+    } else if (arg.type === 'TemplateLiteral') {
+      const tl = arg as { quasis: Array<{ value: { raw: string } }>; expressions: unknown[] };
+      if (tl.quasis.length === 1) {
+        // Простой template literal без интерполяции
+        return tl.quasis[0].value.raw;
+      } else {
+        // Template literal с переменными - возвращаем паттерн
+        const parts = tl.quasis.map(q => q.value.raw);
+        const expressions = tl.expressions.map(() => '${...}');
+
+        let result = '';
+        for (let i = 0; i < parts.length; i++) {
+          result += parts[i];
+          if (i < expressions.length) {
+            result += expressions[i];
+          }
+        }
+        return result;
+      }
+    }
+
+    return 'dynamic';
+  }
+}

package/src/plugins/analysis/SystemDbAnalyzer.ts

@@ -0,0 +1,284 @@
+/**
+ * SystemDbAnalyzer - специализированный плагин для анализа system_db API
+ *
+ * Понимает семантику system_db и добавляет ноды для сайд-эффектов:
+ * - system_db.use(view, server) -> регистрирует VIEW через get_view()
+ * - system_db.subscribe(servers) -> проверяет все зарегистрированные VIEW'ы
+ * - local.use(view) -> регистрирует VIEW в get_hosts()
+ *
+ * Добавляет специальные ноды:
+ * - SYSTEM_DB_VIEW_REGISTRATION - регистрация VIEW'а
+ * - SYSTEM_DB_SUBSCRIPTION - подписка на сервер
+ */
+
+import { readFileSync } from 'fs';
+import { parse, ParserPlugin } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+import type { CallExpression, Identifier, MemberExpression, Node } from '@babel/types';
+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';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const traverse = (traverseModule as any).default || traverseModule;
+
+/**
+ * View registration info
+ */
+interface ViewRegistration {
+  type: 'system_db.use' | 'local.use' | 'get_view';
+  viewName: string;
+  serverName: string;
+  line: number;
+  column: number;
+}
+
+/**
+ * Subscription info
+ */
+interface Subscription {
+  type: 'system_db.subscribe';
+  servers: string[];
+  line: number;
+  column: number;
+}
+
+export class SystemDbAnalyzer extends Plugin {
+  get metadata(): PluginMetadata {
+    return {
+      name: 'SystemDbAnalyzer',
+      phase: 'ANALYSIS',
+      priority: 85, // Run after JSASTAnalyzer
+      creates: {
+        nodes: ['SYSTEM_DB_VIEW_REGISTRATION', 'SYSTEM_DB_SUBSCRIPTION'],
+        edges: ['REGISTERS_VIEW', 'CHECKS_VIEWS']
+      }
+    };
+  }
+
+  async execute(context: PluginContext): Promise<PluginResult> {
+    try {
+      const { graph } = context;
+
+      let nodesCreated = 0;
+      let edgesCreated = 0;
+
+      // Get all MODULE nodes
+      const modules = await this.getModules(graph);
+
+      console.log(
+        `[SystemDbAnalyzer] Analyzing ${modules.length} modules for system_db patterns...\n`
+      );
+
+      for (const module of modules) {
+        if (!module.file) continue;
+
+        try {
+          const code = readFileSync(module.file, 'utf-8');
+          const ast = parse(code, {
+            sourceType: 'module',
+            plugins: ['jsx', 'typescript'] as ParserPlugin[],
+            errorRecovery: true
+          });
+
+          const registrations: ViewRegistration[] = [];
+          const subscriptions: Subscription[] = [];
+
+          traverse(ast, {
+            CallExpression: (path: NodePath<CallExpression>) => {
+              const { node } = path;
+
+              // system_db.use(...)
+              if (
+                node.callee.type === 'MemberExpression' &&
+                (node.callee.object as Identifier).name === 'system_db' &&
+                (node.callee.property as Identifier).name === 'use'
+              ) {
+                const viewName = this.extractLiteral(node.arguments[0]);
+                const serverName = this.extractLiteral(node.arguments[1]);
+
+                if (viewName) {
+                  registrations.push({
+                    type: 'system_db.use',
+                    viewName,
+                    serverName: serverName || 'default',
+                    line: node.loc?.start.line || 0,
+                    column: node.loc?.start.column || 0
+                  });
+                }
+              }
+
+              // system_db.subscribe(...)
+              if (
+                node.callee.type === 'MemberExpression' &&
+                (node.callee.object as Identifier).name === 'system_db' &&
+                (node.callee.property as Identifier).name === 'subscribe'
+              ) {
+                const servers = this.extractServerList(node.arguments[0]);
+
+                subscriptions.push({
+                  type: 'system_db.subscribe',
+                  servers,
+                  line: node.loc?.start.line || 0,
+                  column: node.loc?.start.column || 0
+                });
+              }
+
+              // local.use('view_name') - косвенная регистрация через get_hosts()
+              if (
+                node.callee.type === 'MemberExpression' &&
+                (node.callee.object as Identifier).name === 'local' &&
+                (node.callee.property as Identifier).name === 'use'
+              ) {
+                const viewName = this.extractLiteral(node.arguments[0]);
+
+                if (viewName) {
+                  registrations.push({
+                    type: 'local.use',
+                    viewName,
+                    serverName: 'inferred_from_hosts',
+                    line: node.loc?.start.line || 0,
+                    column: node.loc?.start.column || 0
+                  });
+                }
+              }
+
+              // get_view(name, server) - внутренний API
+              if (
+                node.callee.type === 'Identifier' &&
+                (node.callee as Identifier).name === 'get_view'
+              ) {
+                const viewName = this.extractLiteral(node.arguments[0]);
+                const serverName = this.extractLiteral(node.arguments[1]);
+
+                if (viewName) {
+                  registrations.push({
+                    type: 'get_view',
+                    viewName,
+                    serverName: serverName || 'default',
+                    line: node.loc?.start.line || 0,
+                    column: node.loc?.start.column || 0
+                  });
+                }
+              }
+            }
+          });
+
+          // Create SYSTEM_DB_VIEW_REGISTRATION nodes
+          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}`
+            );
+
+            await graph.addNode({
+              id: nodeId,
+              type: 'SYSTEM_DB_VIEW_REGISTRATION',
+              name: `${reg.type}('${reg.viewName}', '${reg.serverName}')`,
+              file: module.file,
+              line: reg.line,
+              column: reg.column,
+              viewName: reg.viewName,
+              serverName: reg.serverName,
+              callType: reg.type
+            } as unknown as NodeRecord);
+            nodesCreated++;
+
+            // Link MODULE -> REGISTERS_VIEW -> REGISTRATION
+            await graph.addEdge({
+              type: 'REGISTERS_VIEW',
+              src: module.id,
+              dst: nodeId
+            });
+            edgesCreated++;
+          }
+
+          // Create SYSTEM_DB_SUBSCRIPTION nodes
+          for (const sub of subscriptions) {
+            const nodeId = `${module.file}:SYSTEM_DB_SUBSCRIPTION:${sub.line}`;
+
+            await graph.addNode({
+              id: nodeId,
+              type: 'SYSTEM_DB_SUBSCRIPTION',
+              name: `subscribe([${sub.servers.join(', ')}])`,
+              file: module.file,
+              line: sub.line,
+              column: sub.column,
+              servers: sub.servers
+            } as unknown as NodeRecord);
+            nodesCreated++;
+
+            // Link MODULE -> CHECKS_VIEWS -> SUBSCRIPTION
+            await graph.addEdge({
+              type: 'CHECKS_VIEWS',
+              src: module.id,
+              dst: nodeId
+            });
+            edgesCreated++;
+          }
+        } 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}`);
+          }
+        }
+      }
+
+      console.log(
+        `[SystemDbAnalyzer] Created ${nodesCreated} system_db nodes, ${edgesCreated} edges\n`
+      );
+
+      return createSuccessResult(
+        { nodes: nodesCreated, edges: edgesCreated },
+        { modulesAnalyzed: modules.length }
+      );
+    } catch (error) {
+      console.error(`[SystemDbAnalyzer] Error:`, error);
+      return createErrorResult(error as Error);
+    }
+  }
+
+  /**
+   * Extract literal value from AST node
+   */
+  private extractLiteral(node: Node | undefined): 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: { cooked: string | null } }> };
+      if (tl.quasis.length === 1) {
+        return tl.quasis[0].value.cooked;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Extract server list from subscribe() argument
+   */
+  private extractServerList(node: Node | undefined): string[] {
+    if (!node) return ['default'];
+
+    // String literal: subscribe('lum-unblocker')
+    if (node.type === 'StringLiteral') {
+      return [(node as { value: string }).value];
+    }
+
+    // Array: subscribe(['lum', 'lum-views'])
+    if (node.type === 'ArrayExpression') {
+      const arr = node as { elements: Array<Node | null> };
+      return arr.elements
+        .map(el => (el ? this.extractLiteral(el) : null))
+        .filter((s): s is string => s !== null);
+    }
+
+    return ['unknown'];
+  }
+}