@grafema/core 0.1.0-alpha.1

package/src/index.ts

@@ -0,0 +1,93 @@
+/**
+ * @grafema/core - Core analysis engine for GraphDD
+ */
+
+// Main orchestrator
+export { Orchestrator } from './Orchestrator.js';
+export type {
+  OrchestratorOptions,
+  ProgressCallback,
+  ProgressInfo,
+  ParallelConfig,
+  ServiceInfo,
+  EntrypointInfo,
+  DiscoveryManifest,
+  IndexingUnit,
+} from './Orchestrator.js';
+
+// Plugin base
+export { Plugin } from './plugins/Plugin.js';
+export type { PluginContext } from './plugins/Plugin.js';
+
+// Graph backend
+export { GraphBackend, typeToKind, edgeTypeToNumber } from './core/GraphBackend.js';
+export type { Node, Edge, EdgeType, AttrQuery, GraphStats, GraphExport } from './core/GraphBackend.js';
+
+// RFDB
+export { RFDBClient } from '@grafema/rfdb-client';
+export { RFDBServerBackend } from './storage/backends/RFDBServerBackend.js';
+
+// Core utilities
+export { NodeFactory } from './core/NodeFactory.js';
+export { Profiler } from './core/Profiler.js';
+export { AnalysisQueue } from './core/AnalysisQueue.js';
+export { GuaranteeManager } from './core/GuaranteeManager.js';
+export type { GuaranteeGraph } from './core/GuaranteeManager.js';
+
+// API
+export { GraphAPI } from './api/GraphAPI.js';
+export { GuaranteeAPI } from './api/GuaranteeAPI.js';
+export type { GuaranteeGraphBackend } from './api/GuaranteeAPI.js';
+
+// Node kinds
+export { isGuaranteeType } from './core/nodes/NodeKind.js';
+
+// === PLUGINS ===
+
+// Indexing plugins
+export { JSModuleIndexer } from './plugins/indexing/JSModuleIndexer.js';
+export { IncrementalModuleIndexer } from './plugins/indexing/IncrementalModuleIndexer.js';
+export { RustModuleIndexer } from './plugins/indexing/RustModuleIndexer.js';
+export { ServiceDetector } from './plugins/indexing/ServiceDetector.js';
+
+// Analysis plugins
+export { JSASTAnalyzer } from './plugins/analysis/JSASTAnalyzer.js';
+export { ExpressRouteAnalyzer } from './plugins/analysis/ExpressRouteAnalyzer.js';
+export { ExpressAnalyzer } from './plugins/analysis/ExpressAnalyzer.js';
+export { SocketIOAnalyzer } from './plugins/analysis/SocketIOAnalyzer.js';
+export { DatabaseAnalyzer } from './plugins/analysis/DatabaseAnalyzer.js';
+export { FetchAnalyzer } from './plugins/analysis/FetchAnalyzer.js';
+export { ServiceLayerAnalyzer } from './plugins/analysis/ServiceLayerAnalyzer.js';
+export { ReactAnalyzer } from './plugins/analysis/ReactAnalyzer.js';
+export { RustAnalyzer } from './plugins/analysis/RustAnalyzer.js';
+export { SQLiteAnalyzer } from './plugins/analysis/SQLiteAnalyzer.js';
+export { SystemDbAnalyzer } from './plugins/analysis/SystemDbAnalyzer.js';
+export { IncrementalAnalysisPlugin } from './plugins/analysis/IncrementalAnalysisPlugin.js';
+
+// Enrichment plugins
+export { MethodCallResolver } from './plugins/enrichment/MethodCallResolver.js';
+export { AliasTracker } from './plugins/enrichment/AliasTracker.js';
+export { ValueDomainAnalyzer } from './plugins/enrichment/ValueDomainAnalyzer.js';
+export { MountPointResolver } from './plugins/enrichment/MountPointResolver.js';
+export { PrefixEvaluator } from './plugins/enrichment/PrefixEvaluator.js';
+export { InstanceOfResolver } from './plugins/enrichment/InstanceOfResolver.js';
+export { HTTPConnectionEnricher } from './plugins/enrichment/HTTPConnectionEnricher.js';
+export { ImportExportLinker } from './plugins/enrichment/ImportExportLinker.js';
+export { RustFFIEnricher } from './plugins/enrichment/RustFFIEnricher.js';
+
+// Validation plugins
+export { CallResolverValidator } from './plugins/validation/CallResolverValidator.js';
+export { EvalBanValidator } from './plugins/validation/EvalBanValidator.js';
+export { SQLInjectionValidator } from './plugins/validation/SQLInjectionValidator.js';
+export { ShadowingDetector } from './plugins/validation/ShadowingDetector.js';
+export { GraphConnectivityValidator } from './plugins/validation/GraphConnectivityValidator.js';
+export { DataFlowValidator } from './plugins/validation/DataFlowValidator.js';
+export { TypeScriptDeadCodeValidator } from './plugins/validation/TypeScriptDeadCodeValidator.js';
+
+// Discovery plugins
+export { SimpleProjectDiscovery } from './plugins/discovery/SimpleProjectDiscovery.js';
+export { DiscoveryPlugin } from './plugins/discovery/DiscoveryPlugin.js';
+export { MonorepoServiceDiscovery } from './plugins/discovery/MonorepoServiceDiscovery.js';
+
+// Re-export types for convenience
+export type * from '@grafema/types';

