@dxos/app-graph 0.8.4-main.dedc0f3 → 0.8.4-main.e8ec1fe

package/src/graph.ts

@@ -2,8 +2,10 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Registry, Rx } from '@effect-rx/rx-react';
-import { Option, Record, pipe } from 'effect';
+import { Atom, Registry } from '@effect-atom/atom-react';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import * as Record from 'effect/Record';
 
 import { Event, Trigger } from '@dxos/async';
 import { todo } from '@dxos/debug';
@@ -14,7 +16,9 @@ import { type MakeOptional, isNonNullable } from '@dxos/util';
 import { type Action, type ActionGroup, type Node, type NodeArg, type Relation } from './node';
 
 const graphSymbol = Symbol('graph');
-type DeepWriteable<T> = { -readonly [K in keyof T]: T[K] extends object ? DeepWriteable<T[K]> : T[K] };
+type DeepWriteable<T> = {
+  -readonly [K in keyof T]: T[K] extends object ? DeepWriteable<T[K]> : T[K];
+};
 type NodeInternal = DeepWriteable<Node> & { [graphSymbol]: Graph };
 
 /**
@@ -77,32 +81,32 @@ export interface ReadableGraph {
    */
   toJSON(id?: string): object;
 
-  json(id?: string): Rx.Rx<any>;
+  json(id?: string): Atom.Atom<any>;
 
   /**
-   * Get the rx key for the node with the given id.
+   * Get the atom key for the node with the given id.
    */
-  node(id: string): Rx.Rx<Option.Option<Node>>;
+  node(id: string): Atom.Atom<Option.Option<Node>>;
 
   /**
-   * Get the rx key for the node with the given id.
+   * Get the atom key for the node with the given id.
    */
-  nodeOrThrow(id: string): Rx.Rx<Node>;
+  nodeOrThrow(id: string): Atom.Atom<Node>;
 
   /**
-   * Get the rx key for the connections of the node with the given id.
+   * Get the atom key for the connections of the node with the given id.
    */
-  connections(id: string, relation?: Relation): Rx.Rx<Node[]>;
+  connections(id: string, relation?: Relation): Atom.Atom<Node[]>;
 
   /**
-   * Get the rx key for the actions of the node with the given id.
+   * Get the atom key for the actions of the node with the given id.
    */
-  actions(id: string): Rx.Rx<(Action | ActionGroup)[]>;
+  actions(id: string): Atom.Atom<(Action | ActionGroup)[]>;
 
   /**
-   * Get the rx key for the edges of the node with the given id.
+   * Get the atom key for the edges of the node with the given id.
    */
