@dxos/app-graph 0.7.4 → 0.7.5-feature-compute.4d9d99a

package/src/graph-builder.ts

@@ -8,11 +8,13 @@ import { Trigger, type UnsubscribeCallback } from '@dxos/async';
 import { invariant } from '@dxos/invariant';
 import { create } from '@dxos/live-object';
 import { log } from '@dxos/log';
-import { isNode, type MaybePromise, nonNullable } from '@dxos/util';
+import { byDisposition, type Disposition, isNode, type MaybePromise, nonNullable } from '@dxos/util';
 
 import { ACTION_GROUP_TYPE, ACTION_TYPE, Graph, ROOT_ID, type GraphParams } from './graph';
 import { type ActionData, actionGroupSymbol, type Node, type NodeArg, type Relation } from './node';
 
+const NODE_RESOLVER_TIMEOUT = 1_000;
+
 /**
  * Graph builder extension for adding nodes to the graph based on just the node id.
  * This is useful for creating the first node in a graph or for hydrating cached nodes with data.
@@ -50,6 +52,7 @@ type GuardedNodeType<T> = T extends (value: any) => value is infer N ? (N extend
  * @param params.id The unique id of the extension.
  * @param params.relation The relation the graph is being expanded from the existing node.
  * @param params.type If provided, all nodes returned are expected to have this type.
+ * @param params.disposition Affects the order the extensions are processed in.
  * @param params.filter A filter function to determine if an extension should act on a node.
  * @param params.resolver A function to add nodes to the graph based on just the node id.
  * @param params.connector A function to add nodes to the graph based on a connection to an existing node.
@@ -60,6 +63,7 @@ export type CreateExtensionOptions<T = any> = {
   id: string;
   relation?: Relation;
   type?: string;
+  disposition?: Disposition;
   filter?: (node: Node) => node is Node<T>;
   resolver?: ResolverExtension;
   connector?: ConnectorExtension<GuardedNodeType<CreateExtensionOptions<T>['filter']>>;
@@ -71,15 +75,16 @@ export type CreateExtensionOptions<T = any> = {
  * Create a graph builder extension.
  */
 export const createExtension = <T = any>(extension: CreateExtensionOptions<T>): BuilderExtension[] => {
-  const { id, resolver, connector, actions, actionGroups, ...rest } = extension;
+  const { id, disposition = 'static', resolver, connector, actions, actionGroups, ...rest } = extension;
   const getId = (key: string) => `${id}/${key}`;
   return [
-    resolver ? { id: getId('resolver'), resolver } : undefined,
-    connector ? { ...rest, id: getId('connector'), connector } : undefined,
+    resolver ? { id: getId('resolver'), disposition, resolver } : undefined,
+    connector ? { ...rest, id: getId('connector'), disposition, connector } : undefined,
     actionGroups
       ? ({
           ...rest,
           id: getId('actionGroups'),
+          disposition,
           type: ACTION_GROUP_TYPE,
           relation: 'outbound',
           connector: ({ node }) =>
@@ -90,6 +95,7 @@ export const createExtension = <T = any>(extension: CreateExtensionOptions<T>):
       ? ({
           ...rest,
           id: getId('actions'),
+          disposition,
           type: ACTION_TYPE,
           relation: 'outbound',
           connector: ({ node }) => actions({ node })?.map((arg) => ({ ...arg, type: ACTION_TYPE })),
@@ -166,15 +172,16 @@ export const toSignal = <T>(
   return thisSignal.value;
 };
 
-export type BuilderExtension = {
+export type BuilderExtension = Readonly<{
   id: string;
+  disposition: Disposition;
   resolver?: ResolverExtension;
   connector?: ConnectorExtension;
   // Only for connector.
   relation?: Relation;
   type?: string;
   filter?: (node: Node) => boolean;
-};
+}>;
 
 type ExtensionArg = BuilderExtension | BuilderExtension[] | ExtensionArg[];
 
@@ -221,7 +228,16 @@ export class GraphBuilder {
       .filter((id) => id !== ROOT_ID)
       .forEach((id) => (this._initialized[id] = new Trigger()));
     Object.keys(this._graph._nodes).forEach((id) => this._onInitialNode(id));
-    await Promise.all(Object.values(this._initialized).map((trigger) => trigger.wait()));
+    await Promise.all(
+      Object.entries(this._initialized).map(async ([id, trigger]) => {
+        try {
+          await trigger.wait({ timeout: NODE_RESOLVER_TIMEOUT });
+        } catch {
+          log.error('node resolver timeout', { id });
+          this.graph._removeNodes([id]);
+        }
+      }),
+    );
   }
 
   get graph() {
@@ -310,7 +326,8 @@ export class GraphBuilder {
     this._resolverSubscriptions.set(
       nodeId,
       effect(() => {
-        for (const { id, resolver } of Object.values(this._extensions)) {
+        const extensions = Object.values(this._extensions).toSorted(byDisposition);
+        for (const { id, resolver } of extensions) {
           if (!resolver) {
             continue;
           }
@@ -367,7 +384,8 @@ export class GraphBuilder {
 
         // TODO(wittjosiah): Consider allowing extensions to collaborate on the same node by merging their results.
         const nodes: NodeArg<any>[] = [];
-        for (const { id, connector, filter, type, relation = 'outbound' } of Object.values(this._extensions)) {
+        const extensions = Object.values(this._extensions).toSorted(byDisposition);
+        for (const { id, connector, filter, type, relation = 'outbound' } of extensions) {
           if (
             !connector ||
             relation !== nodesRelation ||

package/src/graph.ts

@@ -13,7 +13,7 @@ import { type MakeOptional, nonNullable, pick } from '@dxos/util';
 import { type Node, type NodeArg, type NodeFilter, type Relation, actionGroupSymbol, isActionLike } from './node';
 
 const graphSymbol = Symbol('graph');
-type DeepWriteable<T> = { -readonly [K in keyof T]: DeepWriteable<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 };
 
 export const getGraph = (node: Node): Graph => {
@@ -319,7 +319,6 @@ export class Graph {
 
       const nodes = this._getNodes({ node, relation, expansion });
       const nodeSubscriptions = nodes.map((n) => this.subscribeTraverse({ node: n, visitor, expansion }, path));
-
       return () => {
         nodeSubscriptions.forEach((unsubscribe) => unsubscribe());
       };

package/src/node.ts

@@ -87,9 +87,9 @@ export const isAction = (data: unknown): data is Action =>
 
 export const actionGroupSymbol = Symbol('ActionGroup');
 
-export type ActionGroup = Readonly<
-  Omit<Node<typeof actionGroupSymbol, Record<string, any>>, 'properties'> & {
-    properties: Readonly<Record<string, any>>;
+export type ActionGroup<TProperties extends Record<string, any> = Record<string, any>> = Readonly<
+  Omit<Node<typeof actionGroupSymbol, TProperties>, 'properties'> & {
+    properties: Readonly<TProperties>;
   }
 >;