package/src/plugins/Plugin.ts

@@ -0,0 +1,74 @@
+/**
+ * Base Plugin class
+ *
+ * PLUGIN CONTRACT:
+ *
+ * 1. Metadata - plugin description
+ * 2. Execute - plugin logic execution
+ * 3. Return value - PluginResult
+ */
+
+import type {
+  PluginMetadata,
+  PluginContext,
+  PluginResult,
+  IPlugin,
+  NodeFilter,
+} from '@grafema/types';
+import type { NodeRecord } from '@grafema/types';
+
+// Re-export types for convenience
+export type { PluginMetadata, PluginContext, PluginResult, IPlugin };
+
+// Re-export helper functions from types/plugins.js
+export { createSuccessResult, createErrorResult } from '@grafema/types';
+
+/**
+ * Base Plugin class - extend this for all plugins
+ */
+export abstract class Plugin implements IPlugin {
+  config: Record<string, unknown>;
+
+  constructor(config: Record<string, unknown> = {}) {
+    this.config = config;
+  }
+
+  /**
+   * Plugin metadata
+   */
+  abstract get metadata(): PluginMetadata;
+
+  /**
+   * Initialize plugin (optional)
+   * Called once before first execute
+   */
+  async initialize(_context: PluginContext): Promise<void> {
+    // Optionally override
+  }
+
+  /**
+   * Execute plugin
+   */
+  abstract execute(context: PluginContext): Promise<PluginResult>;
+
+  /**
+   * Cleanup resources (optional)
+   * Called after phase completion
+   */
+  async cleanup(): Promise<void> {
+    // Optionally override
+  }
+
+  /**
+   * Helper: Get all MODULE nodes from graph
+   * Works with RFDBServerBackend
+   */
+  async getModules(graph: PluginContext['graph']): Promise<NodeRecord[]> {
+    const modules: NodeRecord[] = [];
+    const filter: NodeFilter = { type: 'MODULE' };
+    for await (const node of graph.queryNodes(filter)) {
+      modules.push(node);
+    }
+    return modules;
+  }
+}

package/src/plugins/analysis/DatabaseAnalyzer.ts

