@grafema/core 0.2.5-beta → 0.2.7

package/src/plugins/analysis/RustAnalyzer.ts

@@ -5,9 +5,11 @@
  */
 
 import { readFileSync } from 'fs';
+import { resolveNodeFile } from '../../utils/resolveNodeFile.js';
 import { Plugin, createSuccessResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
-import type { NodeRecord } from '@grafema/types';
+import type { NodeRecord, AnyBrandedNode } from '@grafema/types';
+import { NodeFactory } from '../../core/NodeFactory.js';
 
 /**
  * Rust function from parser
@@ -190,6 +192,7 @@ export class RustAnalyzer extends Plugin {
 
   async execute(context: PluginContext): Promise<PluginResult> {
     const { graph, onProgress } = context;
+    const projectPath = (context.manifest as { projectPath?: string })?.projectPath ?? '';
     const logger = this.log(context);
 
     // Load native binding lazily on first use
@@ -230,7 +233,7 @@ export class RustAnalyzer extends Plugin {
     for (let i = 0; i < modules.length; i++) {
       const module = modules[i];
       try {
-        const code = readFileSync(module.file!, 'utf-8');
+        const code = readFileSync(resolveNodeFile(module.file!, projectPath), 'utf-8');
         const parseResult = parseRustFile(code);
 
         const result = await this.processParseResult(parseResult, module, graph);
@@ -277,7 +280,7 @@ export class RustAnalyzer extends Plugin {
     module: NodeRecord,
     graph: PluginContext['graph']
   ): Promise<AnalysisStats> {
-    const nodes: NodeRecord[] = [];
+    const nodes: AnyBrandedNode[] = [];
     const edges: EdgeToAdd[] = [];
     let methodCount = 0;
     let callCount = 0;
@@ -289,95 +292,90 @@ export class RustAnalyzer extends Plugin {
       parentName: string
     ): void => {
       for (const call of calls || []) {
-        const callId = `RUST_CALL#${parentName}#${call.line}#${call.column}#${module.file}`;
-
-        nodes.push({
-          id: callId,
-          type: 'RUST_CALL',
-          file: module.file,
-          line: call.line,
-          column: call.column,
-          callType: call.callType, // "function" | "method" | "macro"
-          name: call.name || null,
-          receiver: call.receiver || null,
-          method: call.method || null,
-          argsCount: call.argsCount,
-          sideEffect: call.sideEffect || null // "fs:write", "panic", "io:print", etc.
-        } as unknown as NodeRecord);
-
-        edges.push({ src: parentId, dst: callId, type: 'CONTAINS' });
+        const callNode = NodeFactory.createRustCall(
+          parentName,
+          module.file!,
+          call.line,
+          call.column,
+          call.callType,
+          call.argsCount,
+          {
+            name: call.name || null,
+            receiver: call.receiver || null,
+            method: call.method || null,
+            sideEffect: call.sideEffect || null,
+          }
+        );
+
+        nodes.push(callNode);
+        edges.push({ src: parentId, dst: callNode.id, type: 'CONTAINS' });
         callCount++;
       }
     };
 
     // 1. Process top-level functions
     for (const fn of parseResult.functions) {
-      const nodeId = `RUST_FUNCTION#${fn.name}#${module.file}#${fn.line}`;
-
-      nodes.push({
-        id: nodeId,
-        type: 'RUST_FUNCTION',
-        name: fn.name,
-        file: module.file,
-        line: fn.line,
-        column: fn.column,
-        pub: fn.isPub,
-        async: fn.isAsync,
-        unsafe: fn.isUnsafe,
-        const: fn.isConst,
-        napi: fn.isNapi,
-        napiJsName: fn.napiJsName || null,
-        napiConstructor: fn.napiConstructor || false,
-        napiGetter: fn.napiGetter || null,
-        napiSetter: fn.napiSetter || null,
-        params: fn.params || [],
-        returnType: fn.returnType || null,
-        unsafeBlocks: fn.unsafeBlocks?.length || 0 // Count of unsafe blocks in body
-      } as unknown as NodeRecord);
-
-      edges.push({ src: module.id, dst: nodeId, type: 'CONTAINS' });
+      const fnNode = NodeFactory.createRustFunction(
+        fn.name,
+        module.file!,
+        fn.line,
+        fn.column,
+        {
+          pub: fn.isPub,
+          async: fn.isAsync,
+          unsafe: fn.isUnsafe,
+          const: fn.isConst,
+          napi: fn.isNapi,
+          napiJsName: fn.napiJsName || null,
+          napiConstructor: fn.napiConstructor || false,
+          napiGetter: fn.napiGetter || null,
+          napiSetter: fn.napiSetter || null,
+          params: fn.params || [],
+          returnType: fn.returnType || null,
+          unsafeBlocks: fn.unsafeBlocks?.length || 0,
+        }
+      );
+
+      nodes.push(fnNode);
+      edges.push({ src: module.id, dst: fnNode.id, type: 'CONTAINS' });
 
       // Process calls within this function
-      processCalls(fn.calls, nodeId, fn.name);
+      processCalls(fn.calls, fnNode.id, fn.name);
     }
 
     // 2. Process structs
     for (const s of parseResult.structs) {
-      const nodeId = `RUST_STRUCT#${s.name}#${module.file}#${s.line}`;
-
-      nodes.push({
-        id: nodeId,
-        type: 'RUST_STRUCT',
-        name: s.name,
-        file: module.file,
-        line: s.line,
-        pub: s.isPub,
-        napi: s.isNapi,
-        fields: s.fields || []
-      } as unknown as NodeRecord);
-
-      edges.push({ src: module.id, dst: nodeId, type: 'CONTAINS' });
+      const structNode = NodeFactory.createRustStruct(
+        s.name,
+        module.file!,
+        s.line,
+        {
+          pub: s.isPub,
+          napi: s.isNapi,
+          fields: s.fields || [],
+        }
+      );
+
+      nodes.push(structNode);
+      edges.push({ src: module.id, dst: structNode.id, type: 'CONTAINS' });
     }
 
     // 3. Process impl blocks and their methods
     for (const impl of parseResult.impls) {
-      const implId = `RUST_IMPL#${impl.targetType}${impl.traitName ? ':' + impl.traitName : ''}#${module.file}#${impl.line}`;
-
-      nodes.push({
-        id: implId,
-        type: 'RUST_IMPL',
-        name: impl.targetType,
-        traitName: impl.traitName || null,
-        file: module.file,
-        line: impl.line
-      } as unknown as NodeRecord);
+      const implNode = NodeFactory.createRustImpl(
+        impl.targetType,
+        module.file!,
+        impl.line,
+        { traitName: impl.traitName || null }
+      );
 
-      edges.push({ src: module.id, dst: implId, type: 'CONTAINS' });
+      nodes.push(implNode);
+      edges.push({ src: module.id, dst: implNode.id, type: 'CONTAINS' });
 
       // IMPLEMENTS edge if trait impl
       if (impl.traitName) {
         edges.push({
-          src: implId,
+          src: implNode.id,
           dst: `RUST_TRAIT#${impl.traitName}`,
           type: 'IMPLEMENTS'
         });
@@ -385,59 +383,57 @@ export class RustAnalyzer extends Plugin {
 
       // Process methods inside impl
       for (const method of impl.methods) {
-        const methodId = `RUST_METHOD#${method.name}#${module.file}#${method.line}`;
-
-        nodes.push({
-          id: methodId,
-          type: 'RUST_METHOD',
-          name: method.name,
-          file: module.file,
-          line: method.line,
-          column: method.column,
-          pub: method.isPub,
-          async: method.isAsync,
-          unsafe: method.isUnsafe,
-          const: method.isConst,
-          napi: method.isNapi,
-          napiJsName: method.napiJsName || null,
-          napiConstructor: method.napiConstructor || false,
-          napiGetter: method.napiGetter || null,
-          napiSetter: method.napiSetter || null,
-          params: method.params || [],
-          returnType: method.returnType || null,
-          selfType: method.selfType || null,
-          implId: implId,
-          implType: impl.targetType,
-          unsafeBlocks: method.unsafeBlocks?.length || 0 // Count of unsafe blocks in body
-        } as unknown as NodeRecord);
-
-        edges.push({ src: implId, dst: methodId, type: 'CONTAINS' });
+        const methodNode = NodeFactory.createRustMethod(
+          method.name,
+          module.file!,
+          method.line,
+          method.column,
+          implNode.id,
+          impl.targetType,
+          {
+            pub: method.isPub,
+            async: method.isAsync,
+            unsafe: method.isUnsafe,
+            const: method.isConst,
+            napi: method.isNapi,
+            napiJsName: method.napiJsName || null,
+            napiConstructor: method.napiConstructor || false,
+            napiGetter: method.napiGetter || null,
+            napiSetter: method.napiSetter || null,
+            params: method.params || [],
+            returnType: method.returnType || null,
+            selfType: method.selfType || null,
+            unsafeBlocks: method.unsafeBlocks?.length || 0,
+          }
+        );
+
+        nodes.push(methodNode);
+        edges.push({ src: implNode.id, dst: methodNode.id, type: 'CONTAINS' });
         methodCount++;
 
         // Process calls within this method
-        processCalls(method.calls, methodId, `${impl.targetType}::${method.name}`);
+        processCalls(method.calls, methodNode.id, `${impl.targetType}::${method.name}`);
       }
     }
 
     // 4. Process traits
     for (const t of parseResult.traits) {
-      const nodeId = `RUST_TRAIT#${t.name}#${module.file}#${t.line}`;
-
-      nodes.push({
-        id: nodeId,
-        type: 'RUST_TRAIT',
-        name: t.name,
-        file: module.file,
-        line: t.line,
-        pub: t.isPub,
-        methods: (t.methods || []).map(m => ({
-          name: m.name,
-          params: m.params,
-          returnType: m.returnType
-        }))
-      } as unknown as NodeRecord);
-
-      edges.push({ src: module.id, dst: nodeId, type: 'CONTAINS' });
+      const traitNode = NodeFactory.createRustTrait(
+        t.name,
+        module.file!,
+        t.line,
+        {
+          pub: t.isPub,
+          methods: (t.methods || []).map(m => ({
+            name: m.name,
+            params: m.params,
+            returnType: m.returnType,
+          })),
+        }
+      );
+
+      nodes.push(traitNode);
+      edges.push({ src: module.id, dst: traitNode.id, type: 'CONTAINS' });
     }
 
     // 5. Write all nodes and edges in batch

package/src/plugins/analysis/SQLiteAnalyzer.ts

@@ -16,8 +16,10 @@ import type { CallExpression, Identifier, MemberExpression, Node } from '@babel/
 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 type { NodeRecord, AnyBrandedNode } from '@grafema/types';
 import { getLine, getColumn } from './ast/utils/location.js';
+import { resolveNodeFile } from '../../utils/resolveNodeFile.js';
+import { NodeFactory } from '../../core/NodeFactory.js';
 
 const traverse = (traverseModule as any).default || traverseModule;
 
@@ -54,6 +56,7 @@ export class SQLiteAnalyzer extends Plugin {
     return {
       name: 'SQLiteAnalyzer',
       phase: 'ANALYSIS',
+      covers: ['sqlite3', 'better-sqlite3'],
       creates: {
         nodes: ['db:query'],
         edges: ['CONTAINS', 'EXECUTES_QUERY']
@@ -67,6 +70,7 @@ export class SQLiteAnalyzer extends Plugin {
 
     try {
       const { graph } = context;
+      const projectPath = (context.manifest as { projectPath?: string })?.projectPath ?? '';
 
       // Получаем все MODULE ноды
       const modules = await this.getModules(graph);
@@ -77,7 +81,7 @@ export class SQLiteAnalyzer extends Plugin {
 
       // Анализируем каждый модуль
       for (const module of modules) {
-        const result = await this.analyzeModule(module, graph);
+        const result = await this.analyzeModule(module, graph, projectPath);
         queriesCreated += result.queries;
         operationsCreated += result.operations;
         edgesCreated += result.edges;
@@ -97,7 +101,8 @@ export class SQLiteAnalyzer extends Plugin {
 
   private async analyzeModule(
     module: NodeRecord,
-    graph: PluginContext['graph']
+    graph: PluginContext['graph'],
+    projectPath: string
   ): Promise<AnalysisResult> {
     let queriesCreated = 0;
     let operationsCreated = 0;
@@ -105,7 +110,7 @@ export class SQLiteAnalyzer extends Plugin {
 
     try {
       // Читаем файл
-      const code = readFileSync(module.file!, 'utf-8');
+      const code = readFileSync(resolveNodeFile(module.file!, projectPath), 'utf-8');
 
       // Парсим AST
       const ast = parse(code, {
@@ -269,14 +274,23 @@ export class SQLiteAnalyzer extends Plugin {
       });
 
       // Создаём DATABASE_QUERY ноды
-      const nodes: NodeRecord[] = [];
+      const nodes: AnyBrandedNode[] = [];
       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;
-
-        nodes.push(queryData as unknown as NodeRecord);
+        nodes.push(NodeFactory.createSQLiteQuery(
+          query.file,
+          query.method.toLowerCase(),
+          query.line,
+          query.query,
+          query.operationType,
+          {
+            params: query.params,
+            tableName: query.tableName,
+            column: query.column,
+            promiseWrapped: query.promiseWrapped,
+          }
+        ));
         queriesCreated++;
 
         // MODULE -> CONTAINS -> DATABASE_QUERY

package/src/plugins/analysis/ServiceLayerAnalyzer.ts

@@ -24,8 +24,10 @@ import type {
 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 type { NodeRecord, AnyBrandedNode } from '@grafema/types';
 import { getLine } from './ast/utils/location.js';
+import { resolveNodeFile } from '../../utils/resolveNodeFile.js';
+import { NodeFactory } from '../../core/NodeFactory.js';
 
 const traverse = (traverseModule as any).default || traverseModule;
 
@@ -103,6 +105,7 @@ export class ServiceLayerAnalyzer extends Plugin {
 
     try {
       const { graph } = context;
+      const projectPath = (context.manifest as { projectPath?: string })?.projectPath ?? '';
 
       // Получаем все модули
       const modules = await this.getModules(graph);
@@ -116,7 +119,7 @@ export class ServiceLayerAnalyzer extends Plugin {
 
       for (let i = 0; i < modules.length; i++) {
         const module = modules[i];
-        const result = await this.analyzeModule(module, graph);
+        const result = await this.analyzeModule(module, graph, projectPath);
         classesCount += result.classes;
         instancesCount += result.instances;
         registrationsCount += result.registrations;
@@ -163,10 +166,11 @@ export class ServiceLayerAnalyzer extends Plugin {
 
   private async analyzeModule(
     module: NodeRecord,
-    graph: PluginContext['graph']
+    graph: PluginContext['graph'],
+    projectPath: string
   ): Promise<AnalysisResult> {
     try {
-      const code = readFileSync(module.file!, 'utf-8');
+      const code = readFileSync(resolveNodeFile(module.file!, projectPath), 'utf-8');
 
       const ast = parse(code, {
         sourceType: 'module',
@@ -304,12 +308,17 @@ export class ServiceLayerAnalyzer extends Plugin {
       });
 
       // Batch nodes and edges for IPC optimization
-      const nodes: Array<unknown> = [];
+      const nodes: AnyBrandedNode[] = [];
       const edges: Array<{ type: string; src: string; dst: string }> = [];
 
       // Collect all nodes
       for (const serviceClass of serviceClasses) {
-        nodes.push(serviceClass as unknown as NodeRecord);
+        nodes.push(NodeFactory.createServiceClass(
+          serviceClass.name,
+          serviceClass.file,
+          serviceClass.line,
+          serviceClass.methods
+        ));
         edges.push({
           type: 'CONTAINS',
           src: module.id,
@@ -318,7 +327,11 @@ export class ServiceLayerAnalyzer extends Plugin {
       }
 
       for (const instance of serviceInstances) {
-        nodes.push(instance as unknown as NodeRecord);
+        nodes.push(NodeFactory.createServiceInstance(
+          instance.serviceClass,
+          instance.file,
+          instance.line
+        ));
         edges.push({
           type: 'CONTAINS',
           src: module.id,
@@ -327,7 +340,12 @@ export class ServiceLayerAnalyzer extends Plugin {
       }
 
       for (const registration of serviceRegistrations) {
-        nodes.push(registration as unknown as NodeRecord);
+        nodes.push(NodeFactory.createServiceRegistration(
+          registration.serviceName,
+          registration.objectName,
+          registration.file,
+          registration.line
+        ));
         edges.push({
           type: 'CONTAINS',
           src: module.id,
@@ -336,7 +354,11 @@ export class ServiceLayerAnalyzer extends Plugin {
       }
 
       for (const usage of serviceUsages) {
-        nodes.push(usage as unknown as NodeRecord);
+        nodes.push(NodeFactory.createServiceUsage(
+          usage.serviceName,
+          usage.file,
+          usage.line
+        ));
         edges.push({
           type: 'CONTAINS',
           src: module.id,
@@ -345,7 +367,7 @@ export class ServiceLayerAnalyzer extends Plugin {
       }
 
       // First flush: add all nodes to graph
-      await graph.addNodes(nodes as NodeRecord[]);
+      await graph.addNodes(nodes);
 
       // Create INSTANTIATES edges (requires querying graph)
       for (const instance of serviceInstances) {