@grafema/core 0.1.1-alpha → 0.2.1-beta

package/src/storage/backends/RFDBServerBackend.ts

@@ -23,11 +23,12 @@ import { existsSync, unlinkSync } from 'fs';
 import { spawn, type ChildProcess } from 'child_process';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
 import { setTimeout as sleep } from 'timers/promises';
 
 import type { WireNode, WireEdge } from '@grafema/types';
 import type { NodeType, EdgeType } from '@grafema/types';
-import type { BaseNodeRecord } from '@grafema/types';
+import type { BaseNodeRecord, EdgeRecord } from '@grafema/types';
 import type { AttrQuery, GraphStats, GraphExport } from '../../core/GraphBackend.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -41,17 +42,6 @@ export interface RFDBServerBackendOptions {
   dbPath?: string;
 }
 
-/**
- * Edge as returned from the backend
- */
-export interface BackendEdge {
-  src: string;
-  dst: string;
-  type: string;
-  edgeType: string;
-  [key: string]: unknown;
-}
-
 /**
  * Input node format (flexible)
  */
@@ -164,13 +154,30 @@ export class RFDBServerBackend {
 
   /**
    * Find RFDB server binary in order of preference:
-   * 1. @grafema/rfdb npm package
-   * 2. rust-engine/target/release (monorepo development)
-   * 3. rust-engine/target/debug
+   * 1. packages/rfdb-server/target/release (monorepo development - prioritized for dev)
+   * 2. packages/rfdb-server/target/debug
+   * 3. @grafema/rfdb npm package
+   * 4. ~/.local/bin/rfdb-server (user-installed binary)
    */
   private _findServerBinary(): string | null {
-    // 1. Check @grafema/rfdb npm package
+    // 1. Check packages/rfdb-server in monorepo (prioritized for development)
+    const projectRoot = join(__dirname, '../../../../..');
+    const releaseBinary = join(projectRoot, 'packages/rfdb-server/target/release/rfdb-server');
+    if (existsSync(releaseBinary)) {
+      console.log(`[RFDBServerBackend] Found release binary: ${releaseBinary}`);
+      return releaseBinary;
+    }
+
+    // 2. Check debug build
+    const debugBinary = join(projectRoot, 'packages/rfdb-server/target/debug/rfdb-server');
+    if (existsSync(debugBinary)) {
+      console.log(`[RFDBServerBackend] Found debug binary: ${debugBinary}`);
+      return debugBinary;
+    }
+
+    // 3. Check @grafema/rfdb npm package
     try {
+      const require = createRequire(import.meta.url);
       const rfdbPkg = require.resolve('@grafema/rfdb');
       const rfdbDir = dirname(rfdbPkg);
       const platform = process.platform;
@@ -194,19 +201,11 @@ export class RFDBServerBackend {
       // @grafema/rfdb not installed
     }
 
-    // 2. Check rust-engine in monorepo
-    const projectRoot = join(__dirname, '../../../../..');
-    const releaseBinary = join(projectRoot, 'rust-engine/target/release/rfdb-server');
-    if (existsSync(releaseBinary)) {
-      console.log(`[RFDBServerBackend] Found release binary: ${releaseBinary}`);
-      return releaseBinary;
-    }
-
-    // 3. Check debug build
-    const debugBinary = join(projectRoot, 'rust-engine/target/debug/rfdb-server');
-    if (existsSync(debugBinary)) {
-      console.log(`[RFDBServerBackend] Found debug binary: ${debugBinary}`);
-      return debugBinary;
+    // 4. Check ~/.local/bin (user-installed binary for unsupported platforms)
+    const homeBinary = join(process.env.HOME || '', '.local', 'bin', 'rfdb-server');
+    if (existsSync(homeBinary)) {
+      console.log(`[RFDBServerBackend] Found user binary: ${homeBinary}`);
+      return homeBinary;
     }
 
     return null;
@@ -441,13 +440,41 @@ export class RFDBServerBackend {
 
     const humanId = (metadata.originalId as string) || wireNode.id;
 
+    // Exclude standard fields from metadata to prevent overwriting wireNode values
+    // REG-325: Metadata spread was overwriting name with LITERAL node data
+    const {
+      id: _id,
+      type: _type,
+      name: _name,
+      file: _file,
+      exported: _exported,
+      nodeType: _nodeType,
+      originalId: _originalId,  // Already extracted above
+      ...safeMetadata
+    } = metadata;
+
     return {
       id: humanId,
       type: wireNode.nodeType,
       name: wireNode.name,
       file: wireNode.file,
       exported: wireNode.exported,
-      ...metadata,
+      ...safeMetadata,
+    };
+  }
+
+  /**
+   * Parse an edge from wire format to EdgeRecord
+   */
+  private _parseEdge(wireEdge: WireEdge): EdgeRecord {
+    const meta: Record<string, unknown> = wireEdge.metadata ? JSON.parse(wireEdge.metadata) : {};
+    // Use original string IDs if stored, otherwise use wire IDs
+    const { _origSrc, _origDst, ...rest } = meta;
+    return {
+      src: (_origSrc as string) || wireEdge.src,
+      dst: (_origDst as string) || wireEdge.dst,
+      type: wireEdge.edgeType,
+      metadata: Object.keys(rest).length > 0 ? rest : undefined,
     };
   }
 
@@ -506,66 +533,35 @@ export class RFDBServerBackend {
   /**
    * Get all edges
    */
-  async getAllEdges(): Promise<BackendEdge[]> {
+  async getAllEdges(): Promise<EdgeRecord[]> {
     return this.getAllEdgesAsync();
   }
 
   /**
    * Get all edges (async version)
    */
-  async getAllEdgesAsync(): Promise<BackendEdge[]> {
+  async getAllEdgesAsync(): Promise<EdgeRecord[]> {
     if (!this.client) throw new Error('Not connected');
     const edges = await this.client.getAllEdges();
-    return edges.map(e => {
-      const meta = JSON.parse(e.metadata || '{}');
-      // Use original string IDs if stored, otherwise use numeric IDs
-      const { _origSrc, _origDst, ...rest } = meta;
-      return {
-        src: _origSrc || e.src,
-        dst: _origDst || e.dst,
-        type: e.edgeType,
-        edgeType: e.edgeType,
-        ...rest,
-      };
-    });
+    return edges.map(e => this._parseEdge(e));
   }
 
   /**
    * Get outgoing edges from a node
    */
-  async getOutgoingEdges(nodeId: string, edgeTypes: EdgeType[] | null = null): Promise<BackendEdge[]> {
+  async getOutgoingEdges(nodeId: string, edgeTypes: EdgeType[] | null = null): Promise<EdgeRecord[]> {
     if (!this.client) throw new Error('Not connected');
     const edges = await this.client.getOutgoingEdges(nodeId, edgeTypes || undefined);
-    return edges.map(e => {
-      const meta = JSON.parse(e.metadata || '{}');
-      const { _origSrc, _origDst, ...rest } = meta;
-      return {
-        src: _origSrc || e.src,
-        dst: _origDst || e.dst,
-        type: e.edgeType,
-        edgeType: e.edgeType,
-        ...rest,
-      };
-    });
+    return edges.map(e => this._parseEdge(e));
   }
 
   /**
    * Get incoming edges to a node
    */
-  async getIncomingEdges(nodeId: string, edgeTypes: EdgeType[] | null = null): Promise<BackendEdge[]> {
+  async getIncomingEdges(nodeId: string, edgeTypes: EdgeType[] | null = null): Promise<EdgeRecord[]> {
     if (!this.client) throw new Error('Not connected');
     const edges = await this.client.getIncomingEdges(nodeId, edgeTypes || undefined);
-    return edges.map(e => {
-      const meta = JSON.parse(e.metadata || '{}');
-      const { _origSrc, _origDst, ...rest } = meta;
-      return {
-        src: _origSrc || e.src,
-        dst: _origDst || e.dst,
-        type: e.edgeType,
-        edgeType: e.edgeType,
-        ...rest,
-      };
-    });
+    return edges.map(e => this._parseEdge(e));
   }
 
   // ===========================================================================

package/src/storage/backends/typeValidation.ts

@@ -45,6 +45,7 @@ const KNOWN_EDGE_TYPES = new Set<string>([
   'INTERACTS_WITH', 'CALLS_API', 'LISTENS_TO', 'JOINS_ROOM', 'EMITS_EVENT',
   'RETURNS', 'RECEIVES_ARGUMENT', 'READS_FROM', 'THROWS', 'REGISTERS_VIEW',
   'GOVERNS', 'VIOLATES', 'HAS_PARAMETER', 'DERIVES_FROM',
+  'RESOLVES_TO',  // Promise resolve() data flow
 ]);
 
 // Store initial edge types for reset