@dxos/app-graph 0.8.4-main.bc674ce → 0.8.4-main.bcb3aa67d6

package/src/graph.test.ts

@@ -12,7 +12,11 @@ import * as Node from './node';
 
 const exampleId = (id: number) => `dx:test:${id}`;
 const EXAMPLE_ID = exampleId(1);
-const EXAMPLE_TYPE = 'dxos.org/type/example';
+const EXAMPLE_TYPE = 'org.dxos.type.example';
+const CHILD_RELATION_KEY = Graph.relationKey('child');
+const CHILD_INBOUND_RELATION_KEY = Graph.relationKey(Node.childRelation('inbound'));
+const ACTIONS_RELATION_KEY = Graph.relationKey('action');
+const ACTIONS_INBOUND_RELATION_KEY = Graph.relationKey(Node.actionRelation('inbound'));
 
 describe('Graph', () => {
   test('getGraph', () => {
@@ -100,6 +104,39 @@ describe('Graph', () => {
     }
   });
 
+  test('remove node with edges=true removes default inbound counterparts', () => {
+    const registry = Registry.make();
+    const graph = Graph.make({ registry });
+    Graph.addNode(graph, { id: exampleId(1), type: EXAMPLE_TYPE });
+    Graph.addNode(graph, { id: exampleId(2), type: EXAMPLE_TYPE });
+    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2), relation: 'child' });
+
+    Graph.removeNode(graph, exampleId(2), true);
+
+    const sourceEdges = registry.get(graph.edges(exampleId(1)));
+    expect(sourceEdges[CHILD_RELATION_KEY]).toEqual([]);
+    expect(sourceEdges[CHILD_INBOUND_RELATION_KEY]).toBeUndefined();
+  });
+
+  test('remove node with edges=true removes typed inbound and outbound counterparts', () => {
+    const registry = Registry.make();
+    const graph = Graph.make({ registry });
+    Graph.addNode(graph, { id: exampleId(1), type: EXAMPLE_TYPE });
+    Graph.addNode(graph, { id: exampleId(2), type: EXAMPLE_TYPE });
+    Graph.addNode(graph, { id: exampleId(3), type: EXAMPLE_TYPE });
+    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2), relation: 'action' });
+    Graph.addEdge(graph, { source: exampleId(2), target: exampleId(3), relation: 'action' });
+
+    Graph.removeNode(graph, exampleId(2), true);
+
+    const sourceEdges = registry.get(graph.edges(exampleId(1)));
+    const targetEdges = registry.get(graph.edges(exampleId(3)));
+    expect(sourceEdges[ACTIONS_RELATION_KEY]).toEqual([]);
+    expect(sourceEdges[ACTIONS_INBOUND_RELATION_KEY]).toBeUndefined();
+    expect(targetEdges[ACTIONS_RELATION_KEY]).toBeUndefined();
+    expect(targetEdges[ACTIONS_INBOUND_RELATION_KEY]).toEqual([]);
+  });
+
   test('remove node curried', () => {
     const registry = Registry.make();
     const graph = Graph.make({ registry });
@@ -130,20 +167,29 @@ describe('Graph', () => {
   test('add edge', () => {
     const registry = Registry.make();
     const graph = Graph.make({ registry });
-    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2) });
-    const edges = registry.get(graph.edges(exampleId(1)));
-    expect(edges.inbound).toEqual([]);
-    expect(edges.outbound).toEqual([exampleId(2)]);
+    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2), relation: 'child' });
+
+    {
+      const edges = registry.get(graph.edges(exampleId(1)));
+      expect(edges[CHILD_INBOUND_RELATION_KEY]).toBeUndefined();
+      expect(edges[CHILD_RELATION_KEY]).toEqual([exampleId(2)]);
+    }
+
+    {
+      const edges = registry.get(graph.edges(exampleId(2)));
+      expect(edges[CHILD_INBOUND_RELATION_KEY]).toEqual([exampleId(1)]);
+      expect(edges[CHILD_RELATION_KEY]).toBeUndefined();
+    }
   });
 
   test('add edges is idempotent', () => {
     const registry = Registry.make();
     const graph = Graph.make({ registry });
-    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2) });
-    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2) });
+    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2), relation: 'child' });
+    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2), relation: 'child' });
     const edges = registry.get(graph.edges(exampleId(1)));
