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

package/tests/notifications.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { System } from '@/system/system';
+import {
+  notifySuccess,
+  notifyError,
+  notifyInfo,
+  notifyLoading
+} from '@/components/notifications/utils';
+
+describe('Notification System', () => {
+  let system: System;
+  let publishSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    system = new System();
+    publishSpy = vi.spyOn(system.pubsub, 'publish');
+  });
+
+  describe('notifySuccess', () => {
+    it('should publish success notification', () => {
+      const message = 'Success!';
+
+      notifySuccess(system.pubsub, message);
+
+      expect(publishSpy).toHaveBeenCalledWith('notification', {
+        type: 'success',
+        message,
+        options: undefined
+      });
+    });
+
+    it('should include options when provided', () => {
+      const message = 'Success with options!';
+      const options = { duration: 5000, id: 'test-id' };
+
+      notifySuccess(system.pubsub, message, options);
+
+      expect(publishSpy).toHaveBeenCalledWith('notification', {
+        type: 'success',
+        message,
+        options
+      });
+    });
+  });
+
+  describe('notifyError', () => {
+    it('should publish error notification', () => {
+      const message = 'Error!';
+
+      notifyError(system.pubsub, message);
+
+      expect(publishSpy).toHaveBeenCalledWith('notification', {
+        type: 'error',
+        message,
+        options: undefined
+      });
+    });
+  });
+
+  describe('notifyInfo', () => {
+    it('should publish info notification', () => {
+      const message = 'Info!';
+
+      notifyInfo(system.pubsub, message);
+
+      expect(publishSpy).toHaveBeenCalledWith('notification', {
+        type: 'info',
+        message,
+        options: undefined
+      });
+    });
+  });
+
+  describe('notifyLoading', () => {
+    it('should publish loading notification', () => {
+      const message = 'Loading...';
+
+      notifyLoading(system.pubsub, message);
+
+      expect(publishSpy).toHaveBeenCalledWith('notification', {
+        type: 'loading',
+        message,
+        options: undefined
+      });
+    });
+  });
+});

package/tests/saveLoad.test.ts

@@ -0,0 +1,372 @@
+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);
+  });
+
+  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);
+
+    // 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);
+
+    // 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);
+
+    // 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);
+
+    // 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);
+
+    // 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);
+
+    // 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/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');
+  });
+});

package/tests/util/getSocketsByNodeTypeAndHandleType.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import { getSocketsByNodeTypeAndHandleType } from '@/util/getSocketsByNodeTypeAndHandleType';
+import type { NodeSpecJSON } from '@kiberon-labs/behave-graph';
+
+const specs = [
+  {
+    type: 'math/add',
+    inputs: [{ name: 'a', valueType: 'float' }],
+    outputs: [{ name: 'result', valueType: 'float' }]
+  }
+] as unknown as NodeSpecJSON[];
+
+describe('getSocketsByNodeTypeAndHandleType', () => {
+  it('returns the output sockets for a source handle', () => {
+    expect(
+      getSocketsByNodeTypeAndHandleType(specs, 'math/add', 'source')
+    ).toEqual([{ name: 'result', valueType: 'float' }]);
+  });
+
+  it('returns the input sockets for a target handle', () => {
+    expect(
+      getSocketsByNodeTypeAndHandleType(specs, 'math/add', 'target')
+    ).toEqual([{ name: 'a', valueType: 'float' }]);
+  });
+
+  it('returns undefined for an unknown node type', () => {
+    expect(
+      getSocketsByNodeTypeAndHandleType(specs, 'does/not/exist', 'source')
+    ).toBeUndefined();
+  });
+});

package/tests/util/hasPositionMetaData.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { hasPositionMetaData } from '@/util/hasPositionMetaData';
+import type { GraphJSON } from '@kiberon-labs/behave-graph';
+
+const graph = (nodes: unknown): GraphJSON => ({ nodes }) as GraphJSON;
+
+describe('hasPositionMetaData', () => {
+  it('returns true when any node carries position metadata', () => {
+    expect(
+      hasPositionMetaData(
+        graph([
+          { type: 'a', id: '1' },
+          { type: 'b', id: '2', metadata: { positionX: '10', positionY: '20' } }
+        ])
+      )
+    ).toBe(true);
+  });
+
+  it('returns false when no node carries position metadata', () => {
+    expect(
+      hasPositionMetaData(
+        graph([
+          { type: 'a', id: '1' },
+          { type: 'b', id: '2', metadata: { label: 'hi' } }
+        ])
+      )
+    ).toBe(false);
+  });
+
+  it('returns false when there are no nodes', () => {
+    expect(hasPositionMetaData(graph(undefined))).toBe(false);
+  });
+});

package/tests/util/isBehaveNode.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { isBehaveNode } from '@/util/isBehaveNode';
+import type { Node } from 'reactflow';
+
+const node = (type: unknown): Node =>
+  ({ id: 'n', position: { x: 0, y: 0 }, data: {}, type }) as Node;
+
+describe('isBehaveNode', () => {
+  it('returns true for node types starting with "behaveNode"', () => {
+    expect(isBehaveNode(node('behaveNode'))).toBe(true);
+    expect(isBehaveNode(node('behaveNode-flow'))).toBe(true);
+  });
+
+  it('returns false for other node types', () => {
+    expect(isBehaveNode(node('comment'))).toBe(false);
+    expect(isBehaveNode(node('group'))).toBe(false);
+  });
+
+  it('returns false when the type is missing', () => {
+    expect(isBehaveNode(node(undefined))).toBe(false);
+  });
+});

package/tests/util/isHandleConnected.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import { isHandleConnected } from '@/util/isHandleConnected';
+import type { Edge } from 'reactflow';
+
+const edge = (over: Partial<Edge>): Edge =>
+  ({ id: 'e', source: 's', target: 't', ...over }) as Edge;
+
+describe('isHandleConnected', () => {
+  const edges: Edge[] = [
+    edge({
+      source: 'n1',
+      sourceHandle: 'out',
+      target: 'n2',
+      targetHandle: 'in'
+    })
+  ];
+
+  it('detects a connected source handle', () => {
+    expect(isHandleConnected(edges, 'n1', 'out', 'source')).toBe(true);
+  });
+
+  it('detects a connected target handle', () => {
+    expect(isHandleConnected(edges, 'n2', 'in', 'target')).toBe(true);
+  });
+
+  it('returns false when the node id does not match', () => {
+    expect(isHandleConnected(edges, 'other', 'out', 'source')).toBe(false);
+  });
+
+  it('returns false when the handle id does not match', () => {
+    expect(isHandleConnected(edges, 'n1', 'wrong', 'source')).toBe(false);
+  });
+
+  it('returns false for an empty edge list', () => {
+    expect(isHandleConnected([], 'n1', 'out', 'source')).toBe(false);
+  });
+});