@dxos/compute 0.8.4-main.e098934 → 0.8.4-main.ead640a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/compute",
-  "version": "0.8.4-main.e098934",
+  "version": "0.8.4-main.ead640a",
   "description": "Low-level compute API",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -35,32 +35,32 @@
     "src"
   ],
   "dependencies": {
-    "@preact/signals-core": "^1.9.0",
-    "effect": "3.17.7",
+    "@preact/signals-core": "^1.12.1",
+    "effect": "3.18.3",
     "lodash.defaultsdeep": "^4.6.1",
-    "@dxos/async": "0.8.4-main.e098934",
-    "@dxos/context": "0.8.4-main.e098934",
-    "@dxos/client": "0.8.4-main.e098934",
-    "@dxos/debug": "0.8.4-main.e098934",
-    "@dxos/echo-db": "0.8.4-main.e098934",
-    "@dxos/echo-schema": "0.8.4-main.e098934",
-    "@dxos/functions": "0.8.4-main.e098934",
-    "@dxos/invariant": "0.8.4-main.e098934",
-    "@dxos/echo": "0.8.4-main.e098934",
-    "@dxos/live-object": "0.8.4-main.e098934",
-    "@dxos/keys": "0.8.4-main.e098934",
-    "@dxos/log": "0.8.4-main.e098934",
-    "@dxos/protocols": "0.8.4-main.e098934",
-    "@dxos/schema": "0.8.4-main.e098934",
-    "@dxos/vendor-hyperformula": "0.8.4-main.e098934",
-    "@dxos/util": "0.8.4-main.e098934"
+    "@dxos/ai": "0.8.4-main.ead640a",
+    "@dxos/async": "0.8.4-main.ead640a",
+    "@dxos/client": "0.8.4-main.ead640a",
+    "@dxos/context": "0.8.4-main.ead640a",
+    "@dxos/echo": "0.8.4-main.ead640a",
+    "@dxos/debug": "0.8.4-main.ead640a",
+    "@dxos/functions": "0.8.4-main.ead640a",
+    "@dxos/keys": "0.8.4-main.ead640a",
+    "@dxos/live-object": "0.8.4-main.ead640a",
+    "@dxos/invariant": "0.8.4-main.ead640a",
+    "@dxos/log": "0.8.4-main.ead640a",
+    "@dxos/plugin-automation": "0.8.4-main.ead640a",
+    "@dxos/protocols": "0.8.4-main.ead640a",
+    "@dxos/schema": "0.8.4-main.ead640a",
+    "@dxos/util": "0.8.4-main.ead640a",
+    "@dxos/vendor-hyperformula": "0.8.4-main.ead640a"
   },
   "devDependencies": {
     "@tldraw/indices": "^2.0.0-alpha.14",
     "@types/lodash.defaultsdeep": "^4.6.6",
-    "@dxos/echo-db": "0.8.4-main.e098934",
-    "@dxos/random": "0.8.4-main.e098934",
-    "@dxos/echo-schema": "0.8.4-main.e098934"
+    "@dxos/echo": "0.8.4-main.ead640a",
+    "@dxos/echo-db": "0.8.4-main.ead640a",
+    "@dxos/random": "0.8.4-main.ead640a"
   },
   "peerDependencies": {
     "effect": "^3.13.3"

package/src/compute-graph-registry.test.ts

@@ -0,0 +1,138 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import { describe, expect, onTestFinished, test } from 'vitest';
+
+import { Trigger } from '@dxos/async';
+import { fullyQualifiedId } from '@dxos/client/echo';
+import { FunctionDefinition, FunctionType } from '@dxos/functions';
+
+import { ComputeGraphRegistry, defaultPlugins } from './compute-graph-registry';
+import { TestBuilder, createMockedComputeRuntimeProvider } from './testing';
+
+describe('ComputeGraphRegistry', () => {
+  const add = FunctionDefinition.make({
+    key: 'add',
+    name: 'add',
+    description: 'Adds two numbers',
+    inputSchema: Schema.Struct({ a: Schema.Number, b: Schema.Number }),
+    outputSchema: Schema.Number,
+    handler: ({ data }) => data.a + data.b,
+  });
+
+  test('invokes user function through compute graph', async () => {
+    const computeRuntime = createMockedComputeRuntimeProvider({ functions: [add] });
+    const testBuilder = new TestBuilder({ types: [FunctionType], computeRuntime });
+    await testBuilder.open();
+    onTestFinished(async () => {
+      await testBuilder.close();
+    });
+
+    const space = await testBuilder.client.spaces.create();
+
+    // Register Edge function plugin and runtime in the registry.
+    const registry = new ComputeGraphRegistry({ plugins: defaultPlugins, computeRuntime });
+    await registry.open();
+    onTestFinished(async () => {
+      await registry.close();
+    });
+
+    const graph = registry.createGraph(space);
+    await graph.open();
+    onTestFinished(async () => {
+      await graph.close();
+    });
+
+    // Create a function object in ECHO with binding that maps to DX calls.
+    const functionObj = FunctionDefinition.serialize(add);
+    functionObj.binding = 'ADD';
+    space.db.add(functionObj);
+
+    const node = await graph.getOrCreateNode('sheet').open();
+
+    // Wait for value update after async invocation completes.
+    const trigger = new Trigger<number>();
+    node.update.on(() => {
+      const value = node.getValue({ row: 0, col: 0 });
+      if (typeof value === 'number') {
+        trigger.wake(value);
+      }
+    });
+
+    // Set formula using binding; graph will map to DX("ADD", ...)
+    node.setValue({ row: 0, col: 0 }, '=ADD(2, 3)');
+
+    const result = await trigger.wait();
+    expect(result).to.equal(5);
+
+    // Sanity check: mapping to fully qualified id works as well.
+    const bindingId = graph.mapFunctionBindingToId('ADD(2, 3)');
+    expect(bindingId.startsWith(`${fullyQualifiedId(functionObj)}`)).to.be.true;
+  });
+
+  test('adding a function binding updates autocomplete and enables execution', async () => {
+    const computeRuntime = createMockedComputeRuntimeProvider({ functions: [add] });
+    const testBuilder = new TestBuilder({ types: [FunctionType], computeRuntime });
+    await testBuilder.open();
+    onTestFinished(async () => {
+      await testBuilder.close();
+    });
+
+    const space = await testBuilder.client.spaces.create();
+
+    const registry = new ComputeGraphRegistry({ plugins: defaultPlugins, computeRuntime });
+    await registry.open();
+    onTestFinished(async () => {
+      await registry.close();
+    });
+
+    const graph = registry.createGraph(space);
+    await graph.open();
+    onTestFinished(async () => {
+      await graph.close();
+    });
+
+    // Initially there should be no echo functions.
+    expect(graph.getFunctions({ standard: false, echo: true }).length).to.equal(0);
+
+    // Subscribe for function updates.
+    const functionsUpdated = new Trigger<void>();
+    const unsubscribe = graph.update.on((e) => {
+      if (e.type === 'functionsUpdated') {
+        functionsUpdated.wake();
+      }
+    });
+    onTestFinished(unsubscribe);
+
+    // Add a bound function to the space; graph should pick it up.
+    const functionObj = FunctionDefinition.serialize(add);
+    functionObj.binding = 'ADD';
+    space.db.add(functionObj);
+
+    await functionsUpdated.wait();
+
+    // Autocomplete should now include the binding.
+    const echoFunctions = graph.getFunctions({ standard: false, echo: true }).map((f) => f.name);
+    expect(echoFunctions).toContain('ADD');
+
+    // And the binding should execute when used in a formula.
+    const node = await graph.getOrCreateNode('sheet').open();
+    onTestFinished(async () => {
+      await node.close();
+    });
+
+    const valueSettled = new Trigger<number>();
+    node.update.on(() => {
+      const value = node.getValue({ row: 0, col: 0 });
+      if (typeof value === 'number') {
+        valueSettled.wake(value);
+      }
+    });
+
+    node.setValue({ row: 0, col: 0 }, '=ADD(2, 3)');
+    const result = await valueSettled.wait();
+    expect(result).to.equal(5);
+  });
+});

package/src/compute-graph-registry.ts

@@ -2,10 +2,12 @@
 // Copyright 2024 DXOS.org
 //
 
+import type * as ManagedRuntime from 'effect/ManagedRuntime';
 import defaultsDeep from 'lodash.defaultsdeep';
 
 import { type Space, type SpaceId } from '@dxos/client/echo';
 import { Resource } from '@dxos/context';
+import { type FunctionInvocationService } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import type { ConfigParams, FunctionPluginDefinition, FunctionTranslationsPackage } from '@dxos/vendor-hyperformula';
@@ -19,15 +21,16 @@ export type ComputeGraphPlugin = {
   translations: FunctionTranslationsPackage;
 };
 
+export type FunctionsRuntimeProvider = {
+  getRuntime(spaceId: SpaceId): ManagedRuntime.ManagedRuntime<FunctionInvocationService, never>;
+};
+
 export type ComputeGraphOptions = {
   plugins?: ComputeGraphPlugin[];
+  computeRuntime: FunctionsRuntimeProvider;
 } & Partial<FunctionContextOptions> &
   Partial<ConfigParams>;
 
-export const defaultOptions: ComputeGraphOptions = {
-  licenseKey: 'gpl-v3',
-};
-
 export const defaultPlugins: ComputeGraphPlugin[] = [
   {
     plugin: EdgeFunctionPlugin,
@@ -35,23 +38,26 @@ export const defaultPlugins: ComputeGraphPlugin[] = [
   },
 ];
 
+export const defaultOptions: Partial<ComputeGraphOptions> = {
+  licenseKey: 'gpl-v3',
+};
+
 /**
  * Manages a collection of ComputeGraph instances for each space.
  *
  * [ComputePlugin] => [ComputeGraphRegistry] => [ComputeGraph(Space)] => [ComputeNode(Object)]
  *
  * NOTE: The ComputeGraphRegistry manages the hierarchy of resources via its root Context.
- * NOTE: The package.json file defines the packaged #hyperformula module.
  */
 // TODO(burdon): Move graph into separate plugin; isolate HF deps.
 export class ComputeGraphRegistry extends Resource {
   private readonly _graphs = new Map<SpaceId, ComputeGraph>();
-
   private readonly _options: ComputeGraphOptions;
 
-  constructor(options: ComputeGraphOptions = { plugins: defaultPlugins }) {
+  constructor(options: ComputeGraphOptions) {
     super();
     this._options = defaultsDeep({}, options, defaultOptions);
+    this._options.plugins = this._options.plugins ?? defaultPlugins;
     this._options.plugins?.forEach(({ plugin, translations }) => {
       HyperFormula.registerFunctionPlugin(plugin, translations);
     });
@@ -74,7 +80,10 @@ export class ComputeGraphRegistry extends Resource {
   createGraph(space: Space): ComputeGraph {
     invariant(!this._graphs.has(space.id), `ComputeGraph already exists for space: ${space.id}`);
     const hf = HyperFormula.buildEmpty(this._options);
-    const graph = new ComputeGraph(hf, space, this._options);
+    invariant(this._options.computeRuntime, 'ComputeRuntime is required');
+    const runtime = this._options.computeRuntime.getRuntime(space.id);
+
+    const graph = new ComputeGraph(hf, runtime, space, this._options);
     this._graphs.set(space.id, graph);
     return graph;
   }

package/src/compute-graph.ts

@@ -2,17 +2,19 @@
 // Copyright 2024 DXOS.org
 //
 
+import type * as ManagedRuntime from 'effect/ManagedRuntime';
+
 import { Event } from '@dxos/async';
 import { Filter, type Space, fullyQualifiedId } from '@dxos/client/echo';
 import { FQ_ID_LENGTH } from '@dxos/client/echo';
 import { Resource } from '@dxos/context';
-import { getTypename } from '@dxos/echo-schema';
-import { FunctionType } from '@dxos/functions';
+import { getTypename } from '@dxos/echo/internal';
+import { type FunctionInvocationService, FunctionType } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { isNonNullable } from '@dxos/util';
-import { type Listeners } from '@dxos/vendor-hyperformula';
+import type { Listeners } from '@dxos/vendor-hyperformula';
 import { ExportedCellChange, type HyperFormula } from '@dxos/vendor-hyperformula';
 
 import { ComputeNode } from './compute-node';
@@ -67,12 +69,13 @@ export class ComputeGraph extends Resource {
 
   constructor(
     private readonly _hf: HyperFormula,
+    private readonly _runtime: ManagedRuntime.ManagedRuntime<FunctionInvocationService, never>,
     private readonly _space?: Space,
     private readonly _options?: Partial<FunctionContextOptions>,
   ) {
     super();
 
-    this.context = new FunctionContext(this._hf, this._space, {
+    this.context = new FunctionContext(this._hf, this._runtime, this._space, {
       ...this._options,
       onUpdate: (update) => {
         this._options?.onUpdate?.(update);

package/src/functions/async-function.ts

@@ -2,15 +2,17 @@
 // Copyright 2024 DXOS.org
 //
 
+import type * as ManagedRuntime from 'effect/ManagedRuntime';
 import defaultsDeep from 'lodash.defaultsdeep';
 
 import { type CleanupFn, debounce } from '@dxos/async';
-import { type Space } from '@dxos/client/echo';
+import type { Space } from '@dxos/client/echo';
+import { type FunctionInvocationService } from '@dxos/functions';
 import { log } from '@dxos/log';
-import { type RawInterpreterValue, type SimpleCellAddress } from '@dxos/vendor-hyperformula';
-import { type InterpreterState } from '@dxos/vendor-hyperformula';
-import { type InterpreterValue } from '@dxos/vendor-hyperformula';
-import { type ProcedureAst } from '@dxos/vendor-hyperformula';
+import type { RawInterpreterValue, SimpleCellAddress } from '@dxos/vendor-hyperformula';
+import type { InterpreterState } from '@dxos/vendor-hyperformula';
+import type { InterpreterValue } from '@dxos/vendor-hyperformula';
+import type { ProcedureAst } from '@dxos/vendor-hyperformula';
 import { CellError, EmptyValue, ErrorType, FunctionPlugin, type HyperFormula } from '@dxos/vendor-hyperformula';
 
 // TODO(burdon): Create API gateways:
@@ -33,14 +35,12 @@ export type FunctionOptions = {
 export type FunctionContextOptions = {
   defaultTtl: number;
   debounceDelay: number;
-  remoteFunctionUrl: string;
   onUpdate?: (update: FunctionUpdateEvent) => void;
 };
 
-export const defaultFunctionContextOptions: FunctionContextOptions = {
+export const defaultFunctionContextOptions: Pick<FunctionContextOptions, 'defaultTtl' | 'debounceDelay'> = {
   defaultTtl: 5_000,
   debounceDelay: 200,
-  remoteFunctionUrl: 'https://edge.dxos.workers.dev/functions', // TODO(burdon): Config.
 };
 
 /**
@@ -77,6 +77,7 @@ export class FunctionContext {
 
   constructor(
     private readonly _hf: HyperFormula,
+    private readonly _runtime: ManagedRuntime.ManagedRuntime<FunctionInvocationService, never>,
     private readonly _space: Space | undefined,
     _options?: Partial<FunctionContextOptions>,
   ) {
@@ -93,14 +94,14 @@ export class FunctionContext {
     return this._space;
   }
 
-  get remoteFunctionUrl() {
-    return this._options.remoteFunctionUrl;
-  }
-
   get info() {
     return { cache: this._cache.size, invocations: this._invocations };
   }
 
+  get runtime() {
+    return this._runtime;
+  }
+
   flush(): void {
     this._cache.clear();
     this._invocations = {};

package/src/functions/edge-function.ts

@@ -3,11 +3,13 @@
 //
 
 import { effect } from '@preact/signals-core';
-import { SchemaAST } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as SchemaAST from 'effect/SchemaAST';
 
-import { Filter, getMeta } from '@dxos/client/echo';
-import { toEffectSchema } from '@dxos/echo-schema';
-import { FunctionType, getUserFunctionIdInMetadata } from '@dxos/functions';
+import { Filter } from '@dxos/client/echo';
+import { toEffectSchema } from '@dxos/echo/internal';
+import { ComputeEventLogger, FunctionInvocationService, FunctionType, TracingService } from '@dxos/functions';
+import { FunctionDefinition } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { isNonNullable } from '@dxos/util';
 import { type ProcedureAst } from '@dxos/vendor-hyperformula';
@@ -55,25 +57,26 @@ export class EdgeFunctionPlugin extends AsyncFunctionPlugin {
           this.context.createSubscription(ast.procedureName, unsubscribe);
         }
 
-        const body: Record<string, any> = {};
+        const runtime = this.context.runtime;
+        const functionDef = FunctionDefinition.deserialize(fn);
+        // If input schema exists, construct an object from args using the schema props order, otherwise pass { args }.
+        let input: any;
         if (fn.inputSchema) {
           const schema = toEffectSchema(fn.inputSchema);
-          SchemaAST.getPropertySignatures(schema.ast).forEach(({ name }, index) => {
-            body[name.toString()] = args[index];
+          const props = SchemaAST.getPropertySignatures(schema.ast);
+          input = {} as any;
+          props.forEach(({ name }, index) => {
+            input[name.toString()] = args[index];
           });
         } else {
-          body.args = args.filter(isNonNullable);
+          input = { args: args.filter(isNonNullable) };
         }
-        const id = getUserFunctionIdInMetadata(getMeta(fn));
-        const response = await fetch(`${this.context.remoteFunctionUrl}/${id}`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(body),
-        });
-        const result = await response.text();
-        log('function executed', { result });
-
-        return result;
+        const result = runtime.runPromise(
+          Effect.gen(function* () {
+            return yield* FunctionInvocationService.invokeFunction(functionDef, input);
+          }).pipe(Effect.provide(ComputeEventLogger.layerFromTracing), Effect.provide(TracingService.layerNoop)),
+        );
+        return result as any;
       };
 
     return this.runAsyncFunction(ast, state, handler(true), { ttl: FUNCTION_TTL });

package/src/testing/index.ts

@@ -5,3 +5,4 @@
 export * from './test-builder';
 export * from './test-plugin';
 export * from './util';
+export * from './test-runtime';

package/src/testing/test-builder.ts

@@ -8,7 +8,9 @@ import { invariant } from '@dxos/invariant';
 
 import { type ComputeGraphOptions, ComputeGraphRegistry } from '../compute-graph-registry';
 
-export type TestBuilderOptions = ClientOptions & ComputeGraphOptions;
+import { createMockedComputeRuntimeProvider } from './test-runtime';
+
+export type TestBuilderOptions = ClientOptions & Partial<ComputeGraphOptions>;
 
 // TODO(burdon): Reconcile with @dxos/client/testing.
 export class TestBuilder extends Resource {
@@ -43,7 +45,11 @@ export class TestBuilder extends Resource {
       this._client = undefined;
     });
 
-    const registry = new ComputeGraphRegistry(this._options);
+    const registry = new ComputeGraphRegistry({
+      ...this._options,
+      // Provide a default runtime provider for tests if not supplied.
+      computeRuntime: this._options.computeRuntime ?? createMockedComputeRuntimeProvider(),
+    });
     await registry.open();
     this._registry = registry;
     this._ctx.onDispose(async () => {

package/src/testing/test-runtime.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Layer from 'effect/Layer';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
+
+import { AiService } from '@dxos/ai';
+import { type SpaceId } from '@dxos/client/echo';
+import {
+  CredentialsService,
+  DatabaseService,
+  type FunctionDefinition,
+  FunctionInvocationService,
+  QueueService,
+} from '@dxos/functions';
+
+import { type FunctionsRuntimeProvider } from '../compute-graph-registry';
+
+/**
+ * Minimal compute runtime provider for tests and Storybook.
+ * Will cause errors if used for actual runtime.
+ */
+export const createMockedComputeRuntimeProvider = ({
+  functions,
+}: { functions?: FunctionDefinition<any, any>[] } = {}): FunctionsRuntimeProvider => {
+  return {
+    getRuntime: (_spaceId: SpaceId) =>
+      ManagedRuntime.make(
+        FunctionInvocationService.layerTest({ functions }).pipe(
+          Layer.provide(AiService.notAvailable),
+          Layer.provide(CredentialsService.configuredLayer([])),
+          Layer.provide(DatabaseService.notAvailable),
+          Layer.provide(QueueService.notAvailable),
+        ),
+      ),
+  };
+};