@@ -0,0 +1,322 @@
+/**
+ * DatabaseAnalyzer - анализ database access patterns
+ * Детектирует db.query(), connection.query() и другие SQL вызовы
+ */
+
+import { readFileSync } from 'fs';
+import { parse, ParserPlugin } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+import type { CallExpression, Identifier } 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;
+
+/**
+ * Database query node
+ */
+interface DatabaseQueryNode {
+  id: string;
+  type: 'db:query';
+  sql: string;
+  sqlSnippet: string;
+  operation: string;
+  tableName: string | null;
+  object: string;
+  method: string;
+  file: string;
+  line: number;
+}
+
+/**
+ * Analysis result
+ */
+interface AnalysisResult {
+  queries: number;
+  tables: number;
+  edges: number;
+}
+
+export class DatabaseAnalyzer extends Plugin {
+  get metadata(): PluginMetadata {
+    return {
+      name: 'DatabaseAnalyzer',
+      phase: 'ANALYSIS',
+      priority: 75, // После JSASTAnalyzer (80)
+      creates: {
+        nodes: ['db:query', 'db:table', 'db:connection'],
+        edges: ['MAKES_QUERY', 'TARGETS', 'READS_FROM', 'WRITES_TO']
+      },
+      dependencies: ['JSASTAnalyzer'] // Требует MODULE и FUNCTION ноды
+    };
+  }
+
+  async execute(context: PluginContext): Promise<PluginResult> {
+    try {
+      const { graph } = context;
+
+      // Получаем все MODULE ноды
+      const modules = await this.getModules(graph);
+      console.log(`[DatabaseAnalyzer] Processing ${modules.length} modules...`);
+
+      // Получаем все FUNCTION ноды для связывания
+      const functions = await this.getFunctions(graph);
+
+      let queriesCreated = 0;
+      let tablesCreated = 0;
+      let edgesCreated = 0;
+      const startTime = Date.now();
+
+      // Анализируем каждый модуль
+      for (let i = 0; i < modules.length; i++) {
+        const module = modules[i];
+        const result = await this.analyzeModule(module, functions, graph);
+        queriesCreated += result.queries;
+        tablesCreated += result.tables;
+        edgesCreated += result.edges;
+
+        // 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(
+            `[DatabaseAnalyzer] Progress: ${i + 1}/${modules.length} (${elapsed}s, avg ${avgTime}ms/module)`
+          );
+        }
+      }
+
+      console.log(`[DatabaseAnalyzer] Created ${queriesCreated} queries, ${tablesCreated} tables`);
+
+      return createSuccessResult(
+        {
+          nodes: queriesCreated + tablesCreated,
+          edges: edgesCreated
+        },
+        {
+          queriesCreated,
+          tablesCreated
+        }
+      );
+    } catch (error) {
+      console.error(`[DatabaseAnalyzer] Error:`, error);
+      return createErrorResult(error as Error);
+    }
+  }
+
+  /**
+   * Получить все FUNCTION ноды из графа
+   */
+  private async getFunctions(graph: PluginContext['graph']): Promise<NodeRecord[]> {
+    const functions: NodeRecord[] = [];
+    for await (const node of graph.queryNodes({ type: 'FUNCTION' })) {
+      functions.push(node);
+    }
+    return functions;
+  }
+
+  /**
+   * Анализировать один модуль на database patterns
+   */
+  private async analyzeModule(
+    module: NodeRecord,
+    functions: NodeRecord[],
+    graph: PluginContext['graph']
+  ): Promise<AnalysisResult> {
+    let queriesCreated = 0;
+    let tablesCreated = 0;
+    let edgesCreated = 0;
+
+    try {
+      // Читаем и парсим файл
+      const code = readFileSync(module.file!, 'utf-8');
+      const ast = parse(code, {
+        sourceType: 'module',
+        plugins: ['jsx'] as ParserPlugin[]
+      });
+
+      const databaseQueries: DatabaseQueryNode[] = [];
+      const createdTables = new Set<string>();
+      let queryCounter = 0;
+
+      // Ищем db.query() паттерны
+      traverse(ast, {
+        CallExpression: (path: NodePath<CallExpression>) => {
+          const node = path.node;
+
+          // Проверяем что это MemberExpression: db.query(), connection.execute()
+          if (node.callee.type === 'MemberExpression') {
+            const methodName = (node.callee.property as Identifier).name;
+            const objectName = (node.callee.object as Identifier).name;
+
+            // Детектируем database queries
+            const isDatabaseQuery =
+              (methodName === 'query' || methodName === 'execute') &&
+              (objectName === 'db' || objectName === 'connection' || objectName === 'pool') &&
+              node.arguments.length >= 1;
+
+            if (isDatabaseQuery) {
+              const sqlArg = node.arguments[0];
+              let sql: string | null = null;
+              let operation = 'UNKNOWN';
+
+              // Извлекаем SQL строку
+              if (sqlArg.type === 'StringLiteral') {
+                sql = sqlArg.value;
+              } else if (sqlArg.type === 'TemplateLiteral') {
+                // Template literal - собираем строку с placeholders
+                sql = sqlArg.quasis.map(q => q.value.raw).join('${...}');
+              }
+
+              // Определяем тип операции и таблицу из SQL
+              if (sql) {
+                const sqlUpper = sql.trim().toUpperCase();
+                let tableName: string | null = null;
+
+                if (sqlUpper.startsWith('SELECT')) {
+                  operation = 'SELECT';
+                  const fromMatch = sqlUpper.match(/FROM\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                  if (fromMatch) tableName = fromMatch[1].toLowerCase();
+                } else if (sqlUpper.startsWith('INSERT')) {
+                  operation = 'INSERT';
+                  const intoMatch = sqlUpper.match(/INTO\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                  if (intoMatch) tableName = intoMatch[1].toLowerCase();
+                } else if (sqlUpper.startsWith('UPDATE')) {
+                  operation = 'UPDATE';
+                  const updateMatch = sqlUpper.match(/UPDATE\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                  if (updateMatch) tableName = updateMatch[1].toLowerCase();
+                } else if (sqlUpper.startsWith('DELETE')) {
+                  operation = 'DELETE';
+                  const deleteMatch = sqlUpper.match(/FROM\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                  if (deleteMatch) tableName = deleteMatch[1].toLowerCase();
+                } else if (sqlUpper.startsWith('CREATE')) {
+                  operation = 'CREATE';
+                  const createMatch = sqlUpper.match(/TABLE\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                  if (createMatch) tableName = createMatch[1].toLowerCase();
+                } else if (sqlUpper.startsWith('DROP')) {
+                  operation = 'DROP';
+                  const dropMatch = sqlUpper.match(/TABLE\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                  if (dropMatch) tableName = dropMatch[1].toLowerCase();
+                } else if (sqlUpper.startsWith('ALTER')) {
+                  operation = 'ALTER';
+                  const alterMatch = sqlUpper.match(/TABLE\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                  if (alterMatch) tableName = alterMatch[1].toLowerCase();
+                }
+
+                const queryId = queryCounter++;
+                const sqlSnippet = sql.length > 50 ? sql.substring(0, 50) + '...' : sql;
+
+                databaseQueries.push({
+                  id: `${module.file}:DATABASE_QUERY:${queryId}`,
+                  type: 'db:query',
+                  sql: sql,
+                  sqlSnippet: sqlSnippet,
+                  operation: operation,
+                  tableName: tableName,
+                  object: objectName,
+                  method: methodName,
+                  file: module.file!,
+                  line: node.loc!.start.line
+                });
+              }
+            }
+          }
+        }
+      });
+
+      // Создаём EXTERNAL_DATABASE ноду если есть хотя бы один query
+      if (databaseQueries.length > 0) {
+        const databaseId = 'EXTERNAL_DATABASE:__database__';
+
+        const existingDb = await graph.getNode(databaseId);
+        if (!existingDb) {
+          await graph.addNode({
+            id: databaseId,
+            type: 'db:connection',
+            name: '__database__'
+          } as NodeRecord);
+        }
+
+        // Создаём DATABASE_QUERY ноды
+        for (const query of databaseQueries) {
+          await graph.addNode(query as unknown as NodeRecord);
+          queriesCreated++;
+
+          // Создаём TABLE ноду если есть tableName
+          if (query.tableName) {
+            const tableId = `TABLE:${query.tableName}`;
+
+            if (!createdTables.has(tableId)) {
+              await graph.addNode({
+                id: tableId,
+                type: 'db:table',
+                name: query.tableName
+              } as NodeRecord);
+              tablesCreated++;
+              createdTables.add(tableId);
+            }
+
+            // DATABASE_QUERY -> TARGETS -> TABLE
+            await graph.addEdge({
+              type: 'TARGETS',
+              src: query.id,
+              dst: tableId
+            });
+            edgesCreated++;
+          }
+
+          // DATABASE_QUERY -> (READS_FROM | WRITES_TO) -> __database__
+          const isReadOperation = query.operation === 'SELECT';
+          const edgeType = isReadOperation ? 'READS_FROM' : 'WRITES_TO';
+
+          await graph.addEdge({
+            type: edgeType,
+            src: query.id,
+            dst: databaseId
+          });
+          edgesCreated++;
+
+          // Находим родительскую функцию для MAKES_QUERY ребра
+          const parentFunction = this.findParentFunction(query, functions);
+
+          if (parentFunction) {
+            await graph.addEdge({
+              type: 'MAKES_QUERY',
+              src: parentFunction.id,
+              dst: query.id
+            });
+            edgesCreated++;
+          }
+        }
+      }
+    } catch (error) {
+      console.error(`[DatabaseAnalyzer] Error analyzing ${module.file}:`, (error as Error).message);
+    }
+
+    return {
+      queries: queriesCreated,
+      tables: tablesCreated,
+      edges: edgesCreated
+    };
+  }
+
+  /**
+   * Найти родительскую функцию для database query
+   */
+  private findParentFunction(query: DatabaseQueryNode, functions: NodeRecord[]): NodeRecord | null {
+    // Ищем функцию в том же файле, которая содержит эту строку
+    const candidates = functions.filter(
+      f => f.file === query.file && (f.line ?? 0) < query.line // Функция должна начинаться раньше query
+    );
+
+    // Берём ближайшую (с максимальным line number меньше query.line)
+    if (candidates.length > 0) {
+      candidates.sort((a, b) => (b.line ?? 0) - (a.line ?? 0));
+      return candidates[0];
+    }
+
+    return null;
+  }
+}