@dxos/app-graph 0.8.4-main.f9ba587 → 0.8.4-main.fffef41

package/src/graph-builder.ts

@@ -2,37 +2,45 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Registry, Rx } from '@effect-rx/rx-react';
+import { Atom, Registry } from '@effect-atom/atom-react';
 import { effect } from '@preact/signals-core';
-import { Array, type Option, pipe, Record } from 'effect';
+import * as Array from 'effect/Array';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import * as Record from 'effect/Record';
 
-import { type MulticastObservable, type CleanupFn } from '@dxos/async';
+import { type CleanupFn, type MulticastObservable, type Trigger } from '@dxos/async';
 import { log } from '@dxos/log';
-import { byPosition, getDebugName, isNode, isNonNullable, type MaybePromise, type Position } from '@dxos/util';
+import { type MaybePromise, type Position, byPosition, getDebugName, isNode, isNonNullable } from '@dxos/util';
 
-import { ACTION_GROUP_TYPE, ACTION_TYPE, Graph, ROOT_ID, type GraphParams, type ExpandableGraph } from './graph';
-import { actionGroupSymbol, type ActionData, type Node, type NodeArg, type Relation } from './node';
+import { ACTION_GROUP_TYPE, ACTION_TYPE, type ExpandableGraph, Graph, type GraphParams, ROOT_ID } from './graph';
+import { type ActionData, type Node, type NodeArg, type Relation, actionGroupSymbol } from './node';
+
+/**
+ * Graph builder extension for adding nodes to the graph based on a node id.
+ */
+export type ResolverExtension = (id: string) => Atom.Atom<NodeArg<any> | null>;
 
 /**
  * Graph builder extension for adding nodes to the graph based on a connection to an existing node.
  *
  * @param params.node The existing node the returned nodes will be connected to.
  */
