@kiberon-labs/behave-graph-flow 1.0.0 → 3.0.0

package/tests/saveLoad.test.ts

@@ -0,0 +1,373 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  registerCoreProfile,
+  writeNodeSpecsToJSON
+} from '@kiberon-labs/behave-graph';
+import { System } from '../src/system/system.js';
+import { buildUIGraphJSON } from '../src/transformers/Uigraph.js';
+
+describe('Save and Load Graph', () => {
+  let system: System;
+
+  beforeEach(() => {
+    // Create a system with a basic registry
+    const coreRegistry = registerCoreProfile({
+      nodes: {},
+      values: {},
+      dependencies: {}
+    });
+
+    const nodeSpecs = writeNodeSpecsToJSON(coreRegistry);
+    const registry = {
+      values: coreRegistry.values,
+      specs: nodeSpecs
+    };
+
+    system = new System(registry);
+    system.createSession('graph');
+  });
+
+  it('should save and load a graph with node positions', () => {
+    // Setup: Create a graph with positioned nodes
+    const initialNodes = [
+      {
+        id: 'node1',
+        type: 'behaveNode',
+        position: { x: 100, y: 200 },
+        data: {
+          type: 'lifecycle/onStart',
+          configuration: {},
+          ports: {},
+          annotations: {}
+        }
+      },
+      {
+        id: 'node2',
+        type: 'behaveNode',
+        position: { x: 300, y: 400 },
+        data: {
+          type: 'debug/log',
+          configuration: {},
+          ports: {},
+          annotations: {}
+        }
+      }
+    ];
+
+    const initialEdges = [
+      {
+        id: 'edge1',
+        source: 'node1',
+        target: 'node2',
+        sourceHandle: 'flow',
+        targetHandle: 'flow'
+      }
+    ];
+
+    system.nodeStore.getState().setNodes(initialNodes);
+    system.edgeStore.getState().setEdges(initialEdges);
+
+    // Save the graph
+    const savedGraph = buildUIGraphJSON(system.session!);
+
+    // Verify saved graph has nodes with positions
+    expect(savedGraph.nodes).toHaveLength(2);
+    expect(savedGraph.nodes[0].position).toEqual({ x: 100, y: 200 });
+    expect(savedGraph.nodes[1].position).toEqual({ x: 300, y: 400 });
+
+    // Clear the system
+    system.nodeStore.getState().setNodes([]);
+    system.edgeStore.getState().setEdges([]);
+
+    // Load the graph
+    system.graph.deseralize(savedGraph);
+    system.flowStore.getState().setGraph(savedGraph.flow, { skipLayout: true });
+
+    // Verify loaded nodes have correct positions
+    const loadedNodes = system.nodeStore.getState().nodes;
+    expect(loadedNodes).toHaveLength(2);
+    expect(loadedNodes[0].position).toEqual({ x: 100, y: 200 });
+    expect(loadedNodes[1].position).toEqual({ x: 300, y: 400 });
+  });
+
+  it('should preserve viewport when saving and loading', () => {
+    // Setup: Create nodes and set viewport
+    const mockReactFlow = {
+      getViewport: () => ({ x: 50, y: 100, zoom: 1.5 }),
+      setViewport: () => {}
+    };
+
+    system.refStore.getState().setRef('reactflow', mockReactFlow);
+
+    const initialNodes = [
+      {
+        id: 'node1',
+        type: 'behaveNode',
+        position: { x: 100, y: 200 },
+        data: {
+          type: 'lifecycle/onStart',
+          configuration: {},
+          ports: {},
+          annotations: {}
+        }
+      }
+    ];
+
+    system.nodeStore.getState().setNodes(initialNodes);
+
+    // Save the graph
+    const savedGraph = buildUIGraphJSON(system.session!);
+
+    // Verify viewport is saved
+    expect(savedGraph.user?.viewport).toEqual({ x: 50, y: 100, zoom: 1.5 });
+  });
+
+  it('should preserve variables when saving and loading', () => {
+    // Setup: Create variables
+    const variables = {
+      var1: {
+        id: 'var1',
+        name: 'myVariable',
+        valueTypeName: 'string',
+        initialValue: 'test value'
+      }
+    };
+
+    system.variableStore.getState().setVariables(variables);
+
+    // Add a node so we have something to save
+    const nodes = [
+      {
+        id: 'node1',
+        type: 'behaveNode',
+        position: { x: 0, y: 0 },
+        data: {
+          type: 'lifecycle/onStart',
+          configuration: {},
+          ports: {},
+          annotations: {}
+        }
+      }
+    ];
+    system.nodeStore.getState().setNodes(nodes);
+
+    // Save the graph
+    const savedGraph = buildUIGraphJSON(system.session!);
+
+    // Verify variables are in the flow
+    expect(savedGraph.flow.variables).toBeDefined();
+    expect(savedGraph.flow.variables?.length).toBe(1);
+    expect(savedGraph.flow.variables?.[0].name).toBe('myVariable');
+
+    // Clear variables
+    system.variableStore.getState().setVariables({});
+
+    // Load the graph
+    system.graph.deseralize(savedGraph);
+    system.flowStore.getState().setGraph(savedGraph.flow, { skipLayout: true });
+
+    // Verify variables are restored
+    const loadedVariables = system.variableStore.getState().variables;
+    expect(Object.keys(loadedVariables)).toHaveLength(1);
+    expect(loadedVariables['var1'].name).toBe('myVariable');
+  });
+
+  it('should preserve custom events when saving and loading', () => {
+    // Setup: Create custom events
+    const customEvents = [
+      {
+        id: 'event1',
+        name: 'customEvent',
+        parameters: []
+      }
+    ];
+
+    system.eventsStore.getState().setCustomEvents(customEvents);
+
+    // Add a node so we have something to save
+    const nodes = [
+      {
+        id: 'node1',
+        type: 'behaveNode',
+        position: { x: 0, y: 0 },
+        data: {
+          type: 'lifecycle/onStart',
+          configuration: {},
+          ports: {},
+          annotations: {}
+        }
+      }
+    ];
+    system.nodeStore.getState().setNodes(nodes);
+
+    // Save the graph
+    const savedGraph = buildUIGraphJSON(system.session!);
+
+    // Verify custom events are in the flow
+    expect(savedGraph.flow.customEvents).toEqual(customEvents);
+
+    // Clear events
+    system.eventsStore.getState().setCustomEvents([]);
+
+    // Load the graph
+    system.graph.deseralize(savedGraph);
+    system.flowStore.getState().setGraph(savedGraph.flow, { skipLayout: true });
+
+    // Verify custom events are restored
+    const loadedEvents = system.eventsStore.getState().getCustomEvents();
+    expect(loadedEvents).toEqual(customEvents);
+  });
+
+  it('should not overwrite node positions when loading with skipLayout', () => {
+    // Setup: Create a graph with specific positions
+    const nodesWithPositions = [
+      {
+        id: 'node1',
+        type: 'behaveNode',
+        position: { x: 100, y: 200 },
+        data: {
+          type: 'lifecycle/onStart',
+          configuration: {},
+          ports: {},
+          annotations: {}
+        }
+      }
+    ];
+
+    system.nodeStore.getState().setNodes(nodesWithPositions);
+
+    // Save the graph
+    const savedGraph = buildUIGraphJSON(system.session!);
+
+    // Modify the node position
+    system.nodeStore.getState().setNodes([
+      {
+        ...nodesWithPositions[0],
+        position: { x: 999, y: 999 }
+      }
+    ]);
+
+    // Load the graph with skipLayout
+    system.graph.deseralize(savedGraph);
+    system.flowStore.getState().setGraph(savedGraph.flow, { skipLayout: true });
+
+    // Verify positions from deseralize are preserved (not overwritten)
+    const loadedNodes = system.nodeStore.getState().nodes;
+    expect(loadedNodes[0].position).toEqual({ x: 100, y: 200 });
+  });
+
+  it('should apply auto-layout when loading graph without position metadata', () => {
+    // Create a plain GraphJSON without position metadata
+    const graphWithoutPositions = {
+      nodes: [
+        {
+          id: 'node1',
+          type: 'lifecycle/onStart',
+          metadata: {}
+        },
+        {
+          id: 'node2',
+          type: 'debug/log',
+          metadata: {}
+        }
+      ],
+      variables: [],
+      customEvents: []
+    };
+
+    // Load the graph (should apply auto-layout)
+    system.flowStore.getState().setGraph(graphWithoutPositions);
+
+    // Verify nodes were created with positions (auto-layout applied)
+    const loadedNodes = system.nodeStore.getState().nodes;
+    expect(loadedNodes).toHaveLength(2);
+    expect(loadedNodes[0].position).toBeDefined();
+    expect(loadedNodes[1].position).toBeDefined();
+    // Auto-layout should set non-zero positions
+    const hasLayout = loadedNodes.some(
+      (n) => n.position.x !== 0 || n.position.y !== 0
+    );
+    expect(hasLayout).toBe(true);
+  });
+
+  it('should handle round-trip save/load without data loss', () => {
+    // Setup a complete graph
+    const nodes = [
+      {
+        id: 'node1',
+        type: 'behaveNode',
+        position: { x: 100, y: 200 },
+        data: {
+          type: 'lifecycle/onStart',
+          configuration: {},
+          ports: {},
+          annotations: {}
+        }
+      },
+      {
+        id: 'node2',
+        type: 'behaveNode',
+        position: { x: 300, y: 400 },
+        data: {
+          type: 'debug/log',
+          configuration: { text: { value: 'test' } },
+          ports: {},
+          annotations: {}
+        }
+      }
+    ];
+
+    const edges = [
+      {
+        id: 'edge1',
+        source: 'node1',
+        target: 'node2',
+        sourceHandle: 'flow',
+        targetHandle: 'flow'
+      }
+    ];
+
+    const variables = {
+      var1: {
+        id: 'var1',
+        name: 'testVar',
+        valueTypeName: 'float',
+        initialValue: 42
+      }
+    };
+
+    system.nodeStore.getState().setNodes(nodes);
+    system.edgeStore.getState().setEdges(edges);
+    system.variableStore.getState().setVariables(variables);
+
+    // Save
+    const saved = buildUIGraphJSON(system.session!);
+
+    // Clear
+    system.nodeStore.getState().setNodes([]);
+    system.edgeStore.getState().setEdges([]);
+    system.variableStore.getState().setVariables({});
+
+    // Load
+    system.graph.deseralize(saved);
+    system.flowStore.getState().setGraph(saved.flow, { skipLayout: true });
+
+    // Verify everything is restored
+    const loadedNodes = system.nodeStore.getState().nodes;
+    const loadedEdges = system.edgeStore.getState().edges;
+    const loadedVars = system.variableStore.getState().variables;
+
+    expect(loadedNodes).toHaveLength(2);
+    expect(loadedNodes[0].position).toEqual({ x: 100, y: 200 });
+    expect(loadedNodes[1].data.configuration).toEqual({
+      text: { value: 'test' }
+    });
+
+    expect(loadedEdges).toHaveLength(1);
+    expect(loadedEdges[0].source).toBe('node1');
+    expect(loadedEdges[0].target).toBe('node2');
+
+    expect(Object.keys(loadedVars)).toHaveLength(1);
+    expect(loadedVars['var1'].initialValue).toBe(42);
+  });
+});

