@dxos/graph 0.8.4-main.7ace549 → 0.8.4-main.937b3ca

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@dxos/graph",
-  "version": "0.8.4-main.7ace549",
+  "version": "0.8.4-main.937b3ca",
   "description": "Low-level graph API",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
   "license": "MIT",
   "author": "DXOS.org",
-  "sideEffects": true,
+  "sideEffects": false,
   "type": "module",
   "exports": {
     ".": {
@@ -25,23 +29,21 @@
     "src"
   ],
   "dependencies": {
-    "@preact/signals-core": "^1.12.1",
-    "effect": "3.18.3",
-    "@dxos/async": "0.8.4-main.7ace549",
-    "@dxos/debug": "0.8.4-main.7ace549",
-    "@dxos/echo-signals": "0.8.4-main.7ace549",
-    "@dxos/invariant": "0.8.4-main.7ace549",
-    "@dxos/log": "0.8.4-main.7ace549",
-    "@dxos/util": "0.8.4-main.7ace549",
-    "@dxos/live-object": "0.8.4-main.7ace549"
+    "@effect-atom/atom-react": "^0.4.6",
+    "@dxos/async": "0.8.4-main.937b3ca",
+    "@dxos/debug": "0.8.4-main.937b3ca",
+    "@dxos/invariant": "0.8.4-main.937b3ca",
+    "@dxos/util": "0.8.4-main.937b3ca",
+    "@dxos/log": "0.8.4-main.937b3ca"
   },
   "devDependencies": {
-    "@dxos/echo": "0.8.4-main.7ace549",
-    "@dxos/echo-db": "0.8.4-main.7ace549",
-    "@dxos/random": "0.8.4-main.7ace549"
+    "effect": "3.19.11",
+    "@dxos/echo-db": "0.8.4-main.937b3ca",
+    "@dxos/echo": "0.8.4-main.937b3ca",
+    "@dxos/random": "0.8.4-main.937b3ca"
   },
   "peerDependencies": {
-    "effect": "^3.13.3"
+    "effect": "3.19.11"
   },
   "publishConfig": {
     "access": "public"

package/src/Graph.ts

@@ -0,0 +1,81 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { invariant } from '@dxos/invariant';
+import { type Specialize } from '@dxos/util';
+
+//
+// Node
+//
+
+export const Node = Schema.Struct({
+  id: Schema.String,
+  type: Schema.optional(Schema.String),
+  data: Schema.optional(Schema.Any),
+});
+
+interface BaseNode extends Schema.Schema.Type<typeof Node> {}
+
+export declare namespace Node {
+  export type Any = Specialize<BaseNode, { data?: any }>;
+  export type Node<Data = any> = Specialize<BaseNode, { data: Data }>;
+}
+
+//
+// Edge
+//
+
+export const Edge = Schema.Struct({
+  id: Schema.String,
+  type: Schema.optional(Schema.String),
+  source: Schema.String,
+  target: Schema.String,
+  data: Schema.optional(Schema.Any),
+});
+
+interface BaseEdge extends Schema.Schema.Type<typeof Edge> {}
+
+export declare namespace Edge {
+  export type Any = Specialize<BaseEdge, { data?: any }>;
+  export type Edge<Data = any> = Specialize<BaseEdge, { data: Data }>;
+}
+
+const KEY_REGEX = /\w+/;
+
+// NOTE: The `relation` is different from the `type`.
+type EdgeMeta = { source: string; target: string; relation?: string };
+
+export const createEdgeId = ({ source, target, relation }: EdgeMeta) => {
+  invariant(source.match(KEY_REGEX), `invalid source: ${source}`);
+  invariant(target.match(KEY_REGEX), `invalid target: ${target}`);
+  return [source, relation, target].join('_');
+};
+
+export const parseEdgeId = (id: string): EdgeMeta => {
+  const [source, relation, target] = id.split('_');
+  invariant(source.length && target.length);
+  return { source, relation: relation.length ? relation : undefined, target };
+};
+
+//
+// Graph
+//
+
+export const Graph = Schema.Struct({
+  id: Schema.optional(Schema.String),
+  nodes: Schema.mutable(Schema.Array(Node)),
+  edges: Schema.mutable(Schema.Array(Edge)),
+});
+
+export interface Any extends Schema.Schema.Type<typeof Graph> {}
+
+export type Graph<Node extends Node.Any, Edge extends Edge.Any> = Specialize<
+  Any,
+  {
+    nodes: Node[];
+    edges: Edge[];
+  }
+>;

package/src/GraphModel.test.ts

@@ -0,0 +1,265 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Registry } from '@effect-atom/atom-react';
+import * as Schema from 'effect/Schema';
+import { describe, test } from 'vitest';
+
+import { Trigger } from '@dxos/async';
+
+import * as Graph from './Graph';
+import * as GraphModel from './GraphModel';
+
+// Create a registry for tests.
+const createRegistry = () => Registry.make();
+
+const TestNode = Schema.extend(
+  Graph.Node,
+  Schema.Struct({
+    value: Schema.String,
+  }),
+);
+
+type TestNode = Schema.Schema.Type<typeof TestNode>;
+
+type TestData = { value: string };
+
+describe('Graph', () => {
+  test('empty', ({ expect }) => {
+    const graph = new GraphModel.GraphModel();
+    expect(graph.nodes).to.have.length(0);
+    expect(graph.edges).to.have.length(0);
+    expect(graph.toJSON()).to.deep.eq({ nodes: 0, edges: 0 });
+  });
+
+  test('extended', ({ expect }) => {
+    const graph = new GraphModel.GraphModel<TestNode>();
+    const node = graph.addNode({ id: 'test', value: 'test' });
+    expect(node.value.length).to.eq(4);
+  });
+
+  test('reactive model', async ({ expect }) => {
+    const registry = createRegistry();
+    const graph = new GraphModel.ReactiveGraphModel(registry);
+
+    const done = new Trigger<Graph.Any>();
+    const unsubscribe = graph.subscribe((model, g) => {
+      if (g.edges.length === 2) {
+        done.wake(g);
+      }
+    });
+
+    setTimeout(() => {
+      graph.addNode({ id: 'node-1' });
+      graph.addNode({ id: 'node-2' });
+      graph.addNode({ id: 'node-3' });
+    });
+
+    setTimeout(() => {
+      graph.addEdge({ source: 'node-1', target: 'node-2' });
+      graph.addEdge({ source: 'node-2', target: 'node-3' });
+    });
+
+    {
+      const g = await done.wait();
+      expect(g.nodes).to.have.length(3);
+      expect(g.edges).to.have.length(2);
+    }
+
+    unsubscribe();
+  });
+
+  test('reactive model fires immediately with fire option', ({ expect }) => {
+    const registry = createRegistry();
+    const graph = new GraphModel.ReactiveGraphModel(registry);
+    graph.addNode({ id: 'node-1' });
+
+    let callCount = 0;
+    let lastNodeCount = 0;
+
+    const unsubscribe = graph.subscribe(
+      (model) => {
+        callCount++;
+        lastNodeCount = model.nodes.length;
+      },
+      true, // fire immediately
+    );
+
+    // Should fire once immediately with fire option.
+    expect(callCount).to.eq(1);
+    expect(lastNodeCount).to.eq(1);
+
+    unsubscribe();
+  });
+
+  test('reactive model tracks node additions', ({ expect }) => {
+    const registry = createRegistry();
+    const graph = new GraphModel.ReactiveGraphModel(registry);
+
+    const nodeCountHistory: number[] = [];
+    const unsubscribe = graph.subscribe((model) => {
+      nodeCountHistory.push(model.nodes.length);
+    });
+
+    graph.addNode({ id: 'node-1' });
+    graph.addNode({ id: 'node-2' });
+    graph.addNode({ id: 'node-3' });
+
+    // Should have tracked the additions synchronously.
+    expect(nodeCountHistory).to.deep.eq([1, 2, 3]);
+
+    unsubscribe();
+  });
+
+  test('reactive model tracks node removals', ({ expect }) => {
+    const registry = createRegistry();
+    const graph = new GraphModel.ReactiveGraphModel(registry);
+    graph.addNode({ id: 'node-1' });
+    graph.addNode({ id: 'node-2' });
+    graph.addNode({ id: 'node-3' });
+
+    const nodeCountHistory: number[] = [];
+    const unsubscribe = graph.subscribe((model) => {
+      nodeCountHistory.push(model.nodes.length);
+    }, true);
+
+    expect(nodeCountHistory[0]).to.eq(3);
+
+    graph.removeNode('node-2');
+
+    expect(nodeCountHistory[nodeCountHistory.length - 1]).to.eq(2);
+
+    unsubscribe();
+  });
+
+  test('reactive model unsubscribe stops notifications', ({ expect }) => {
+    const registry = createRegistry();
+    const graph = new GraphModel.ReactiveGraphModel(registry);
+
+    let callCount = 0;
+    const unsubscribe = graph.subscribe(() => {
+      callCount++;
+    });
+
+    graph.addNode({ id: 'node-1' });
+
+    const countAfterFirstAdd = callCount;
+    expect(countAfterFirstAdd).to.eq(1);
+
+    unsubscribe();
+
+    graph.addNode({ id: 'node-2' });
+
+    // Should not have received more notifications after unsubscribe.
+    expect(callCount).to.eq(countAfterFirstAdd);
+  });
+
+  test('reactive model supports multiple subscribers', ({ expect }) => {
+    const registry = createRegistry();
+    const graph = new GraphModel.ReactiveGraphModel(registry);
+
+    let subscriber1Count = 0;
+    let subscriber2Count = 0;
+
+    const unsub1 = graph.subscribe(() => {
+      subscriber1Count++;
+    });
+
+    const unsub2 = graph.subscribe(() => {
+      subscriber2Count++;
+    });
+
+    graph.addNode({ id: 'node-1' });
+
+    expect(subscriber1Count).to.eq(1);
+    expect(subscriber2Count).to.eq(1);
+
+    unsub1();
+    unsub2();
+  });
+
+  test('optional', ({ expect }) => {
+    {
+      const graph = new GraphModel.GraphModel<Graph.Node.Node<string>>();
+      const node = graph.addNode({ id: 'test', data: 'test' });
+      expect(node.data.length).to.eq(4);
+    }
+
+    {
+      const graph = new GraphModel.GraphModel<Graph.Node.Any>();
+      const node = graph.addNode({ id: 'test' });
+      expect(node.data?.length).to.be.undefined;
+    }
+  });
+
+  test('add and remove subgraphs', ({ expect }) => {
+    const graph = new GraphModel.GraphModel<Graph.Node.Node<TestData>>();
+    graph.builder
+      .addNode({ id: 'node1', data: { value: 'test' } })
+      .addNode({ id: 'node2', data: { value: 'test' } })
+      .addNode({ id: 'node3', data: { value: 'test' } })
+      .addEdge({ source: 'node1', target: 'node2' })
+      .addEdge({ source: 'node2', target: 'node3' });
+    expect(graph.nodes).to.have.length(3);
+    expect(graph.edges).to.have.length(2);
+    const pre = graph.toJSON();
+
+    const node = graph.findNode('node2');
+    expect(node).to.exist;
+
+    const removed = graph.removeNode('node2');
+    expect(removed.nodes).to.have.length(1);
+    expect(removed.edges).to.have.length(2);
+    expect(graph.nodes).to.have.length(2);
+    expect(graph.edges).to.have.length(0);
+
+    graph.addGraph(removed);
+    const post = graph.toJSON();
+    expect(pre).to.deep.eq(post);
+
+    graph.clear();
+    expect(graph.nodes).to.have.length(0);
+    expect(graph.edges).to.have.length(0);
+  });
+
+  test('traverse', ({ expect }) => {
+    const graph = new GraphModel.GraphModel();
+    graph.builder
+      .addNode({ id: 'a' })
+      .addNode({ id: 'b' })
+      .addNode({ id: 'c' })
+      .addNode({ id: 'd' })
+      .addNode({ id: 'e' })
+      .addNode({ id: 'f' })
+      .addNode({ id: 'g' })
+      .addNode({ id: 'h' })
+      // Sub-graph 1.
+      .addEdge({ source: 'a', target: 'b' })
+      .addEdge({ source: 'a', target: 'c' })
+      .addEdge({ source: 'c', target: 'd' })
+      .addEdge({ source: 'd', target: 'e' })
+      .addEdge({ source: 'd', target: 'a' })
+      // Sub-graph 2.
+      .addEdge({ source: 'f', target: 'g' })
+      .addEdge({ source: 'g', target: 'h' });
+
+    const count = graph.nodes.length;
+
+    {
+      // Sub-graph 1.
+      const nodes = graph.traverse(graph.getNode('a'));
+      expect(nodes).to.have.length(5);
+    }
+
+    {
+      // Sub-graph 2.
+      const nodes = graph.traverse(graph.getNode('f'));
+      expect(nodes).to.have.length(3);
+
+      // Remove sub-graph.
+      graph.removeNodes(nodes.map((node) => node.id));
+      expect(graph.nodes).to.have.length(count - 3);
+    }
+  });
+});