-export type ConnectorExtension = (node: Rx.Rx<Option.Option<Node>>) => Rx.Rx<NodeArg<any>[]>;
+export type ConnectorExtension = (node: Atom.Atom<Option.Option<Node>>) => Atom.Atom<NodeArg<any>[]>;
 
 /**
  * Constrained case of the connector extension for more easily adding actions to the graph.
  */
 export type ActionsExtension = (
-  node: Rx.Rx<Option.Option<Node>>,
-) => Rx.Rx<Omit<NodeArg<ActionData>, 'type' | 'nodes' | 'edges'>[]>;
+  node: Atom.Atom<Option.Option<Node>>,
+) => Atom.Atom<Omit<NodeArg<ActionData>, 'type' | 'nodes' | 'edges'>[]>;
 
 /**
  * Constrained case of the connector extension for more easily adding action groups to the graph.
  */
 export type ActionGroupsExtension = (
-  node: Rx.Rx<Option.Option<Node>>,
-) => Rx.Rx<Omit<NodeArg<typeof actionGroupSymbol>, 'type' | 'data' | 'nodes' | 'edges'>[]>;
+  node: Atom.Atom<Option.Option<Node>>,
+) => Atom.Atom<Omit<NodeArg<typeof actionGroupSymbol>, 'type' | 'data' | 'nodes' | 'edges'>[]>;
 
 /**
  * A graph builder extension is used to add nodes to the graph.
@@ -49,8 +57,7 @@ export type CreateExtensionOptions = {
   id: string;
   relation?: Relation;
   position?: Position;
-  // TODO(wittjosiah): On initialize to restore state from cache.
-  // resolver?: ResolverExtension;
+  resolver?: ResolverExtension;
   connector?: ConnectorExtension;
   actions?: ActionsExtension;
   actionGroups?: ActionGroupsExtension;
@@ -64,44 +71,50 @@ export const createExtension = (extension: CreateExtensionOptions): BuilderExten
     id,
     position = 'static',
     relation = 'outbound',
+    resolver: _resolver,
     connector: _connector,
     actions: _actions,
     actionGroups: _actionGroups,
   } = extension;
   const getId = (key: string) => `${id}/${key}`;
 
+  const resolver =
+    _resolver && Atom.family((id: string) => _resolver(id).pipe(Atom.withLabel(`graph-builder:_resolver:${id}`)));
+
   const connector =
     _connector &&
-    Rx.family((node: Rx.Rx<Option.Option<Node>>) =>
-      _connector(node).pipe(Rx.withLabel(`graph-builder:_connector:${id}`)),
+    Atom.family((node: Atom.Atom<Option.Option<Node>>) =>
+      _connector(node).pipe(Atom.withLabel(`graph-builder:_connector:${id}`)),
     );
 
   const actionGroups =
     _actionGroups &&
-    Rx.family((node: Rx.Rx<Option.Option<Node>>) =>
-      _actionGroups(node).pipe(Rx.withLabel(`graph-builder:_actionGroups:${id}`)),
+    Atom.family((node: Atom.Atom<Option.Option<Node>>) =>
+      _actionGroups(node).pipe(Atom.withLabel(`graph-builder:_actionGroups:${id}`)),
     );
 
   const actions =
     _actions &&
-    Rx.family((node: Rx.Rx<Option.Option<Node>>) => _actions(node).pipe(Rx.withLabel(`graph-builder:_actions:${id}`)));
+    Atom.family((node: Atom.Atom<Option.Option<Node>>) =>
+      _actions(node).pipe(Atom.withLabel(`graph-builder:_actions:${id}`)),
+    );
 
   return [
-    // resolver ? { id: getId('resolver'), position, resolver } : undefined,
+    resolver ? { id: getId('resolver'), position, resolver } : undefined,
     connector
       ? ({
           id: getId('connector'),
           position,
           relation,
-          connector: Rx.family((node) =>
-            Rx.make((get) => {
+          connector: Atom.family((node) =>
+            Atom.make((get) => {
               try {
                 return get(connector(node));
               } catch {
                 log.warn('Error in connector', { id: getId('connector'), node });
                 return [];
               }
-            }).pipe(Rx.withLabel(`graph-builder:connector:${id}`)),
+            }).pipe(Atom.withLabel(`graph-builder:connector:${id}`)),
           ),
         } satisfies BuilderExtension)
       : undefined,
@@ -110,8 +123,8 @@ export const createExtension = (extension: CreateExtensionOptions): BuilderExten
           id: getId('actionGroups'),
           position,
           relation: 'outbound',
-          connector: Rx.family((node) =>
-            Rx.make((get) => {
+          connector: Atom.family((node) =>
+            Atom.make((get) => {
               try {
                 return get(actionGroups(node)).map((arg) => ({
                   ...arg,
@@ -122,7 +135,7 @@ export const createExtension = (extension: CreateExtensionOptions): BuilderExten
                 log.warn('Error in actionGroups', { id: getId('actionGroups'), node });
                 return [];
               }
-            }).pipe(Rx.withLabel(`graph-builder:connector:actionGroups:${id}`)),
+            }).pipe(Atom.withLabel(`graph-builder:connector:actionGroups:${id}`)),
           ),
         } satisfies BuilderExtension)
       : undefined,
@@ -131,15 +144,15 @@ export const createExtension = (extension: CreateExtensionOptions): BuilderExten
           id: getId('actions'),
           position,
           relation: 'outbound',
-          connector: Rx.family((node) =>
-            Rx.make((get) => {
+          connector: Atom.family((node) =>
+            Atom.make((get) => {
               try {
                 return get(actions(node)).map((arg) => ({ ...arg, type: ACTION_TYPE }));
               } catch {
                 log.warn('Error in actions', { id: getId('actions'), node });
                 return [];
               }
-            }).pipe(Rx.withLabel(`graph-builder:connector:actions:${id}`)),
+            }).pipe(Atom.withLabel(`graph-builder:connector:actions:${id}`)),
           ),
         } satisfies BuilderExtension)
       : undefined,
@@ -157,8 +170,8 @@ export type BuilderExtension = Readonly<{
   id: string;
   position: Position;
   relation?: Relation; // Only for connector.
-  // resolver?: ResolverExtension;
-  connector?: (node: Rx.Rx<Option.Option<Node>>) => Rx.Rx<NodeArg<any>[]>;
+  resolver?: ResolverExtension;
+  connector?: (node: Atom.Atom<Option.Option<Node>>) => Atom.Atom<NodeArg<any>[]>;
 }>;
 
 export type BuilderExtensions = BuilderExtension | BuilderExtension[] | BuilderExtensions[];
@@ -179,12 +192,12 @@ export const flattenExtensions = (extension: BuilderExtensions, acc: BuilderExte
 //   Should track LRU nodes that are not in the set/radius and remove them beyond a certain threshold.
 export class GraphBuilder {
   // TODO(wittjosiah): Use Context.
-  private readonly _connectorSubscriptions = new Map<string, CleanupFn>();
-  private readonly _extensions = Rx.make(Record.empty<string, BuilderExtension>()).pipe(
-    Rx.keepAlive,
-    Rx.withLabel('graph-builder:extensions'),
+  private readonly _subscriptions = new Map<string, CleanupFn>();
+  private readonly _extensions = Atom.make(Record.empty<string, BuilderExtension>()).pipe(
+    Atom.keepAlive,
+    Atom.withLabel('graph-builder:extensions'),
   );
-
+  private readonly _initialized: Record<string, Trigger> = {};
   private readonly _registry: Registry.Registry;
   private readonly _graph: Graph;
 
@@ -194,7 +207,7 @@ export class GraphBuilder {
       ...params,
       registry: this._registry,
       onExpand: (id, relation) => this._onExpand(id, relation),
-      // onInitialize: (id) => this._onInitialize(id),
+      onInitialize: (id) => this._onInitialize(id),
       onRemoveNode: (id) => this._onRemoveNode(id),
     });
   }
@@ -275,16 +288,31 @@ export class GraphBuilder {
   }
 
   destroy(): void {
-    this._connectorSubscriptions.forEach((unsubscribe) => unsubscribe());
-    this._connectorSubscriptions.clear();
+    this._subscriptions.forEach((unsubscribe) => unsubscribe());
+    this._subscriptions.clear();
   }
 
-  private readonly _connectors = Rx.family<string, Rx.Rx<NodeArg<any>[]>>((key) => {
-    return Rx.make((get) => {
+  private readonly _resolvers = Atom.family<string, Atom.Atom<Option.Option<NodeArg<any>>>>((id) => {
+    return Atom.make((get) => {
+      return Function.pipe(
+        get(this._extensions),
+        Record.values,
+        Array.sortBy(byPosition),
+        Array.map(({ resolver }) => resolver),
+        Array.filter(isNonNullable),
+        Array.map((resolver) => get(resolver(id))),
+        Array.filter(isNonNullable),
+        Array.head,
+      );
+    });
+  });
+
+  private readonly _connectors = Atom.family<string, Atom.Atom<NodeArg<any>[]>>((key) => {
+    return Atom.make((get) => {
       const [id, relation] = key.split('+');
       const node = this._graph.node(id);
 
-      return pipe(
+      return Function.pipe(
         get(this._extensions),
         Record.values,
         // TODO(wittjosiah): Sort on write rather than read.
@@ -294,7 +322,7 @@ export class GraphBuilder {
         Array.filter(isNonNullable),
         Array.flatMap((result) => get(result)),
       );
-    }).pipe(Rx.withLabel(`graph-builder:connectors:${key}`));
+    }).pipe(Atom.withLabel(`graph-builder:connectors:${key}`));
   });
 
   private _onExpand(id: string, relation: Relation): void {
@@ -311,7 +339,7 @@ export class GraphBuilder {
 
         log('update', { id, relation, ids, removed });
         const update = () => {
-          Rx.batch(() => {
+          Atom.batch(() => {
             this._graph.removeEdges(
               removed.map((target) => ({ source: id, target })),
               true,
@@ -341,26 +369,47 @@ export class GraphBuilder {
       { immediate: true },
     );
 
-    this._connectorSubscriptions.set(id, cancel);
+    this._subscriptions.set(id, cancel);
   }
 
-  // TODO(wittjosiah): On initialize to restore state from cache.
-  // private async _onInitialize(id: string) {
-  //   log('onInitialize', { id });
-  // }
+  // TODO(wittjosiah): If the same node is added by a connector, the resolver should probably cancel itself?
+  private async _onInitialize(id: string) {
+    log('onInitialize', { id });
+    const resolver = this._resolvers(id);
+
+    const cancel = this._registry.subscribe(
+      resolver,
+      (node) => {
+        const trigger = this._initialized[id];
+        Option.match(node, {
+          onSome: (node) => {
+            this._graph.addNodes([node]);
+            trigger?.wake();
+          },
+          onNone: () => {
+            trigger?.wake();
+            this._graph.removeNodes([id]);
+          },
+        });
+      },
+      { immediate: true },
+    );
+
+    this._subscriptions.set(id, cancel);
+  }
 
   private _onRemoveNode(id: string): void {
-    this._connectorSubscriptions.get(id)?.();
-    this._connectorSubscriptions.delete(id);
+    this._subscriptions.get(id)?.();
+    this._subscriptions.delete(id);
   }
 }
 
 /**
- * Creates an Rx.Rx<T> from a callback which accesses signals.
- * Will return a new rx instance each time.
+ * Creates an Atom.Atom<T> from a callback which accesses signals.
+ * Will return a new atom instance each time.
  */
