@dxos/app-graph 0.4.6 → 0.4.7-main.0a4f1cd

package/src/graph.test.ts

@@ -2,219 +2,315 @@
 // Copyright 2023 DXOS.org
 //
 
+import { effect } from '@preact/signals-core';
 import { expect } from 'chai';
 
 import { describe, test } from '@dxos/test';
 
-import { GraphBuilder } from './graph-builder';
-import { createTestNodeBuilder } from './testing';
+import { Graph } from './graph';
+import { type Node, type NodeFilter } from './node';
 
-describe('Graph', () => {
-  test('returns root node', () => {
-    const graph = new GraphBuilder().build();
-    expect(graph.root).to.not.be.undefined;
-    expect(graph.root.id).to.equal('root');
-  });
+const longestPaths = new Map<string, string[]>();
 
-  test('root node unmodified without builders', () => {
-    const graph = new GraphBuilder().build();
-    expect(graph.root.properties).to.be.empty;
-    expect(graph.root.children).to.be.empty;
-    expect(graph.root.actions).to.be.empty;
-  });
+const filterLongestPath: NodeFilter = (node, connectedNode): node is Node => {
+  const longestPath = longestPaths.get(node.id);
+  if (!longestPath) {
+    return false;
+  }
 
-  test('builder can add children to root node', () => {
-    const builder = new GraphBuilder();
-    const testNode = { id: 'test', label: 'Test', data: null };
-    const id = 'test';
-    builder.addNodeBuilder(id, (parent) => {
-      if (parent.id === 'root') {
-        parent.addNode(id, testNode);
-      }
-    });
+  if (longestPath[longestPath.length - 2] !== connectedNode.id) {
+    return false;
+  }
 
-    const graph = builder.build();
-    expect(graph.root.childrenMap.test.id).to.equal(testNode.id);
-    expect(graph.root.childrenMap.test.parent!.id).to.equal(graph.root.id);
-  });
+  return true;
+};
+
+// TODO(wittjosiah): Add tests for granularity of reactivity.
+describe('Graph', () => {
+  test('add nodes', () => {
+    const graph = new Graph();
 
-  test('builder can add actions to root node', () => {
-    const builder = new GraphBuilder();
-    const testAction = { id: 'test', label: 'Test', invoke: () => {} };
-    builder.addNodeBuilder('test', (parent) => {
-      if (parent.id === 'root') {
-        parent.addAction(testAction);
-      }
+    const [root] = graph.addNodes({
+      id: 'root',
+      nodes: [{ id: 'test1' }, { id: 'test2' }],
     });
 
-    const graph = builder.build();
-    expect(graph.root.actionsMap.test.id).to.equal(testAction.id);
+    expect(root.id).to.equal('root');
+    expect(root.nodes()).to.have.length(2);
+    expect(graph.findNode('test1')?.id).to.equal('test1');
+    expect(graph.findNode('test2')?.id).to.equal('test2');
+    expect(graph.findNode('test1')?.nodes()).to.be.empty;
+    expect(graph.findNode('test2')?.nodes()).to.be.empty;
+    expect(graph.findNode('test1')?.nodes({ direction: 'inbound' })).to.have.length(1);
+    expect(graph.findNode('test2')?.nodes({ direction: 'inbound' })).to.have.length(1);
   });
 
-  test('multiple builders can add children to root node', () => {
-    const builder = new GraphBuilder();
-    builder.addNodeBuilder('test1', createTestNodeBuilder('test1').nodeBuilder);
-    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
+  test('add nodes updates existing nodes', () => {
+    const graph = new Graph();
 
-    const graph = builder.build();
-    expect(Object.keys(graph.root.childrenMap)).to.deep.equal(['root-test1', 'root-test2']);
-    for (const node of graph.root.children) {
-      expect(graph.root.id).to.equal(node.parent!.id);
-    }
+    graph.addNodes({
+      id: 'root',
+      nodes: [{ id: 'test1' }, { id: 'test2' }],
+    });
+    graph.addNodes({
+      id: 'root',
+      nodes: [{ id: 'test1' }, { id: 'test2' }],
+    });
+
+    expect(Object.keys(graph._nodes)).to.have.length(3);
+    expect(Object.keys(graph._edges)).to.have.length(3);
+    expect(graph.root.nodes()).to.have.length(2);
   });
 
-  test('multiple builders can add actions to root node', () => {
-    const builder = new GraphBuilder();
-    builder.addNodeBuilder('test1', createTestNodeBuilder('test1').nodeBuilder);
-    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
+  test('remove node', () => {
+    const graph = new Graph();
 
-    const graph = builder.build();
-    expect(Object.keys(graph.root.actionsMap)).to.deep.equal(['root-test1', 'root-test2']);
-  });
+    const [root] = graph.addNodes({
+      id: 'root',
+      nodes: [{ id: 'test1' }, { id: 'test2' }],
+    });
 
-  test('builders can add children to child node', () => {
-    const builder = new GraphBuilder();
-    builder.addNodeBuilder('test1', createTestNodeBuilder('test1', 2).nodeBuilder);
-    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
+    expect(root.id).to.equal('root');
+    expect(root.nodes()).to.have.length(2);
+    expect(graph.findNode('test1')?.id).to.equal('test1');
+    expect(graph.findNode('test2')?.id).to.equal('test2');
 
-    const graph = builder.build();
-    expect(Object.keys(graph.root.childrenMap['root-test1'].children)).to.be.empty;
-    expect(Object.keys(graph.root.childrenMap['root-test2'].childrenMap)).to.deep.equal(['root-test2-test1']);
-    for (const node of graph.root.childrenMap['root-test2'].children) {
-      expect(graph.root.childrenMap['root-test2'].id).to.equal(node.parent!.id);
-    }
+    graph.removeNode('test1');
+    expect(graph.findNode('test1')).to.be.undefined;
+    expect(root.nodes()).to.have.length(1);
   });
 
-  test('builders can add actions to child node', () => {
-    const builder = new GraphBuilder();
-    builder.addNodeBuilder('test1', createTestNodeBuilder('test1', 2).nodeBuilder);
-    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
+  test('add edge', () => {
+    const graph = new Graph();
 
-    const graph = builder.build();
-    expect(Object.keys(graph.root.childrenMap['root-test1'].actionsMap)).to.be.empty;
-    expect(Object.keys(graph.root.childrenMap['root-test2'].actionsMap)).to.deep.equal(['root-test2-test1']);
+    graph.addNodes({
+      id: 'root',
+      nodes: [{ id: 'test1' }, { id: 'test2' }],
+    });
+    graph.addEdge({ source: 'test1', target: 'test2' });
+
+    expect(graph.findNode('test1')?.nodes()).to.have.length(1);
+    expect(graph.findNode('test2')?.nodes({ direction: 'inbound' })).to.have.length(2);
   });
 
-  test('builders can add actions to action sets', () => {
-    const builder = new GraphBuilder();
-    builder.addNodeBuilder('test', (parent) => {
-      const [set] = parent.addAction({ id: 'test-set', label: 'Test Set', invoke: () => {} });
-      set.addAction({ id: 'test-action', label: 'Test', invoke: () => {} });
+  test('add edges is idempontent', () => {
+    const graph = new Graph();
+
+    graph.addNodes({
+      id: 'root',
+      nodes: [{ id: 'test1' }, { id: 'test2' }],
     });
+    graph.addEdge({ source: 'test1', target: 'test2' });
+    graph.addEdge({ source: 'test1', target: 'test2' });
 
-    const graph = builder.build();
-    expect(Object.keys(graph.root.actionsMap['test-set'].actionsMap)).to.deep.equal(['test-action']);
+    expect(graph.findNode('test1')?.nodes()).to.have.length(1);
+    expect(graph.findNode('test2')?.nodes({ direction: 'inbound' })).to.have.length(2);
   });
 
-  test('is updated when nodes change', async () => {
-    const builder = new GraphBuilder();
+  test('sort edges', () => {
+    const graph = new Graph();
 
-    // TODO(burdon): Return TestNodeBuilder object.
-    const { nodeBuilder, addNode, removeNode, addAction, removeAction, addProperty, removeProperty } =
-      createTestNodeBuilder('test1', 2);
-    builder.addNodeBuilder('test1', nodeBuilder);
+    const [root] = graph.addNodes({
+      id: 'root',
+      nodes: [{ id: 'test1' }, { id: 'test3' }, { id: 'test2' }, { id: 'test4' }],
+    });
 
-    const graph = builder.build();
-    expect(graph.root.children).to.have.length(1);
-    addNode('root', { id: 'root-test2', label: 'root-test2' });
-    expect(graph.root.children).to.have.length(2);
-    expect(graph.root.childrenMap['root-test2'].children).to.have.length(0);
+    expect(root.nodes().map((node) => node.id)).to.deep.equal(['test1', 'test3', 'test2', 'test4']);
 
-    expect(graph.root.childrenMap['root-test1'].children).to.have.length(0);
-    addNode('root-test1', { id: 'root-test1-test2', label: 'root-test1-test2' });
-    expect(graph.root.childrenMap['root-test1'].children).to.have.length(1);
-    expect(graph.root.childrenMap['root-test1'].childrenMap['root-test1-test2'].children).to.have.length(0);
+    graph.sortEdges('root', 'outbound', ['test4', 'test3']);
 
-    expect(graph.root.actions).to.have.length(1);
-    addAction('root', { id: 'root-test2', label: 'root-test2', invoke: () => {} });
-    expect(graph.root.actions).to.have.length(2);
+    expect(root.nodes().map((node) => node.id)).to.deep.equal(['test4', 'test3', 'test1', 'test2']);
+  });
 
-    expect(graph.root.childrenMap['root-test1'].properties).to.not.have.property('test');
-    addProperty('root-test1', 'test', 'test');
-    expect(graph.root.childrenMap['root-test1'].properties.test).to.equal('test');
+  test('remove edge', () => {
+    const graph = new Graph();
 
-    expect(graph.root.children).to.have.length(2);
-    removeNode('root', 'root-test2');
-    expect(graph.root.children).to.have.length(1);
+    graph.addNodes({
+      id: 'root',
+      nodes: [{ id: 'test1' }, { id: 'test2' }],
+    });
+    graph.removeEdge({ source: 'root', target: 'test1' });
 
-    expect(graph.root.childrenMap['root-test1'].children).to.have.length(1);
-    removeNode('root-test1', 'root-test1-test2');
-    expect(graph.root.childrenMap['root-test1'].children).to.have.length(0);
+    expect(graph.root.nodes()).to.have.length(1);
+    expect(graph.findNode('test1')?.nodes({ direction: 'inbound' })).to.be.empty;
+  });
 
-    expect(graph.root.actions).to.have.length(2);
-    removeAction('root', 'root-test2');
-    expect(graph.root.actions).to.have.length(1);
+  test('toJSON', () => {
+    const graph = new Graph();
 
-    expect(graph.root.childrenMap['root-test1'].properties.test).to.equal('test');
-    removeProperty('root-test1', 'test');
-    expect(graph.root.childrenMap['root-test1'].properties).to.not.have.property('test');
-  });
+    graph.addNodes({
+      id: 'root',
+      nodes: [{ id: 'test1' }, { id: 'test2' }],
+    });
+    graph.addEdge({ source: 'test1', target: 'test2' });
 
-  test.skip('node builder unsubscribe is called when builder is re-run', async () => {
-    // TODO(wittjosiah): Implement.
+    const json = graph.toJSON();
+    expect(json).to.deep.equal({
+      id: 'root',
+      nodes: [{ id: 'test1', nodes: [{ id: 'test2' }] }, { id: 'test2' }],
+    });
   });
 
-  test('can find nodes', () => {
-    const builder = new GraphBuilder();
-    builder.addNodeBuilder('test1', createTestNodeBuilder('test1', 2).nodeBuilder);
-    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
+  test('can be traversed', () => {
+    const graph = new Graph();
 
-    const graph = builder.build();
-    expect(graph.findNode('root-test1')?.id).to.equal('root-test1');
-    expect(graph.findNode('root-test2-test1')?.id).to.equal('root-test2-test1');
+    const [root] = graph.addNodes({
+      id: 'root',
+      nodes: [{ id: 'test1' }, { id: 'test2' }],
+    });
+
+    const nodes: string[] = [];
+    graph.traverse({ node: root, visitor: (node) => nodes.push(node.id) });
+    expect(nodes).to.deep.equal(['root', 'test1', 'test2']);
   });
 
-  test('can be traversed', () => {
-    const builder = new GraphBuilder();
-    builder.addNodeBuilder('test1', createTestNodeBuilder('test1', 2).nodeBuilder);
-    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
+  test('traversal breaks cycles', () => {
+    const graph = new Graph();
+
+    const [root] = graph.addNodes({
+      id: 'root',
+      nodes: [{ id: 'test1' }, { id: 'test2' }],
+    });
+    graph.addEdge({ source: 'test1', target: 'root' });
 
-    const graph = builder.build();
     const nodes: string[] = [];
-    graph.traverse({ visitor: (node) => nodes.push(node.id) });
-    expect(nodes).to.deep.equal(['root', 'root-test1', 'root-test2', 'root-test2-test1']);
+    graph.traverse({ node: root, visitor: (node) => nodes.push(node.id) });
+    expect(nodes).to.deep.equal(['root', 'test1', 'test2']);
   });
 
   test('traversal can be limited by predicate', () => {
-    const builder = new GraphBuilder();
-    builder.addNodeBuilder('test1', createTestNodeBuilder('test1', 2).nodeBuilder);
-    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
+    const graph = new Graph();
+
+    const [root] = graph.addNodes({
+      id: 'root',
+      nodes: [{ id: 'test1' }, { id: 'test2' }, { id: 'test3' }, { id: 'test4' }],
+    });
 
-    const graph = builder.build();
     const nodes: string[] = [];
     graph.traverse({
-      filter: (node) => node.id.includes('test1'),
+      node: root,
       visitor: (node) => nodes.push(node.id),
+      filter: (node) => {
+        try {
+          const id = parseInt(node.id.replace('test', ''), 10);
+          return id % 2 === 0;
+        } catch (e) {
+          return false;
+        }
+      },
     });
-    expect(nodes).to.deep.equal(['root-test1', 'root-test2-test1']);
+    expect(nodes).to.deep.equal(['test2', 'test4']);
   });
 
   test('traversal can be started from any node', () => {
-    const builder = new GraphBuilder();
-    builder.addNodeBuilder('test1', createTestNodeBuilder('test1', 2).nodeBuilder);
-    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
+    const graph = new Graph();
+
+    graph.addNodes({
+      id: 'root',
+      nodes: [{ id: 'test1', nodes: [{ id: 'test2', nodes: [{ id: 'test3' }] }] }],
+    });
 
-    const graph = builder.build();
     const nodes: string[] = [];
     graph.traverse({
-      node: graph.root.childrenMap['root-test2'],
+      node: graph.findNode('test2')!,
       visitor: (node) => nodes.push(node.id),
     });
-    expect(nodes).to.deep.equal(['root-test2', 'root-test2-test1']);
+    expect(nodes).to.deep.equal(['test2', 'test3']);
   });
 
-  test('can traverse up', () => {
-    const builder = new GraphBuilder();
-    builder.addNodeBuilder('test1', createTestNodeBuilder('test1', 2).nodeBuilder);
-    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
+  test('traversal can follow inbound edges', () => {
+    const graph = new Graph();
+
+    graph.addNodes({
+      id: 'root',
+      nodes: [{ id: 'test1', nodes: [{ id: 'test2', nodes: [{ id: 'test3' }] }] }],
+    });
 
-    const graph = builder.build();
     const nodes: string[] = [];
     graph.traverse({
-      direction: 'up',
-      node: graph.root.childrenMap['root-test2'].childrenMap['root-test2-test1'],
+      node: graph.findNode('test2')!,
+      direction: 'inbound',
       visitor: (node) => nodes.push(node.id),
     });
-    expect(nodes).to.deep.equal(['root-test2-test1', 'root-test2', 'root']);
+    expect(nodes).to.deep.equal(['test2', 'test1', 'root']);
+  });
+
+  test('can filter to longest pathes', () => {
+    const graph = new Graph();
+
+    graph.addNodes({
+      id: 'root',
+      nodes: [{ id: 'test1' }, { id: 'test2' }],
+    });
+    graph.addEdge({ source: 'test1', target: 'test2' });
+
+    graph.traverse({
+      visitor: (node, path) => {
+        if (!longestPaths.has(node.id) || longestPaths.get(node.id)!.length < path.length) {
+          longestPaths.set(node.id, path);
+        }
+      },
+    });
+
+    expect(longestPaths.get('root')).to.deep.equal(['root']);
+    expect(longestPaths.get('test1')).to.deep.equal(['root', 'test1']);
+    expect(longestPaths.get('test2')).to.deep.equal(['root', 'test1', 'test2']);
+    expect(graph.root.nodes({ filter: filterLongestPath })).to.have.length(1);
+    expect(graph.findNode('test1')?.nodes({ filter: filterLongestPath })).to.have.length(1);
+    expect(graph.findNode('test2')?.nodes({ filter: filterLongestPath })).to.be.empty;
+
+    longestPaths.clear();
+  });
+
+  test('traversing the graph subscribes to changes', () => {
+    const graph = new Graph();
+
+    graph.addNodes({
+      id: 'root',
+      nodes: [{ id: 'test1' }, { id: 'test2' }],
+    });
+
+    const dispose = effect(() => {
+      graph.traverse({
+        visitor: (node, path) => {
+          if (!longestPaths.has(node.id) || longestPaths.get(node.id)!.length < path.length) {
+            longestPaths.set(node.id, path);
+          }
+        },
+      });
+    });
+
+    expect(longestPaths.get('root')).to.deep.equal(['root']);
+    expect(longestPaths.get('test1')).to.deep.equal(['root', 'test1']);
+    expect(longestPaths.get('test2')).to.deep.equal(['root', 'test2']);
+    expect(graph.root.nodes({ filter: filterLongestPath })).to.have.length(2);
+    expect(graph.findNode('test1')?.nodes({ filter: filterLongestPath })).to.be.empty;
+    expect(graph.findNode('test2')?.nodes({ filter: filterLongestPath })).to.be.empty;
+
+    graph.addEdge({ source: 'test1', target: 'test2' });
+
+    expect(longestPaths.get('root')).to.deep.equal(['root']);
+    expect(longestPaths.get('test1')).to.deep.equal(['root', 'test1']);
+    expect(longestPaths.get('test2')).to.deep.equal(['root', 'test1', 'test2']);
+    expect(graph.root.nodes({ filter: filterLongestPath })).to.have.length(1);
+    expect(graph.findNode('test1')?.nodes({ filter: filterLongestPath })).to.have.length(1);
+    expect(graph.findNode('test2')?.nodes({ filter: filterLongestPath })).to.be.empty;
+
+    dispose();
+    longestPaths.clear();
+  });
+
+  test('get path', () => {
+    const graph = new Graph();
+
+    graph.addNodes({
+      id: 'root',
+      nodes: [{ id: 'test1' }, { id: 'test2' }],
+    });
+    graph.addEdge({ source: 'test1', target: 'test2' });
+
+    expect(graph.getPath({ target: 'test2' })).to.deep.equal(['root', 'test1', 'test2']);
+    expect(graph.getPath({ source: 'test1', target: 'test2' })).to.deep.equal(['test1', 'test2']);
+    expect(graph.getPath({ source: 'test2', target: 'test1' })).to.be.undefined;
   });
 });