-    expect(edges.inbound).toEqual([]);
-    expect(edges.outbound).toEqual([exampleId(2)]);
+    expect(edges[CHILD_INBOUND_RELATION_KEY]).toBeUndefined();
+    expect(edges[CHILD_RELATION_KEY]).toEqual([exampleId(2)]);
   });
 
   test('sort edges', () => {
@@ -151,17 +197,17 @@ describe('Graph', () => {
     const graph = Graph.make({ registry });
 
     {
-      Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2) });
-      Graph.addEdge(graph, { source: exampleId(1), target: exampleId(3) });
-      Graph.addEdge(graph, { source: exampleId(1), target: exampleId(4) });
+      Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2), relation: 'child' });
+      Graph.addEdge(graph, { source: exampleId(1), target: exampleId(3), relation: 'child' });
+      Graph.addEdge(graph, { source: exampleId(1), target: exampleId(4), relation: 'child' });
       const edges = registry.get(graph.edges(exampleId(1)));
-      expect(edges.outbound).toEqual([exampleId(2), exampleId(3), exampleId(4)]);
+      expect(edges[CHILD_RELATION_KEY]).toEqual([exampleId(2), exampleId(3), exampleId(4)]);
     }
 
     {
-      Graph.sortEdges(graph, exampleId(1), 'outbound', [exampleId(3), exampleId(2)]);
+      Graph.sortEdges(graph, exampleId(1), 'child', [exampleId(3), exampleId(2)]);
       const edges = registry.get(graph.edges(exampleId(1)));
-      expect(edges.outbound).toEqual([exampleId(3), exampleId(2), exampleId(4)]);
+      expect(edges[CHILD_RELATION_KEY]).toEqual([exampleId(3), exampleId(2), exampleId(4)]);
     }
   });
 
@@ -170,17 +216,17 @@ describe('Graph', () => {
     const graph = Graph.make({ registry });
 
     {
-      Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2) });
+      Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2), relation: 'child' });
       const edges = registry.get(graph.edges(exampleId(1)));
-      expect(edges.inbound).toEqual([]);
-      expect(edges.outbound).toEqual([exampleId(2)]);
+      expect(edges[CHILD_INBOUND_RELATION_KEY]).toBeUndefined();
+      expect(edges[CHILD_RELATION_KEY]).toEqual([exampleId(2)]);
     }
 
     {
-      Graph.removeEdge(graph, { source: exampleId(1), target: exampleId(2) });
+      Graph.removeEdge(graph, { source: exampleId(1), target: exampleId(2), relation: 'child' });
       const edges = registry.get(graph.edges(exampleId(1)));
-      expect(edges.inbound).toEqual([]);
-      expect(edges.outbound).toEqual([]);
+      expect(edges[CHILD_INBOUND_RELATION_KEY]).toBeUndefined();
+      expect(edges[CHILD_RELATION_KEY]).toEqual([]);
     }
   });
 
@@ -189,12 +235,42 @@ describe('Graph', () => {
     const graph = Graph.make({ registry });
     Graph.addNode(graph, { id: exampleId(1), type: EXAMPLE_TYPE });
     Graph.addNode(graph, { id: exampleId(2), type: EXAMPLE_TYPE });
-    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2) });
-    const result = graph.pipe(Graph.removeEdge({ source: exampleId(1), target: exampleId(2) }));
+    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2), relation: 'child' });
+    const result = graph.pipe(Graph.removeEdge({ source: exampleId(1), target: exampleId(2), relation: 'child' }));
     expect(result).toEqual(graph);
     const edges = registry.get(graph.edges(exampleId(1)));