package/tests/settings.test.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect, vi } from 'vitest';
+import { System } from '../src/system/system.js';
+import { registerDefaults } from '../src/generators/registerDefaults.js';
+
+describe('editor settings serialization', () => {
+  it('round-trips toggles and custom conversions', () => {
+    const a = new System();
+    a.systemSettings.getState().setAutoConvert(false);
+    a.systemSettings.getState().setGridSize(42);
+    a.registerConversion({ from: 'integer', to: 'string', nodeType: 'x/conv' });
+
+    const json = a.serializeSettings();
+
+    const b = new System();
+    b.applySettings(json);
+
+    expect(b.systemSettings.getState().autoConvert).toBe(false);
+    expect(b.systemSettings.getState().gridSize).toBe(42);
+    expect(b.conversionStore.getState().conversions).toEqual([
+      { from: 'integer', to: 'string', nodeType: 'x/conv' }
+    ]);
+  });
+
+  it('round-trips settings that the old hand-written store dropped', () => {
+    // inlineValues lacked a setter (so applySettings could not restore it) and
+    // setShowMenu was untyped , both fixed by the declarative schema.
+    const a = new System();
+    a.systemSettings.getState().setInlineValues(true);
+    a.systemSettings.getState().setShowMenu(false);
+
+    const b = new System();
+    b.applySettings(a.serializeSettings());
+
+    expect(b.systemSettings.getState().inlineValues).toBe(true);
+    expect(b.systemSettings.getState().showMenu).toBe(false);
+  });
+
+  it('does not persist transient settings (showSearch)', () => {
+    const a = new System();
+    a.systemSettings.getState().setShowSearch(true);
+    expect(a.serializeSettings().settings).not.toHaveProperty('showSearch');
+  });
+});
+
+describe('plugin-contributed settings (schema registry)', () => {
+  it('seeds the built-in descriptors so the panel auto-generates', () => {
+    const sys = new System();
+    const keys = sys.settingsSchema.getState().settings.map((s) => s.key);
+    expect(keys).toContain('edgeType');
+    expect(keys).toContain('autoConvert');
+    expect(sys.settingsSchema.getState().sectionOrder).toContain('Layout');
+  });
+
+  it('registerSetting adds a descriptor and seeds its default value', () => {
+    const sys = new System();
+    sys.registerSetting({
+      key: 'myPlugin.apiUrl',
+      section: 'My Plugin',
+      type: 'string',
+      default: 'https://example.com',
+      title: 'API URL'
+    });
+
+    expect(sys.getSetting('myPlugin.apiUrl')).toBe('https://example.com');
+    expect(
+      sys.settingsSchema
+        .getState()
+        .settings.some((s) => s.key === 'myPlugin.apiUrl')
+    ).toBe(true);
+    expect(sys.settingsSchema.getState().sectionOrder).toContain('My Plugin');
+  });
+
+  it('ignores a duplicate key without clobbering the original', () => {
+    const sys = new System();
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    try {
+      // edgeType is a built-in; a plugin must not be able to redefine it.
+      sys.registerSetting({
+        key: 'edgeType',
+        section: 'Hijack',
+        type: 'boolean',
+        default: true
+      });
+      expect(warn).toHaveBeenCalled();
+      const edge = sys.settingsSchema
+        .getState()
+        .settings.find((s) => s.key === 'edgeType');
+      expect(edge?.section).toBe('Layout');
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  it('round-trips plugin setting values through persistence', () => {
+    const a = new System();
+    a.registerSetting({
+      key: 'myPlugin.autoStart',
+      section: 'My Plugin',
+      type: 'boolean',
+      default: false
+    });
+    a.setSetting('myPlugin.autoStart', true);
+
+    const json = a.serializeSettings();
+    expect(json.settings).toHaveProperty('myPlugin.autoStart', true);
+
+    const b = new System();
+    b.registerSetting({
+      key: 'myPlugin.autoStart',
+      section: 'My Plugin',
+      type: 'boolean',
+      default: false
+    });
+    b.applySettings(json);
+    expect(b.getSetting('myPlugin.autoStart')).toBe(true);
+  });
+
+  it('excludes persist:false plugin settings from serialization', () => {
+    const sys = new System();
+    sys.registerSetting({
+      key: 'myPlugin.scratch',
+      section: 'My Plugin',
+      type: 'boolean',
+      default: false,
+      persist: false
+    });
+    sys.setSetting('myPlugin.scratch', true);
+    expect(sys.serializeSettings().settings).not.toHaveProperty(
+      'myPlugin.scratch'
+    );
+  });
+});
+
+describe('registerDefaults', () => {
+  it('registers built-in generators and is idempotent per editor', () => {
+    const sys = new System();
+    registerDefaults(sys);
+    const first = sys.socketGeneratorStore.getState().generators.length;
+    expect(first).toBeGreaterThan(0);
+
+    // Second call (e.g. another graph tab mounting) is a no-op.
+    expect(() => registerDefaults(sys)).not.toThrow();
+    expect(sys.socketGeneratorStore.getState().generators.length).toBe(first);
+  });
+
+  it('persists to and loads from a storage adapter', () => {
+    vi.useFakeTimers();
+    try {
+      const backing: Record<string, string> = {};
+      const storage = {
+        getItem: (k: string) => backing[k] ?? null,
+        setItem: (k: string, v: string) => {
+          backing[k] = v;
+        }
+      };
+
+      const a = new System();
+      a.enableSettingsPersistence(storage);
+      a.registerConversion({ from: 'float', to: 'string', nodeType: 'f/conv' });
+      a.systemSettings.getState().setShowGrid(false);
+      vi.advanceTimersByTime(400); // flush the debounced save
+
+      expect(Object.keys(backing).length).toBe(1);
+
+      // A fresh system loads the saved state on init.
+      const b = new System();
+      b.enableSettingsPersistence(storage);
+      expect(b.systemSettings.getState().showGrid).toBe(false);
+      expect(b.conversionStore.getState().conversions).toContainEqual({
+        from: 'float',
+        to: 'string',
+        nodeType: 'f/conv'
+      });
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});

package/tests/traceStore.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { traceStoreFactory } from '../src/store/traces.js';
+import type { TraceSpan } from '../src/store/traces.js';
+
+const newStore = () => traceStoreFactory({} as any).getState();
+
+const usedLanes = (spans: TraceSpan[], size: number): Set<number> =>
+  new Set(spans.slice(0, size).map((s) => s.lane));
+
+describe('trace store lane allocation', () => {
+  it('reuses a lane for sequential spans (closed before the next opens)', () => {
+    const s = newStore();
+    // A opens and closes, then B opens and closes , never overlapping.
+    s.addSpan({ nodeId: 'a', name: 'a', start: 0, end: Number.NaN });
+    s.updateSpan('a', { end: 1 });
+    s.addSpan({ nodeId: 'b', name: 'b', start: 2, end: Number.NaN });
+    s.updateSpan('b', { end: 3 });
+
+    const c = s.collector;
+    expect(c.size).toBe(2);
+    // Both land in lane 0 → the panel shows a single lane.
+    expect(usedLanes(c.spans, c.size)).toEqual(new Set([0]));
+  });
+
+  it('allocates separate lanes for concurrent (overlapping) spans', () => {
+    const s = newStore();
+    // Both open at once (no end between them) → must not share a lane.
+    s.addSpan({ nodeId: 'a', name: 'a', start: 0, end: Number.NaN });
+    s.addSpan({ nodeId: 'b', name: 'b', start: 0, end: Number.NaN });
+
+    const c = s.collector;
+    expect(c.size).toBe(2);
+    expect(usedLanes(c.spans, c.size)).toEqual(new Set([0, 1]));
+  });
+
+  it('keeps an open span as open (NaN end) until updateSpan closes it', () => {
+    const s = newStore();
+    s.addSpan({ nodeId: 'a', name: 'a', start: 5, end: Number.NaN });
+
+    const open = s.collector.spans[0]!;
+    expect(Number.isNaN(open.end)).toBe(true);
+
+    s.updateSpan('a', { end: 9 });
+    expect(s.collector.spans[0]!.end).toBe(9);
+  });
+});

package/tests/util/calculateNewEdge.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it } from 'vitest';
+import { calculateNewEdge } from '@/util/calculateNewEdge';
+import type { NodeSpecJSON } from '@kiberon-labs/behave-graph';
+import type { Node, OnConnectStartParams } from 'reactflow';
+
+const specJSON = [
+  {
+    type: 'source/node',
+    inputs: [],
+    outputs: [{ name: 'out', valueType: 'flow' }]
+  },
+  {
+    type: 'target/node',
+    inputs: [{ name: 'in', valueType: 'flow' }],
+    outputs: []
+  }
+] as unknown as NodeSpecJSON[];
+
+const originNode = { id: 'origin', type: 'source/node' } as Node;
+
+describe('calculateNewEdge', () => {
+  it('wires source -> target when dragging from a source handle', () => {
+    const connection: OnConnectStartParams = {
+      nodeId: 'origin',
+      handleId: 'out',
+      handleType: 'source'
+    };
+
+    const edge = calculateNewEdge(
+      originNode,
+      'target/node',
+      'dest',
+      connection,
+      specJSON
+    );
+
+    expect(edge).toMatchObject({
+      source: 'origin',
+      sourceHandle: 'out',
+      target: 'dest',
+      targetHandle: 'in'
+    });
+    expect(typeof edge.id).toBe('string');
+    expect(edge.id.length).toBeGreaterThan(0);
+  });
+
+  it('wires target -> source when dragging from a target handle', () => {
+    const connection: OnConnectStartParams = {
+      nodeId: 'origin',
+      handleId: 'in',
+      handleType: 'target'
+    };
+    const targetOrigin = { id: 'origin', type: 'target/node' } as Node;
+
+    const edge = calculateNewEdge(
+      targetOrigin,
+      'source/node',
+      'dest',
+      connection,
+      specJSON
+    );
+
+    expect(edge).toMatchObject({
+      target: 'origin',
+      targetHandle: 'in',
+      source: 'dest',
+      sourceHandle: 'out'
+    });
+  });
+
+  it('matches the destination socket by value type', () => {
+    const multiSpec = [
+      {
+        type: 'source/node',
+        inputs: [],
+        outputs: [{ name: 'out', valueType: 'string' }]
+      },
+      {
+        type: 'target/node',
+        inputs: [
+          { name: 'flowIn', valueType: 'flow' },
+          { name: 'strIn', valueType: 'string' }
+        ],
+        outputs: []
+      }
+    ] as unknown as NodeSpecJSON[];
+
+    const edge = calculateNewEdge(
+      originNode,
+      'target/node',
+      'dest',
+      { nodeId: 'origin', handleId: 'out', handleType: 'source' },
+      multiSpec
+    );
+
+    expect(edge.targetHandle).toBe('strIn');
+  });
+});