-export const rxFromSignal = <T>(cb: () => T): Rx.Rx<T> => {
-  return Rx.make((get) => {
+export const atomFromSignal = <T>(cb: () => T): Atom.Atom<T> => {
+  return Atom.make((get) => {
     const dispose = effect(() => {
       get.setSelf(cb());
     });
@@ -371,8 +420,8 @@ export const rxFromSignal = <T>(cb: () => T): Rx.Rx<T> => {
   });
 };
 
-const observableFamily = Rx.family((observable: MulticastObservable<any>) => {
-  return Rx.make((get) => {
+const observableFamily = Atom.family((observable: MulticastObservable<any>) => {
+  return Atom.make((get) => {
     const subscription = observable.subscribe((value) => get.setSelf(value));
 
     get.addFinalizer(() => subscription.unsubscribe());
@@ -382,9 +431,9 @@ const observableFamily = Rx.family((observable: MulticastObservable<any>) => {
 });
 
 /**
- * Creates an Rx.Rx<T> from a MulticastObservable<T>
- * Will return the same rx instance for the same observable.
+ * Creates an Atom.Atom<T> from a MulticastObservable<T>
+ * Will return the same atom instance for the same observable.
  */
-export const rxFromObservable = <T>(observable: MulticastObservable<T>): Rx.Rx<T> => {
-  return observableFamily(observable) as Rx.Rx<T>;
+export const atomFromObservable = <T>(observable: MulticastObservable<T>): Atom.Atom<T> => {
+  return observableFamily(observable) as Atom.Atom<T>;
 };

package/src/graph.test.ts

@@ -2,11 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Registry, Rx } from '@effect-rx/rx-react';
-import { Option } from 'effect';
+import { Atom, Registry } from '@effect-atom/atom-react';
+import * as Option from 'effect/Option';
 import { assert, describe, expect, onTestFinished, test } from 'vitest';
 
-import { getGraph, Graph, ROOT_ID, ROOT_TYPE } from './graph';
+import { Graph, ROOT_ID, ROOT_TYPE, getGraph } from './graph';
 import { type Node } from './node';
 
 const exampleId = (id: number) => `dx:test:${id}`;
@@ -238,7 +238,7 @@ describe('Graph', () => {
     expect(count).toEqual(5);
 
     // Batching the edge and node updates fires a single update.
-    Rx.batch(() => {
+    Atom.batch(() => {
       graph.addEdge({ source: exampleId(1), target: exampleId(6) });
       graph.addNode({ id: exampleId(6), type: EXAMPLE_TYPE });
     });