-    expect(edges.inbound).toEqual([]);
-    expect(edges.outbound).toEqual([]);
+    expect(edges[CHILD_INBOUND_RELATION_KEY]).toBeUndefined();
+    expect(edges[CHILD_RELATION_KEY]).toEqual([]);
+  });
+
+  test('add edge with custom relation creates typed inbound inverse', () => {
+    const registry = Registry.make();
+    const graph = Graph.make({ registry });
+    Graph.addNode(graph, { id: exampleId(1), type: EXAMPLE_TYPE });
+    Graph.addNode(graph, { id: exampleId(2), type: EXAMPLE_TYPE });
+    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2), relation: 'action' });
+    const sourceEdges = registry.get(graph.edges(exampleId(1)));
+    expect(sourceEdges[ACTIONS_RELATION_KEY]).toEqual([exampleId(2)]);
+    expect(sourceEdges[CHILD_RELATION_KEY]).toBeUndefined();
+    const targetEdges = registry.get(graph.edges(exampleId(2)));
+    expect(targetEdges[CHILD_INBOUND_RELATION_KEY]).toBeUndefined();
+    expect(targetEdges[ACTIONS_INBOUND_RELATION_KEY]).toEqual([exampleId(1)]);
+    const reverseConnections = registry.get(graph.connections(exampleId(2), Node.actionRelation('inbound')));
+    expect(reverseConnections.map(({ id }) => id)).toEqual([exampleId(1)]);
+  });
+
+  test('remove edge with custom relation removes typed inbound inverse', () => {
+    const registry = Registry.make();
+    const graph = Graph.make({ registry });
+    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2), relation: 'action' });
+    Graph.removeEdge(graph, { source: exampleId(1), target: exampleId(2), relation: 'action' });
+    const sourceEdges = registry.get(graph.edges(exampleId(1)));
+    expect(sourceEdges[ACTIONS_RELATION_KEY]).toEqual([]);
+    const targetEdges = registry.get(graph.edges(exampleId(2)));
+    expect(targetEdges[CHILD_INBOUND_RELATION_KEY]).toBeUndefined();
+    expect(targetEdges[CHILD_RELATION_KEY]).toBeUndefined();
+    expect(targetEdges[ACTIONS_RELATION_KEY]).toBeUndefined();
+    expect(targetEdges[ACTIONS_INBOUND_RELATION_KEY]).toEqual([]);
   });
 
   test('get connections', () => {
@@ -202,8 +278,8 @@ describe('Graph', () => {
     const graph = Graph.make({ registry });
     Graph.addNode(graph, { id: exampleId(1), type: EXAMPLE_TYPE });
     Graph.addNode(graph, { id: exampleId(2), type: EXAMPLE_TYPE });
-    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2) });
-    const nodes = registry.get(graph.connections(exampleId(1)));
+    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2), relation: 'child' });
+    const nodes = registry.get(graph.connections(exampleId(1), 'child'));
     expect(nodes).has.length(1);
     expect(nodes[0].id).toEqual(exampleId(2));
   });
@@ -228,8 +304,8 @@ describe('Graph', () => {
   test('connections updates', () => {
     const registry = Registry.make();
     const graph = Graph.make({ registry });
-    assert.strictEqual(graph.connections(exampleId(1)), graph.connections(exampleId(1)));
-    const childrenKey = graph.connections(exampleId(1));
+    assert.strictEqual(graph.connections(exampleId(1), 'child'), graph.connections(exampleId(1), 'child'));
+    const childrenKey = graph.connections(exampleId(1), 'child');
 
     let count = 0;
     const cancel = registry.subscribe(childrenKey, (_) => {
@@ -240,7 +316,7 @@ describe('Graph', () => {
     graph.pipe(
       Graph.addNode({ id: exampleId(1), type: EXAMPLE_TYPE }),
       Graph.addNode({ id: exampleId(2), type: EXAMPLE_TYPE }),
-      Graph.addEdge({ source: exampleId(1), target: exampleId(2) }),
+      Graph.addEdge({ source: exampleId(1), target: exampleId(2), relation: 'child' }),
     );
 
     expect(count).toEqual(0);
@@ -262,12 +338,12 @@ describe('Graph', () => {
     expect(count).toEqual(2);
 
     // Connecting a node fires an update.
-    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(3) });
+    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(3), relation: 'child' });
     expect(count).toEqual(3);
 
     // Adding an edge connected to nothing fires an update.
     // TODO(wittjosiah): Is there a way to avoid this?
-    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(4) });
+    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(4), relation: 'child' });
     expect(count).toEqual(4);
 
     // Adding a node to an existing edge fires an update.
@@ -277,7 +353,7 @@ describe('Graph', () => {
     // Batching the edge and node updates fires a single update.
     Atom.batch(() => {
       graph.pipe(
-        Graph.addEdge({ source: exampleId(1), target: exampleId(6) }),
+        Graph.addEdge({ source: exampleId(1), target: exampleId(6), relation: 'child' }),
         Graph.addNode({ id: exampleId(6), type: EXAMPLE_TYPE }),
       );
     });
@@ -295,7 +371,7 @@ describe('Graph', () => {
         { id: 'test2', type: 'test' },
       ],
     });
-    Graph.addEdge(graph, { source: 'test1', target: 'test2' });
+    Graph.addEdge(graph, { source: 'test1', target: 'test2', relation: 'child' });
 
     const json = Graph.toJSON(graph);
     expect(json).to.deep.equal({
@@ -320,7 +396,7 @@ describe('Graph', () => {
         { id: 'test2', type: 'test' },
       ],
     });
-    Graph.addEdge(graph, { source: 'test1', target: 'test2' });
+    Graph.addEdge(graph, { source: 'test1', target: 'test2', relation: 'child' });
 
     let json: any;
     const cancel = registry.subscribe(graph.json(), (_) => {
@@ -339,7 +415,7 @@ describe('Graph', () => {
     });
 
     Graph.addNode(graph, { id: 'test3', type: 'test' });
-    Graph.addEdge(graph, { source: 'root', target: 'test3' });
+    Graph.addEdge(graph, { source: 'root', target: 'test3', relation: 'child' });
     expect(json).to.deep.equal({
       id: Node.RootId,
       type: Node.RootType,
@@ -361,7 +437,7 @@ describe('Graph', () => {
         { id: exampleId(2), type: EXAMPLE_TYPE },
       ],
     });
-    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2) });
+    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2), relation: 'child' });
 
     expect(Graph.getPath(graph, { target: exampleId(2) }).pipe(Option.getOrNull)).to.deep.equal([
       'root',
@@ -385,7 +461,7 @@ describe('Graph', () => {
         { id: exampleId(2), type: EXAMPLE_TYPE },
       ],
     });
-    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2) });
+    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2), relation: 'child' });
     const path = graph.pipe(Graph.getPath({ target: exampleId(2) }));
     expect(path.pipe(Option.getOrNull)).to.deep.equal(['root', exampleId(1), exampleId(2)]);
   });