-  edges(id: string): Rx.Rx<Edges>;
+  edges(id: string): Atom.Atom<Edges>;
 
   /**
    * Alias for `getNodeOrThrow(ROOT_ID)`.
@@ -226,7 +230,10 @@ export interface WritableGraph extends ExpandableGraph {
  * The Graph represents the user interface information architecture of the application constructed via plugins.
  */
 export class Graph implements WritableGraph {
-  readonly onNodeChanged = new Event<{ id: string; node: Option.Option<Node> }>();
+  readonly onNodeChanged = new Event<{
+    id: string;
+    node: Option.Option<Node>;
+  }>();
 
   private readonly _onExpand?: (id: string, relation: Relation) => void;
   private readonly _onInitialize?: (id: string) => Promise<void>;
@@ -237,55 +244,63 @@ export class Graph implements WritableGraph {
   private readonly _initialized = Record.empty<string, boolean>();
   private readonly _initialEdges = Record.empty<string, Edges>();
   private readonly _initialNodes = Record.fromEntries([
-    [ROOT_ID, this._constructNode({ id: ROOT_ID, type: ROOT_TYPE, data: null, properties: {} })],
+    [
+      ROOT_ID,
+      this._constructNode({
+        id: ROOT_ID,
+        type: ROOT_TYPE,
+        data: null,
+        properties: {},
+      }),
+    ],
   ]);
 
   /** @internal */
-  readonly _node = Rx.family<string, Rx.Writable<Option.Option<Node>>>((id) => {
+  readonly _node = Atom.family<string, Atom.Writable<Option.Option<Node>>>((id) => {
     const initial = Option.flatten(Record.get(this._initialNodes, id));
-    return Rx.make<Option.Option<Node>>(initial).pipe(Rx.keepAlive, Rx.withLabel(`graph:node:${id}`));
+    return Atom.make<Option.Option<Node>>(initial).pipe(Atom.keepAlive, Atom.withLabel(`graph:node:${id}`));
   });
 
-  private readonly _nodeOrThrow = Rx.family<string, Rx.Rx<Node>>((id) => {
-    return Rx.make((get) => {
+  private readonly _nodeOrThrow = Atom.family<string, Atom.Atom<Node>>((id) => {
+    return Atom.make((get) => {
       const node = get(this._node(id));
       invariant(Option.isSome(node), `Node not available: ${id}`);
       return node.value;
     });
   });
 
-  private readonly _edges = Rx.family<string, Rx.Writable<Edges>>((id) => {
+  private readonly _edges = Atom.family<string, Atom.Writable<Edges>>((id) => {
     const initial = Record.get(this._initialEdges, id).pipe(Option.getOrElse(() => ({ inbound: [], outbound: [] })));
-    return Rx.make<Edges>(initial).pipe(Rx.keepAlive, Rx.withLabel(`graph:edges:${id}`));
+    return Atom.make<Edges>(initial).pipe(Atom.keepAlive, Atom.withLabel(`graph:edges:${id}`));
   });
 
-  // NOTE: Currently the argument to the family needs to be referentially stable for the rx to be referentially stable.
-  // TODO(wittjosiah): Rx feature request, support for something akin to `ComplexMap` to allow for complex arguments.
-  private readonly _connections = Rx.family<string, Rx.Rx<Node[]>>((key) => {
-    return Rx.make((get) => {
+  // NOTE: Currently the argument to the family needs to be referentially stable for the atom to be referentially stable.
+  // TODO(wittjosiah): Atom feature request, support for something akin to `ComplexMap` to allow for complex arguments.
+  private readonly _connections = Atom.family<string, Atom.Atom<Node[]>>((key) => {
+    return Atom.make((get) => {
       const [id, relation] = key.split('$');
       const edges = get(this._edges(id));
       return edges[relation as Relation]
         .map((id) => get(this._node(id)))
         .filter(Option.isSome)
         .map((o) => o.value);
-    }).pipe(Rx.withLabel(`graph:connections:${key}`));
+    }).pipe(Atom.withLabel(`graph:connections:${key}`));
   });
 
-  private readonly _actions = Rx.family<string, Rx.Rx<(Action | ActionGroup)[]>>((id) => {
-    return Rx.make((get) => {
+  private readonly _actions = Atom.family<string, Atom.Atom<(Action | ActionGroup)[]>>((id) => {
+    return Atom.make((get) => {
       return get(this._connections(`${id}$outbound`)).filter(
         (node) => node.type === ACTION_TYPE || node.type === ACTION_GROUP_TYPE,
       );
-    }).pipe(Rx.withLabel(`graph:actions:${id}`));
+    }).pipe(Atom.withLabel(`graph:actions:${id}`));
   });
 
-  private readonly _json = Rx.family<string, Rx.Rx<any>>((id) => {
-    return Rx.make((get) => {
+  private readonly _json = Atom.family<string, Atom.Atom<any>>((id) => {
+    return Atom.make((get) => {
       const toJSON = (node: Node, seen: string[] = []): any => {
         const nodes = get(this.connections(node.id));
         const obj: Record<string, any> = {
-          id: node.id.length > 32 ? `${node.id.slice(0, 32)}...` : node.id,
+          id: node.id,
           type: node.type,
         };
         if (node.properties.label) {
@@ -305,7 +320,7 @@ export class Graph implements WritableGraph {
 
       const root = get(this.nodeOrThrow(id));
       return toJSON(root);
-    }).pipe(Rx.withLabel(`graph:json:${id}`));
+    }).pipe(Atom.withLabel(`graph:json:${id}`));
   });
 
   constructor({ registry, nodes, edges, onInitialize, onExpand, onRemoveNode }: GraphParams = {}) {
@@ -335,15 +350,15 @@ export class Graph implements WritableGraph {
     return this._json(id);
   }
 
-  node(id: string): Rx.Rx<Option.Option<Node>> {
+  node(id: string): Atom.Atom<Option.Option<Node>> {
     return this._node(id);
   }
 
-  nodeOrThrow(id: string): Rx.Rx<Node> {
+  nodeOrThrow(id: string): Atom.Atom<Node> {
     return this._nodeOrThrow(id);
   }
 
-  connections(id: string, relation: Relation = 'outbound'): Rx.Rx<Node[]> {
+  connections(id: string, relation: Relation = 'outbound'): Atom.Atom<Node[]> {
     return this._connections(`${id}$${relation}`);
   }
 
@@ -351,7 +366,7 @@ export class Graph implements WritableGraph {
     return this._actions(id);
   }
 
-  edges(id: string): Rx.Rx<Edges> {
+  edges(id: string): Atom.Atom<Edges> {
     return this._edges(id);
   }
 
@@ -399,38 +414,48 @@ export class Graph implements WritableGraph {
   }
 
   addNodes(nodes: NodeArg<any, Record<string, any>>[]): void {
-    Rx.batch(() => {
+    Atom.batch(() => {
       nodes.map((node) => this.addNode(node));
     });
   }
 
   addNode({ nodes, edges, ...nodeArg }: NodeArg<any, Record<string, any>>): void {
     const { id, type, data = null, properties = {} } = nodeArg;
-    const nodeRx = this._node(id);
-    const node = this._registry.get(nodeRx);
+    const nodeAtom = this._node(id);
+    const node = this._registry.get(nodeAtom);
     Option.match(node, {
       onSome: (node) => {
         const typeChanged = node.type !== type;
         const dataChanged = node.data !== data;
         const propertiesChanged = Object.keys(properties).some((key) => node.properties[key] !== properties[key]);
-        log('existing node', { id, typeChanged, dataChanged, propertiesChanged });
+        log('existing node', {
+          id,
+          typeChanged,
+          dataChanged,
+          propertiesChanged,
+        });
         if (typeChanged || dataChanged || propertiesChanged) {
           log('updating node', { id, type, data, properties });
-          const newNode = Option.some({ ...node, type, data, properties: { ...node.properties, ...properties } });
-          this._registry.set(nodeRx, newNode);
+          const newNode = Option.some({
+            ...node,
+            type,
+            data,
+            properties: { ...node.properties, ...properties },
+          });
+          this._registry.set(nodeAtom, newNode);
           this.onNodeChanged.emit({ id, node: newNode });
         }
       },
       onNone: () => {
         log('new node', { id, type, data, properties });
         const newNode = this._constructNode({ id, type, data, properties });
-        this._registry.set(nodeRx, newNode);
+        this._registry.set(nodeAtom, newNode);
         this.onNodeChanged.emit({ id, node: newNode });
       },
     });
 
     if (nodes) {
-      // Rx.batch(() => {
+      // Atom.batch(() => {
       this.addNodes(nodes);
       const _edges = nodes.map((node) => ({ source: id, target: node.id }));
       this.addEdges(_edges);
@@ -443,15 +468,15 @@ export class Graph implements WritableGraph {
   }
 
   removeNodes(ids: string[], edges = false): void {
-    Rx.batch(() => {
+    Atom.batch(() => {
       ids.map((id) => this.removeNode(id, edges));
     });
   }
 
   removeNode(id: string, edges = false): void {
-    const nodeRx = this._node(id);
-    // TODO(wittjosiah): Is there a way to mark these rx values for garbage collection?
-    this._registry.set(nodeRx, Option.none());
+    const nodeAtom = this._node(id);
+    // TODO(wittjosiah): Is there a way to mark these atom values for garbage collection?
+    this._registry.set(nodeAtom, Option.none());
     this.onNodeChanged.emit({ id, node: Option.none() });
     // TODO(wittjosiah): Reset expanded and initialized flags?
 
@@ -468,55 +493,67 @@ export class Graph implements WritableGraph {
   }
 
   addEdges(edges: Edge[]): void {
-    Rx.batch(() => {
+    Atom.batch(() => {
       edges.map((edge) => this.addEdge(edge));
     });
   }
 
   addEdge(edgeArg: Edge): void {
-    const sourceRx = this._edges(edgeArg.source);
-    const source = this._registry.get(sourceRx);
+    const sourceAtom = this._edges(edgeArg.source);
+    const source = this._registry.get(sourceAtom);
     if (!source.outbound.includes(edgeArg.target)) {
-      log('add outbound edge', { source: edgeArg.source, target: edgeArg.target });
-      this._registry.set(sourceRx, { inbound: source.inbound, outbound: [...source.outbound, edgeArg.target] });
+      log('add outbound edge', {
+        source: edgeArg.source,
+        target: edgeArg.target,
+      });
+      this._registry.set(sourceAtom, {
+        inbound: source.inbound,
+        outbound: [...source.outbound, edgeArg.target],
+      });
     }
 
-    const targetRx = this._edges(edgeArg.target);
-    const target = this._registry.get(targetRx);
+    const targetAtom = this._edges(edgeArg.target);
+    const target = this._registry.get(targetAtom);
     if (!target.inbound.includes(edgeArg.source)) {
-      log('add inbound edge', { source: edgeArg.source, target: edgeArg.target });
-      this._registry.set(targetRx, { inbound: [...target.inbound, edgeArg.source], outbound: target.outbound });
+      log('add inbound edge', {
+        source: edgeArg.source,
+        target: edgeArg.target,
+      });
+      this._registry.set(targetAtom, {
+        inbound: [...target.inbound, edgeArg.source],
+        outbound: target.outbound,
+      });
     }
   }
 
   removeEdges(edges: Edge[], removeOrphans = false): void {
-    Rx.batch(() => {
+    Atom.batch(() => {
       edges.map((edge) => this.removeEdge(edge, removeOrphans));
     });
   }
 
   removeEdge(edgeArg: Edge, removeOrphans = false): void {
-    const sourceRx = this._edges(edgeArg.source);
-    const source = this._registry.get(sourceRx);
+    const sourceAtom = this._edges(edgeArg.source);
+    const source = this._registry.get(sourceAtom);
     if (source.outbound.includes(edgeArg.target)) {
-      this._registry.set(sourceRx, {
+      this._registry.set(sourceAtom, {
         inbound: source.inbound,
         outbound: source.outbound.filter((id) => id !== edgeArg.target),
       });
     }
 
-    const targetRx = this._edges(edgeArg.target);
-    const target = this._registry.get(targetRx);
+    const targetAtom = this._edges(edgeArg.target);
+    const target = this._registry.get(targetAtom);
     if (target.inbound.includes(edgeArg.source)) {
-      this._registry.set(targetRx, {
+      this._registry.set(targetAtom, {
         inbound: target.inbound.filter((id) => id !== edgeArg.source),
         outbound: target.outbound,
       });
     }
 
     if (removeOrphans) {
-      const source = this._registry.get(sourceRx);
-      const target = this._registry.get(targetRx);
+      const source = this._registry.get(sourceAtom);
+      const target = this._registry.get(targetAtom);
       if (source.outbound.length === 0 && source.inbound.length === 0 && edgeArg.source !== ROOT_ID) {
         this.removeNodes([edgeArg.source]);
       }
@@ -527,12 +564,12 @@ export class Graph implements WritableGraph {
   }
 
   sortEdges(id: string, relation: Relation, order: string[]): void {
-    const edgesRx = this._edges(id);
-    const edges = this._registry.get(edgesRx);
+    const edgesAtom = this._edges(id);
+    const edges = this._registry.get(edgesAtom);
     const unsorted = edges[relation].filter((id) => !order.includes(id)) ?? [];
     const sorted = order.filter((id) => edges[relation].includes(id)) ?? [];
     edges[relation].splice(0, edges[relation].length, ...[...sorted, ...unsorted]);
-    this._registry.set(edgesRx, edges);
+    this._registry.set(edgesAtom, edges);
   }
 
   traverse({ visitor, source = ROOT_ID, relation = 'outbound' }: GraphTraversalOptions, path: string[] = []): void {
@@ -553,7 +590,7 @@ export class Graph implements WritableGraph {
   }
 
   getPath({ source = 'root', target }: { source?: string; target: string }): Option.Option<string[]> {
-    return pipe(
+    return Function.pipe(
       this.getNode(source),
       Option.flatMap((node) => {
         let found: Option.Option<string[]> = Option.none();
@@ -597,6 +634,11 @@ export class Graph implements WritableGraph {
 
   /** @internal */
   _constructNode(node: NodeArg<any>): Option.Option<Node> {
-    return Option.some({ [graphSymbol]: this, data: null, properties: {}, ...node });
+    return Option.some({
+      [graphSymbol]: this,
+      data: null,
+      properties: {},
+      ...node,
+    });
   }
 }

package/src/signals-integration.test.ts

@@ -2,37 +2,37 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Registry, Rx } from '@effect-rx/rx-react';
+import { Atom, Registry } from '@effect-atom/atom-react';
 import { signal } from '@preact/signals-core';
 import { afterEach, beforeEach, describe, expect, onTestFinished, test } from 'vitest';
 
 import { Trigger } from '@dxos/async';
+import { Obj, Type } from '@dxos/echo';
+import { Ref } from '@dxos/echo/internal';
 import { Filter } from '@dxos/echo-db';
 import { EchoTestBuilder } from '@dxos/echo-db/testing';
-import { Expando, Ref } from '@dxos/echo-schema';
 import { registerSignalsRuntime } from '@dxos/echo-signals';
-import { live } from '@dxos/live-object';
 
 import { ROOT_ID } from './graph';
-import { GraphBuilder, createExtension, rxFromSignal } from './graph-builder';
-import { rxFromQuery } from './testing';
+import { GraphBuilder, atomFromSignal, createExtension } from './graph-builder';
+import { atomFromQuery } from './testing';
 
 registerSignalsRuntime();
 
 const EXAMPLE_TYPE = 'dxos.org/type/example';
 
 describe('signals integration', () => {
-  test('creating rx from signal', () => {
+  test('creating atom from signal', () => {
     const registry = Registry.make();
     const state = signal<number>(0);
-    const value = rxFromSignal(() => state.value);
-    const inline = Rx.make((get) => {
-      // NOTE: This will create a new rx instance each time.
-      // This test is verifying that this behaves the same as using a stable rx instance.
+    const value = atomFromSignal(() => state.value);
+    const inline = Atom.make((get) => {
+      // NOTE: This will create a new atom instance each time.
+      // This test is verifying that this behaves the same as using a stable atom instance.
       // The parent will remain subscribed to one instance until the new one is created.
       // The old one will then be garbage collected because it is no longer referenced.
-      const rx = rxFromSignal(() => get(value));
-      return get(rx);
+      const atom = atomFromSignal(() => get(value));
+      return get(atom);
     });
 
     let count = 0;
@@ -72,7 +72,7 @@ describe('signals integration', () => {
       await dbBuilder.close();
     });
 
-    test('rx references are loaded lazily and receive signal notifications', async () => {
+    test('atom references are loaded lazily and receive signal notifications', async () => {
       const registry = Registry.make();
       await using peer = await dbBuilder.createPeer();
 
@@ -89,23 +89,24 @@ describe('signals integration', () => {
       {
         await using db = await peer.openLastDatabase();
         const outer = (await db.query(Filter.ids(outerId)).first()) as any;
-        const innerRx = rxFromSignal(() => outer.inner.target);
-
+        const innerAtom = atomFromSignal(() => outer.inner.target);
         const loaded = new Trigger();
+
         let count = 0;
-        const cancel = registry.subscribe(innerRx, (inner) => {
+        const cancel = registry.subscribe(innerAtom, (inner) => {
           count++;
           if (inner) {
             loaded.wake();
           }
         });
+
         onTestFinished(() => cancel());
 
-        expect(registry.get(innerRx)).to.eq(undefined);
+        expect(registry.get(innerAtom)).to.eq(undefined);
         expect(count).to.eq(1);
 
         await loaded.wait();
-        expect(registry.get(innerRx)).to.include({ name: 'inner' });
+        expect(registry.get(innerAtom)).to.include({ name: 'inner' });
         expect(count).to.eq(2);
       }
     });
@@ -129,8 +130,8 @@ describe('signals integration', () => {
       {
         await using db = await peer.openLastDatabase();
         const outer = (await db.query(Filter.ids(outerId)).first()) as any;
-        const innerRx = rxFromSignal(() => outer.inner.target);
-        const inner = registry.get(innerRx);
+        const innerAtom = atomFromSignal(() => outer.inner.target);
+        const inner = registry.get(innerAtom);
         expect(inner).to.eq(undefined);
 
         const builder = new GraphBuilder({ registry });
@@ -138,8 +139,8 @@ describe('signals integration', () => {
           createExtension({
             id: 'outbound-connector',
             connector: () =>
-              Rx.make((get) => {
-                const inner = get(innerRx) as any;
+              Atom.make((get) => {
+                const inner = get(innerAtom) as any;
                 return inner ? [{ id: inner.id, type: EXAMPLE_TYPE, data: inner.name }] : [];
               }),
           }),
@@ -174,18 +175,18 @@ describe('signals integration', () => {
       const registry = Registry.make();
       await using peer = await dbBuilder.createPeer();
       await using db = await peer.createDatabase();
-      db.add(live(Expando, { name: 'a' }));
-      db.add(live(Expando, { name: 'b' }));
+      db.add(Obj.make(Type.Expando, { name: 'a' }));
+      db.add(Obj.make(Type.Expando, { name: 'b' }));
 
       const builder = new GraphBuilder({ registry });
       builder.addExtension(
         createExtension({
           id: 'expando',
           connector: () => {
-            const query = db.query(Filter.type(Expando));
+            const query = db.query(Filter.type(Type.Expando));
 
-            return Rx.make((get) => {
-              const objects = get(rxFromQuery(query));
+            return Atom.make((get) => {
+              const objects = get(atomFromQuery(query));
               return objects.map((object) => ({ id: object.id, type: EXAMPLE_TYPE, data: object.name }));
             });
           },
@@ -205,7 +206,7 @@ describe('signals integration', () => {
       graph.expand(ROOT_ID);
       expect(count).to.eq(2);
 
-      const object = db.add(live(Expando, { name: 'c' }));
+      const object = db.add(Obj.make(Type.Expando, { name: 'c' }));
       await db.flush();
       expect(count).to.eq(3);