@grafema/core 0.2.5-beta → 0.2.7

package/src/plugins/analysis/ExpressAnalyzer.ts

@@ -13,18 +13,18 @@ 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 { NetworkRequestNode } from '../../core/nodes/NetworkRequestNode.js';
+import type { AnyBrandedNode } from '@grafema/types';
+import { NodeFactory } from '../../core/NodeFactory.js';
 import { getLine, getColumn } from './ast/utils/location.js';
 import { getTraverseFunction } from './ast/utils/babelTraverse.js';
+import { resolveNodeFile } from '../../utils/resolveNodeFile.js';
 
 const traverse = getTraverseFunction(traverseModule);
 
 /**
- * Endpoint node
+ * Collected endpoint info (before creating branded nodes)
  */
-interface EndpointNode {
-  id: string;
-  type: 'http:route';
+interface EndpointInfo {
   method: string;
   path: string;
   localPath: string;
@@ -35,11 +35,9 @@ interface EndpointNode {
 }
 
 /**
- * Mount point node
+ * Collected mount point info (before creating branded nodes)
  */
-interface MountPointNode {
-  id: string;
-  type: 'express:mount';
+interface MountPointInfo {
   prefix: string;
   targetFunction: string | null;
   targetVariable: string | null;
@@ -85,14 +83,15 @@ export class ExpressAnalyzer extends Plugin {
 
     try {
       const { graph } = context;
+      const projectPath = (context.manifest as { projectPath?: string })?.projectPath ?? '';
 
       // Batch arrays
-      const nodes: NodeRecord[] = [];
+      const nodes: AnyBrandedNode[] = [];
       const edges: Array<{type: string; src: string; dst: string; [key: string]: unknown}> = [];
 
       // Create net:request singleton (GraphBackend handles deduplication)
-      const networkNode = NetworkRequestNode.create();
-      nodes.push(networkNode as unknown as NodeRecord);
+      const networkNode = NodeFactory.createNetworkRequest();
+      nodes.push(networkNode);
 
       // Получаем все MODULE ноды
       const modules = await this.getModules(graph);
@@ -103,7 +102,7 @@ export class ExpressAnalyzer extends Plugin {
 
       // Анализируем каждый модуль
       for (const module of modules) {
-        const result = await this.analyzeModule(module, graph, networkNode.id, nodes, edges);
+        const result = await this.analyzeModule(module, graph, projectPath, networkNode.id, nodes, edges);
         endpointsCreated += result.endpoints;
         mountPointsCreated += result.mountPoints;
         edgesCreated += result.edges;
@@ -138,8 +137,9 @@ export class ExpressAnalyzer extends Plugin {
   private async analyzeModule(
     module: NodeRecord,
     graph: PluginContext['graph'],
+    projectPath: string,
     networkId: string,
-    nodes: NodeRecord[],
+    nodes: AnyBrandedNode[],
     edges: Array<{type: string; src: string; dst: string; [key: string]: unknown}>
   ): Promise<AnalysisResult> {
     let endpointsCreated = 0;
@@ -148,14 +148,14 @@ export class ExpressAnalyzer extends Plugin {
 
     try {
       // Читаем и парсим файл
-      const code = readFileSync(module.file!, 'utf-8');
+      const code = readFileSync(resolveNodeFile(module.file!, projectPath), 'utf-8');
       const ast = parse(code, {
         sourceType: 'module',
         plugins: ['jsx'] as ParserPlugin[]
       });
 
-      const endpoints: EndpointNode[] = [];
-      const mountPoints: MountPointNode[] = [];
+      const endpoints: EndpointInfo[] = [];
+      const mountPoints: MountPointInfo[] = [];
       const imports: ImportInfo[] = [];
 
       // Собираем импорты для резолвинга mount points
@@ -216,8 +216,6 @@ export class ExpressAnalyzer extends Plugin {
               if (routePath) {
                 const method = methodName.toUpperCase();
                 endpoints.push({
-                  id: `http:route#${method}:${routePath}#${module.file}#${getLine(node)}`,
-                  type: 'http:route',
                   method: method,
                   path: routePath,
                   localPath: routePath,
@@ -294,8 +292,6 @@ export class ExpressAnalyzer extends Plugin {
               // Создаём mount point
               if ((targetFunction || targetVariable) && prefix) {
                 mountPoints.push({
-                  id: `express:mount#${prefix}#${module.file}#${getLine(node)}`,
-                  type: 'express:mount',
                   prefix: prefix,
                   targetFunction: targetFunction,
                   targetVariable: targetVariable,
@@ -312,21 +308,32 @@ export class ExpressAnalyzer extends Plugin {
 
       // Создаём ENDPOINT ноды
       for (const endpoint of endpoints) {
-        nodes.push(endpoint as unknown as NodeRecord);
+        const brandedNode = NodeFactory.createHttpRoute(
+          endpoint.method,
+          endpoint.path,
+          endpoint.file,
+          endpoint.line,
+          {
+            column: endpoint.column,
+            localPath: endpoint.localPath,
+            mountedOn: endpoint.mountedOn,
+          }
+        );
+        nodes.push(brandedNode);
         endpointsCreated++;
 
         // MODULE --EXPOSES--> ENDPOINT
         edges.push({
           type: 'EXPOSES',
           src: module.id,
-          dst: endpoint.id
+          dst: brandedNode.id
         });
         edgesCreated++;
 
         // ENDPOINT --INTERACTS_WITH--> EXTERNAL_NETWORK
         edges.push({
           type: 'INTERACTS_WITH',
-          src: endpoint.id,
+          src: brandedNode.id,
           dst: networkId
         });
         edgesCreated++;
@@ -334,19 +341,30 @@ export class ExpressAnalyzer extends Plugin {
 
       // Создаём MOUNT_POINT ноды
       for (const mountPoint of mountPoints) {
-        nodes.push(mountPoint as unknown as NodeRecord);
+        const brandedNode = NodeFactory.createExpressMount(
+          mountPoint.prefix,
+          mountPoint.file,
+          mountPoint.line,
+          mountPoint.column,
+          {
+            targetFunction: mountPoint.targetFunction,
+            targetVariable: mountPoint.targetVariable,
+            mountedOn: mountPoint.mountedOn,
+          }
+        );
+        nodes.push(brandedNode);
         mountPointsCreated++;
 
         // MODULE --DEFINES--> MOUNT_POINT
         edges.push({
           type: 'DEFINES',
           src: module.id,
-          dst: mountPoint.id
+          dst: brandedNode.id
         });
         edgesCreated++;
 
         // Создаём MOUNTS рёбра
-        const mountEdges = await this.createMountEdges(mountPoint, module, imports, graph, edges);
+        const mountEdges = await this.createMountEdges(brandedNode.id, mountPoint, module, imports, graph, projectPath, edges);
         edgesCreated += mountEdges;
       }
     } catch {
@@ -364,10 +382,12 @@ export class ExpressAnalyzer extends Plugin {
    * Создать MOUNTS рёбра для mount point
    */
   private async createMountEdges(
-    mountPoint: MountPointNode,
+    mountNodeId: string,
+    mountPoint: MountPointInfo,
     module: NodeRecord,
     imports: ImportInfo[],
     graph: PluginContext['graph'],
+    projectPath: string,
     edges: Array<{type: string; src: string; dst: string; [key: string]: unknown}>
   ): Promise<number> {
     let edgesCreated = 0;
@@ -388,7 +408,7 @@ export class ExpressAnalyzer extends Plugin {
 
         if (hasTarget) {
           // Резолвим путь к модулю
-          const currentDir = dirname(module.file!);
+          const currentDir = dirname(resolveNodeFile(module.file!, projectPath));
           targetModulePath = resolve(currentDir, imp.source);
           break;
         }
@@ -397,14 +417,7 @@ export class ExpressAnalyzer extends Plugin {
 
     // Если нашли целевой модуль, создаем MOUNTS ребро
     if (targetModulePath) {
-      // Derive project root from module's absolute and relative paths
-      // module.file is absolute path, module.name is relative path
-      const moduleAbsPath = module.file!;
-      const moduleRelPath = module.name!;
-      // projectRoot = absolute path minus relative path suffix
-      const projectRoot = moduleAbsPath.endsWith(moduleRelPath)
-        ? moduleAbsPath.slice(0, moduleAbsPath.length - moduleRelPath.length)
-        : dirname(moduleAbsPath); // fallback
+      const projectRoot = projectPath;
 
       // Convert target absolute path to relative path for semantic ID
       const targetRelativePath = relative(projectRoot, targetModulePath);
@@ -415,7 +428,7 @@ export class ExpressAnalyzer extends Plugin {
       if (targetModule) {
         edges.push({
           type: 'MOUNTS',
-          src: mountPoint.id,
+          src: mountNodeId,
           dst: targetModuleId
         });
         edgesCreated++;

package/src/plugins/analysis/ExpressResponseAnalyzer.ts

@@ -20,9 +20,10 @@ import type { CallExpression, Identifier, MemberExpression, Node, ArrowFunctionE
 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 { NodeFactory } from '../../core/NodeFactory.js';
 import { getLine } from './ast/utils/location.js';
+import { resolveNodeFile } from '../../utils/resolveNodeFile.js';
 
 const traverse = (traverseModule as any).default || traverseModule;
 
@@ -60,6 +61,7 @@ export class ExpressResponseAnalyzer extends Plugin {
 
     try {
       const { graph } = context;
+      const projectPath = (context.manifest as { projectPath?: string })?.projectPath ?? '';
 
       // Get all http:route nodes
       const routes: NodeRecord[] = [];
@@ -71,11 +73,11 @@ export class ExpressResponseAnalyzer extends Plugin {
 
       let edgesCreated = 0;
       let nodesCreated = 0;
-      const allNodes: NodeRecord[] = [];
+      const allNodes: AnyBrandedNode[] = [];
       const allEdges: Array<{ type: string; src: string; dst: string; metadata?: unknown }> = [];
 
       for (const route of routes) {
-        const result = await this.analyzeRouteResponses(route, graph, allNodes, allEdges);
+        const result = await this.analyzeRouteResponses(route, graph, projectPath, allNodes, allEdges);
         edgesCreated += result.edges;
         nodesCreated += result.nodes;
       }
@@ -103,7 +105,8 @@ export class ExpressResponseAnalyzer extends Plugin {
   private async analyzeRouteResponses(
     route: NodeRecord,
     graph: PluginContext['graph'],
-    nodes: NodeRecord[],
+    projectPath: string,
+    nodes: AnyBrandedNode[],
     edges: Array<{ type: string; src: string; dst: string; metadata?: unknown }>
   ): Promise<{ nodes: number; edges: number }> {
     let edgesCreated = 0;
@@ -126,7 +129,7 @@ export class ExpressResponseAnalyzer extends Plugin {
       }
 
       // Parse the file and find response calls in handler
-      const code = readFileSync(handlerNode.file, 'utf-8');
+      const code = readFileSync(resolveNodeFile(handlerNode.file, projectPath), 'utf-8');
       const ast = parse(code, {
         sourceType: 'module',
         plugins: ['jsx', 'typescript'] as ParserPlugin[]
@@ -351,7 +354,7 @@ export class ExpressResponseAnalyzer extends Plugin {
     call: ResponseCallInfo,
     routeId: string,
     handlerSemanticId: string,
-    nodes: NodeRecord[]
+    nodes: AnyBrandedNode[]
   ): Promise<{ nodeId: string; nodesCreated: number }> {
     const { argLine, argColumn, argType, identifierName } = call;
 
@@ -576,7 +579,7 @@ export class ExpressResponseAnalyzer extends Plugin {
     column: number,
     astType: string,
     _routeId: string,
-    nodes: NodeRecord[]
+    nodes: AnyBrandedNode[]
   ): string {
     const counter = this.responseNodeCounter++;
 
@@ -586,33 +589,33 @@ export class ExpressResponseAnalyzer extends Plugin {
         const node = NodeFactory.createObjectLiteral(file, line, column, {
           argIndex: counter
         });
-        nodes.push(node as NodeRecord);
+        nodes.push(node);
         return node.id;
       }
       case 'Identifier': {
         const node = NodeFactory.createVariableDeclaration('<response>', file, line, column, {
           counter
         });
-        nodes.push(node as NodeRecord);
+        nodes.push(node);
         return node.id;
       }
       case 'CallExpression': {
         const node = NodeFactory.createCallSite('<response>', file, line, column, {
           counter
         });
-        nodes.push(node as NodeRecord);
+        nodes.push(node);
         return node.id;
       }
       case 'ArrayExpression': {
         const node = NodeFactory.createArrayLiteral(file, line, column, {
           argIndex: counter
         });
-        nodes.push(node as NodeRecord);
+        nodes.push(node);
         return node.id;
       }
       default: {
         const node = NodeFactory.createExpression(astType, file, line, column);
-        nodes.push(node as NodeRecord);
+        nodes.push(node);
         return node.id;
       }
     }

package/src/plugins/analysis/ExpressRouteAnalyzer.ts

@@ -17,34 +17,31 @@ 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 { AnyBrandedNode } from '@grafema/types';
+import { NodeFactory } from '../../core/NodeFactory.js';
 import { getLine, getColumn } from './ast/utils/location.js';
+import { resolveNodeFile } from '../../utils/resolveNodeFile.js';
 
 const traverse = (traverseModule as any).default || traverseModule;
 
 /**
- * Endpoint node
+ * Collected endpoint info (before creating branded nodes)
  */
-interface EndpointNode {
-  id: string;
-  type: 'http:route';
+interface EndpointInfo {
   method: string;
   path: string;
   file: string;
   line: number;
   column: number;
   routerName: string;
-  handlerLine: number;
-  handlerColumn: number;
   handlerStart?: number;  // Byte offset for inline handlers
   handlerName?: string;   // Function name for named handler references
 }
 
 /**
- * Middleware node
+ * Collected middleware info (before creating branded nodes)
  */
-interface MiddlewareNode {
-  id: string;
-  type: 'express:middleware';
+interface MiddlewareInfo {
   name: string;
   file: string;
   line: number;
@@ -84,6 +81,7 @@ export class ExpressRouteAnalyzer extends Plugin {
 
     try {
       const { graph } = context;
+      const projectPath = (context.manifest as { projectPath?: string })?.projectPath ?? '';
 
       // Получаем все MODULE ноды
       const modules = await this.getModules(graph);
@@ -97,7 +95,7 @@ export class ExpressRouteAnalyzer 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);
         endpointsCreated += result.endpoints;
         middlewareCreated += result.middleware;
         edgesCreated += result.edges;
@@ -132,7 +130,8 @@ export class ExpressRouteAnalyzer extends Plugin {
 
   private async analyzeModule(
     module: NodeRecord,
-    graph: PluginContext['graph']
+    graph: PluginContext['graph'],
+    projectPath: string
   ): Promise<AnalysisResult> {
     let endpointsCreated = 0;
     let middlewareCreated = 0;
@@ -140,7 +139,7 @@ export class ExpressRouteAnalyzer extends Plugin {
 
     try {
       // Читаем файл
-      const code = readFileSync(module.file!, 'utf-8');
+      const code = readFileSync(resolveNodeFile(module.file!, projectPath), 'utf-8');
 
       // Парсим AST
       const ast = parse(code, {
@@ -148,8 +147,8 @@ export class ExpressRouteAnalyzer extends Plugin {
         plugins: ['jsx', 'typescript'] as ParserPlugin[]
       });
 
-      const endpoints: EndpointNode[] = [];
-      const middlewares: MiddlewareNode[] = [];
+      const endpoints: EndpointInfo[] = [];
+      const middlewares: MiddlewareInfo[] = [];
 
       // Находим все переменные созданные от express() или express.Router()
       const expressVars = new Set(['app', 'router']);
@@ -250,9 +249,6 @@ export class ExpressRouteAnalyzer extends Plugin {
                   // Все предыдущие - middleware
                   const middlewareHandlers = handlers.slice(0, -1);
 
-                  // Создаём http:route
-                  const endpointId = `http:route#${method.toUpperCase()}:${routePath}#${module.file}#${getLine(node)}`;
-
                   // Determine handler identification for HANDLED_BY linking:
                   // - Inline functions (arrow/function expressions): use byte offset (start)
                   // - Named references (Identifier): use function name
@@ -266,24 +262,19 @@ export class ExpressRouteAnalyzer extends Plugin {
                   }
 
                   endpoints.push({
-                    id: endpointId,
-                    type: 'http:route',
                     method: method.toUpperCase(),
                     path: routePath,
                     file: module.file!,
                     line: getLine(node),
                     column: getColumn(node),
                     routerName: objectName,
-                    handlerLine: actualHandler.loc
-                      ? getLine(actualHandler)
-                      : getLine(node),
-                    handlerColumn: actualHandler.loc
-                      ? getColumn(actualHandler)
-                      : getColumn(node),
                     handlerStart,
                     handlerName
                   });
 
+                  // Compute endpoint ID (matches factory output) for middleware linking
+                  const endpointId = `http:route#${method.toUpperCase()}:${routePath}#${module.file}#${getLine(node)}`;
+
                   // Обрабатываем middleware
                   middlewareHandlers.forEach((mw, index) => {
                     let middlewareName: string | null = null;
@@ -306,11 +297,7 @@ export class ExpressRouteAnalyzer extends Plugin {
                     }
 
                     if (middlewareName) {
-                      const middlewareId = `express:middleware#${middlewareName}#${module.file}#${getLine(mwNode)}`;
-
                       middlewares.push({
-                        id: middlewareId,
-                        type: 'express:middleware',
                         name: middlewareName,
                         file: module.file!,
                         line: mwNode.loc ? getLine(mwNode) : getLine(node),
@@ -351,11 +338,7 @@ export class ExpressRouteAnalyzer extends Plugin {
                   }
 
                   if (middlewareName) {
-                    const middlewareId = `express:middleware#${middlewareName}#${module.file}#${getLine(node)}`;
-
                     middlewares.push({
-                      id: middlewareId,
-                      type: 'express:middleware',
                       name: middlewareName,
                       file: module.file!,
                       line: getLine(node),
@@ -372,30 +355,35 @@ export class ExpressRouteAnalyzer extends Plugin {
       });
 
       // Collect all nodes and edges for batch operations
-      const nodes: NodeRecord[] = [];
+      const nodes: AnyBrandedNode[] = [];
       const edges: Array<{ type: string; src: string; dst: string }> = [];
 
       // Prepare ENDPOINT nodes
       for (const endpoint of endpoints) {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { handlerLine: _hl, handlerColumn: _hc, handlerStart, handlerName, routerName, ...endpointData } = endpoint;
-
         // Store handler identification in metadata for ExpressHandlerLinker enricher
-        const nodeData = {
-          ...endpointData,
-          metadata: {
-            ...(handlerStart !== undefined && { handlerStart }),
-            ...(handlerName !== undefined && { handlerName })
+        const metadata: Record<string, unknown> = {};
+        if (endpoint.handlerStart !== undefined) metadata.handlerStart = endpoint.handlerStart;
+        if (endpoint.handlerName !== undefined) metadata.handlerName = endpoint.handlerName;
+
+        const brandedNode = NodeFactory.createHttpRoute(
+          endpoint.method,
+          endpoint.path,
+          endpoint.file,
+          endpoint.line,
+          {
+            column: endpoint.column,
+            routerName: endpoint.routerName,
+            metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
           }
-        };
-        nodes.push(nodeData as unknown as NodeRecord);
+        );
+        nodes.push(brandedNode);
         endpointsCreated++;
 
         // MODULE -> CONTAINS -> ENDPOINT
         edges.push({
           type: 'CONTAINS',
           src: module.id,
-          dst: endpoint.id
+          dst: brandedNode.id
         });
         edgesCreated++;
 
@@ -403,28 +391,38 @@ export class ExpressRouteAnalyzer extends Plugin {
         // using handlerStart (byte offset) or handlerName stored in node metadata
       }
 
-      // Prepare MIDDLEWARE nodes
+      // Prepare MIDDLEWARE nodes - track branded IDs for edge creation
+      const middlewareNodeIds: string[] = [];
       for (const middleware of middlewares) {
-        const { endpointId, order: _order, ...middlewareData } = middleware;
-
-        nodes.push(middlewareData as unknown as NodeRecord);
+        const brandedNode = NodeFactory.createExpressMiddleware(
+          middleware.name,
+          middleware.file,
+          middleware.line,
+          middleware.column,
+          {
+            mountPath: middleware.mountPath,
+            isGlobal: middleware.isGlobal,
+          }
+        );
+        nodes.push(brandedNode);
+        middlewareNodeIds.push(brandedNode.id);
         middlewareCreated++;
 
         // MODULE -> CONTAINS -> MIDDLEWARE
         edges.push({
           type: 'CONTAINS',
           src: module.id,
-          dst: middleware.id
+          dst: brandedNode.id
         });
         edgesCreated++;
 
         // Если есть связанный endpoint
-        if (endpointId) {
+        if (middleware.endpointId) {
           // ENDPOINT -> USES_MIDDLEWARE -> MIDDLEWARE
           edges.push({
             type: 'USES_MIDDLEWARE',
-            src: endpointId,
-            dst: middleware.id
+            src: middleware.endpointId,
+            dst: brandedNode.id
           });
           edgesCreated++;
         }
@@ -434,7 +432,9 @@ export class ExpressRouteAnalyzer extends Plugin {
       await graph.addNodes(nodes);
 
       // Query for HANDLED_BY edges (needs nodes to exist first)
-      for (const middleware of middlewares) {
+      for (let i = 0; i < middlewares.length; i++) {
+        const middleware = middlewares[i];
+        const middlewareId = middlewareNodeIds[i];
         // Ищем FUNCTION ноду для middleware (если это именованная функция)
         if (!middleware.name.startsWith('inline:')) {
           for await (const fn of graph.queryNodes({
@@ -445,7 +445,7 @@ export class ExpressRouteAnalyzer extends Plugin {
             // MIDDLEWARE -> HANDLED_BY -> FUNCTION
             edges.push({
               type: 'HANDLED_BY',
-              src: middleware.id,
+              src: middlewareId,
               dst: fn.id
             });
             edgesCreated++;