@@ -404,6 +480,7 @@ describe('Graph', () => {
 
       const nodes: string[] = [];
       Graph.traverse(graph, {
+        relation: 'child',
         visitor: (node) => {
           nodes.push(node.id);
         },
@@ -421,10 +498,11 @@ describe('Graph', () => {
           { id: 'test2', type: 'test' },
         ],
       });
-      Graph.addEdge(graph, { source: 'test1', target: 'root' });
+      Graph.addEdge(graph, { source: 'test1', target: 'root', relation: 'child' });
 
       const nodes: string[] = [];
       Graph.traverse(graph, {
+        relation: 'child',
         visitor: (node) => {
           nodes.push(node.id);
         },
@@ -449,6 +527,7 @@ describe('Graph', () => {
       const nodes: string[] = [];
       Graph.traverse(graph, {
         source: 'test2',
+        relation: 'child',
         visitor: (node) => {
           nodes.push(node.id);
         },
@@ -473,7 +552,7 @@ describe('Graph', () => {
       const nodes: string[] = [];
       Graph.traverse(graph, {
         source: 'test2',
-        relation: 'inbound',
+        relation: Node.childRelation('inbound'),
         visitor: (node) => {
           nodes.push(node.id);
         },
@@ -481,6 +560,23 @@ describe('Graph', () => {
       expect(nodes).to.deep.equal(['test2', 'test1', 'root']);
     });
 
+    test('traversal can follow typed inbound edges', () => {
+      const graph = Graph.make();
+      Graph.addNode(graph, { id: 'host', type: 'test' });
+      Graph.addNode(graph, { id: 'action', type: 'test' });
+      Graph.addEdge(graph, { source: 'host', target: 'action', relation: 'action' });
+
+      const nodes: string[] = [];
+      Graph.traverse(graph, {
+        source: 'action',
+        relation: Node.actionRelation('inbound'),
+        visitor: (node) => {
+          nodes.push(node.id);
+        },
+      });
+      expect(nodes).to.deep.equal(['action', 'host']);
+    });
+
     test('traversal can be terminated early', () => {
       const graph = Graph.make();
       Graph.addNode(graph, {
@@ -494,6 +590,7 @@ describe('Graph', () => {
 
       const nodes: string[] = [];
       Graph.traverse(graph, {
+        relation: 'child',
         visitor: (node) => {
           if (nodes.length === 2) {
             return false;
@@ -505,6 +602,26 @@ describe('Graph', () => {
       expect(nodes).to.deep.equal(['root', 'test1']);
     });
 
+    test('traversal with multiple relations follows all edge types', () => {
+      const graph = Graph.make();
+      Graph.addNode(graph, {
+        id: Node.RootId,
+        type: Node.RootType,
+        nodes: [{ id: 'child1', type: 'test' }],
+      });
+      Graph.addNode(graph, { id: 'action1', type: Node.ActionType });
+      Graph.addEdge(graph, { source: Node.RootId, target: 'action1', relation: 'action' });
+
+      const nodes: string[] = [];
+      Graph.traverse(graph, {
+        relation: ['child', 'action'],
+        visitor: (node) => {
+          nodes.push(node.id);
+        },
+      });
+      expect(nodes).to.deep.equal(['root', 'child1', 'action1']);
+    });
+
     test('traverse curried', () => {
       const graph = Graph.make();
       Graph.addNode(graph, {
@@ -513,11 +630,12 @@ describe('Graph', () => {
         nodes: [{ id: 'test1', type: 'test' }],
       });
       Graph.addNode(graph, { id: 'test2', type: 'test' });
-      Graph.addEdge(graph, { source: 'test1', target: 'test2' });
+      Graph.addEdge(graph, { source: 'test1', target: 'test2', relation: 'child' });
       const nodes: string[] = [];
       graph.pipe(
         Graph.traverse({
           source: Node.RootId,
+          relation: 'child',
           visitor: (node, _path) => {
             nodes.push(node.id);
           },
@@ -553,15 +671,15 @@ describe('Graph', () => {
     Graph.addNode(graph, { id: exampleId(3), type: EXAMPLE_TYPE });
     const result = graph.pipe(
       Graph.addEdges([
-        { source: exampleId(1), target: exampleId(2) },
-        { source: exampleId(1), target: exampleId(3) },
+        { source: exampleId(1), target: exampleId(2), relation: 'child' },
+        { source: exampleId(1), target: exampleId(3), relation: 'child' },
       ]),
     );
     expect(result).toEqual(graph);
     const edges = registry.get(graph.edges(exampleId(1)));
-    expect(edges.outbound).to.have.length(2);
-    expect(edges.outbound).to.include(exampleId(2));
-    expect(edges.outbound).to.include(exampleId(3));
+    expect(edges[CHILD_RELATION_KEY]).to.have.length(2);
+    expect(edges[CHILD_RELATION_KEY]).to.include(exampleId(2));
+    expect(edges[CHILD_RELATION_KEY]).to.include(exampleId(3));
   });
 
   test('remove nodes curried', () => {
@@ -583,17 +701,17 @@ describe('Graph', () => {
     Graph.addNode(graph, { id: exampleId(1), type: EXAMPLE_TYPE });
     Graph.addNode(graph, { id: exampleId(2), type: EXAMPLE_TYPE });
     Graph.addNode(graph, { id: exampleId(3), type: EXAMPLE_TYPE });
-    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2) });
-    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(3) });
+    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(2), relation: 'child' });
+    Graph.addEdge(graph, { source: exampleId(1), target: exampleId(3), relation: 'child' });
     const result = graph.pipe(
       Graph.removeEdges([
-        { source: exampleId(1), target: exampleId(2) },
-        { source: exampleId(1), target: exampleId(3) },
+        { source: exampleId(1), target: exampleId(2), relation: 'child' },
+        { source: exampleId(1), target: exampleId(3), relation: 'child' },
       ]),
     );
     expect(result).toEqual(graph);
     const edges = registry.get(graph.edges(exampleId(1)));
-    expect(edges.outbound).to.have.length(0);
+    expect(edges[CHILD_RELATION_KEY]).to.have.length(0);
   });
 
   test('expand curried', async () => {
@@ -611,10 +729,27 @@ describe('Graph', () => {
         },
       }),
     );
-    await graph.pipe(Graph.expand(Node.RootId));
+    await graph.pipe(Graph.expand(Node.RootId, 'child'));
     expect(expandCalled).to.be.true;
   });
 
+  test('expand defers for non-existent node and applies when node is added', () => {
+    const registry = Registry.make();
+    const expandCalls: [string, Node.Relation][] = [];
+    const graph = Graph.make({
+      registry,
+      onExpand: (id, relation) => expandCalls.push([id, relation]),
+    });
+    const childId = 'child';
+    expect(Option.isNone(registry.get(graph.node(childId)))).to.be.true;
+
+    Graph.expand(graph, childId, 'child');
+    expect(expandCalls).to.deep.equal([]);
+
+    Graph.addNode(graph, { id: childId, type: EXAMPLE_TYPE });
+    expect(expandCalls).to.deep.equal([[childId, Node.childRelation()]]);
+  });
+
   test('initialize curried', async () => {
     const registry = Registry.make();
     const builder = GraphBuilder.make({ registry });