@dxos/graph 0.7.5-main.499c70c

package/src/graph.ts

@@ -0,0 +1,127 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { create } from '@dxos/live-object';
+
+import { Graph, type GraphNode, type GraphEdge } from './types';
+import { removeElements } from './util';
+
+// TODO(burdon): Traversal/visitor.
+
+/**
+ * Typed reactive object graph.
+ */
+export class ReadonlyGraphModel<Node extends GraphNode = any, Edge extends GraphEdge = any> {
+  protected readonly _graph: Graph;
+
+  constructor({ nodes = [], edges = [] }: Partial<Graph> = {}) {
+    this._graph = create(Graph, { nodes, edges });
+  }
+
+  toJSON() {
+    // Sort to enable stable comparisons.
+    this._graph.nodes.sort(({ id: a }, { id: b }) => a.localeCompare(b));
+    this._graph.edges.sort(({ id: a }, { id: b }) => a.localeCompare(b));
+    return JSON.parse(JSON.stringify(this._graph));
+  }
+
+  get graph(): Graph {
+    return this._graph;
+  }
+
+  get nodes(): Node[] {
+    return this._graph.nodes as Node[];
+  }
+
+  get edges(): Edge[] {
+    return this._graph.edges as Edge[];
+  }
+
+  getNode(id: string): Node | undefined {
+    return this.nodes.find((node) => node.id === id);
+  }
+
+  getNodes({ type }: Partial<Node>): Node[] {
+    return this.nodes.filter((node) => !type || type === node.type);
+  }
+
+  getEdge(id: string): Edge | undefined {
+    return this.edges.find((edge) => edge.id === id);
+  }
+
+  getEdges({ type, source, target }: Partial<Edge>): Edge[] {
+    return this.edges.filter(
+      (edge) =>
+        (!type || type === edge.type) && (!source || source === edge.source) && (!target || target === edge.target),
+    );
+  }
+}
+
+export class GraphModel<Node extends GraphNode = any, Edge extends GraphEdge = any> extends ReadonlyGraphModel<
+  Node,
+  Edge
+> {
+  clear(): this {
+    this._graph.nodes.length = 0;
+    this._graph.edges.length = 0;
+    return this;
+  }
+
+  addGraph(graph: GraphModel<Node, Edge>): this {
+    this.addNodes(graph.nodes);
+    this.addEdges(graph.edges);
+    return this;
+  }
+
+  addGraphs(graphs: GraphModel<Node, Edge>[]): this {
+    graphs.forEach((graph) => {
+      this.addNodes(graph.nodes);
+      this.addEdges(graph.edges);
+    });
+    return this;
+  }
+
+  addNode(node: Node): this {
+    this._graph.nodes.push(node);
+    return this;
+  }
+
+  addNodes(nodes: Node[]): this {
+    nodes.forEach((node) => this.addNode(node));
+    return this;
+  }
+
+  addEdge(edge: Edge): this {
+    this._graph.edges.push(edge);
+    return this;
+  }
+
+  addEdges(edges: Edge[]): this {
+    edges.forEach((edge) => this.addEdge(edge));
+    return this;
+  }
+
+  // TODO(burdon): Return graph.
+
+  removeNode(id: string): GraphModel<Node, Edge> {
+    const nodes = removeElements(this._graph.nodes, (node) => node.id === id);
+    const edges = removeElements(this._graph.edges, (edge) => edge.source === id || edge.target === id);
+    return new GraphModel<Node, Edge>({ nodes, edges });
+  }
+
+  removeNodes(ids: string[]): GraphModel<Node, Edge> {
+    const graphs = ids.map((id) => this.removeNode(id));
+    return new GraphModel<Node, Edge>().addGraphs(graphs);
+  }
+
+  removeEdge(id: string): GraphModel<Node, Edge> {
+    const edges = removeElements(this._graph.edges, (edge) => edge.id === id);
+    return new GraphModel<Node, Edge>({ edges });
+  }
+
+  removeEdges(ids: string[]): GraphModel<Node, Edge> {
+    const graphs = ids.map((id) => this.removeEdge(id));
+    return new GraphModel<Node, Edge>().addGraphs(graphs);
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export * from './buidler';
+export * from './graph';
+export * from './types';

package/src/types.ts

@@ -0,0 +1,42 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { S } from '@dxos/echo-schema';
+
+// Prior art:
+// - https://graphology.github.io (TS, tree-shakable, multiple packages for extensions)
+// - https://github.com/dagrejs/graphlib (mature, extensive)
+// - https://github.com/avoidwork/tiny-graph
+
+export const BaseGraphNode = S.Struct({
+  id: S.String,
+  type: S.optional(S.String),
+  data: S.optional(S.Any),
+});
+
+export type BaseGraphNode = S.Schema.Type<typeof BaseGraphNode>;
+export type GraphNode<Data extends object | void = void> = BaseGraphNode & { data: Data };
+
+export const BaseGraphEdge = S.Struct({
+  id: S.String,
+  type: S.optional(S.String),
+  source: S.String,
+  target: S.String,
+  data: S.optional(S.Any),
+});
+
+export type BaseGraphEdge = S.Schema.Type<typeof BaseGraphEdge>;
+export type GraphEdge<Data extends object | void = void> = BaseGraphEdge & { data: Data };
+
+/**
+ * Generic graph abstraction.
+ */
+export const Graph = S.Struct({
+  nodes: S.mutable(S.Array(BaseGraphNode)),
+  edges: S.mutable(S.Array(BaseGraphEdge)),
+});
+
+export type Graph = S.Schema.Type<typeof Graph>;
+
+export const emptyGraph: Graph = { nodes: [], edges: [] };

package/src/util.ts

@@ -0,0 +1,17 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+// TODO(burdon): GraphBuilder.
+
+// TODO(burdon): Move to @dxos/live-object?
+export const removeElements = <T>(array: T[], predicate: (element: T, index: number) => boolean): T[] => {
+  const deleted: T[] = [];
+  for (let i = array.length - 1; i >= 0; i--) {
+    if (predicate(array[i], i)) {
+      deleted.push(...array.splice(i, 1));
+    }
+  }
+
+  return deleted;
+};