@dxos/compute 0.8.4-main.f5c0578 → 0.8.4-main.fcfe5033a5

package/src/functions/async-function.ts

@@ -2,17 +2,18 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type SimpleCellAddress } from 'hyperformula/typings/Cell';
-import { type InterpreterState } from 'hyperformula/typings/interpreter/InterpreterState';
-import { type InterpreterValue } from 'hyperformula/typings/interpreter/InterpreterValue';
-import { type ProcedureAst } from 'hyperformula/typings/parser';
+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 { log } from '@dxos/log';
-
-import { CellError, EmptyValue, ErrorType, FunctionPlugin, type HyperFormula } from '#hyperformula';
+import type { Operation } from '@dxos/operation';
+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:
 //  https://publicapis.io
@@ -34,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.
 };
 
 /**
@@ -78,6 +77,7 @@ export class FunctionContext {
 
   constructor(
     private readonly _hf: HyperFormula,
+    private readonly _runtime: ManagedRuntime.ManagedRuntime<Operation.Service, never>,
     private readonly _space: Space | undefined,
     _options?: Partial<FunctionContextOptions>,
   ) {
@@ -94,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 = {};
@@ -169,7 +169,12 @@ export class AsyncFunctionPlugin extends FunctionPlugin {
   /**
    * Immediately returns cached value then runs the async function.
    */
-  protected runAsyncFunction(ast: ProcedureAst, state: InterpreterState, cb: AsyncFunction, options?: FunctionOptions) {
+  protected runAsyncFunction(
+    ast: ProcedureAst,
+    state: InterpreterState,
+    cb: AsyncFunction,
+    options?: FunctionOptions,
+  ): RawInterpreterValue {
     const { procedureName } = ast;
     const metadata = this.metadata(procedureName);
     return this.runFunction(ast.args, state, metadata, (...args: any) => {

package/src/functions/edge-function.ts

@@ -2,18 +2,17 @@
 // Copyright 2024 DXOS.org
 //
 
-import { effect } from '@preact/signals-core';
-import { SchemaAST } from 'effect';
-import { type InterpreterState } from 'hyperformula/typings/interpreter/InterpreterState';
-import { type ProcedureAst } from 'hyperformula/typings/parser';
+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, getUserFunctionUrlInMetadata } from '@dxos/functions';
+import { Filter } from '@dxos/client/echo';
+import { JsonSchema, Obj } from '@dxos/echo';
 import { log } from '@dxos/log';
+import { Operation } from '@dxos/operation';
 import { isNonNullable } from '@dxos/util';
-
-import { CellError, ErrorType, FunctionArgumentType } from '#hyperformula';
+import { type ProcedureAst } from '@dxos/vendor-hyperformula';
+import { type InterpreterState } from '@dxos/vendor-hyperformula';
+import { CellError, ErrorType, FunctionArgumentType } from '@dxos/vendor-hyperformula';
 
 import { type AsyncFunction, AsyncFunctionPlugin } from './async-function';
 
@@ -35,49 +34,46 @@ export class EdgeFunctionPlugin extends AsyncFunctionPlugin {
           return new CellError(ErrorType.REF, 'Missing space');
         }
 
-        const {
-          objects: [fn],
-        } = await space.db.query(Filter.type(FunctionType, { binding })).run();
+        const [fn] = await space.db.query(Filter.type(Operation.PersistentOperation, { binding })).run();
         if (!fn) {
           log.info('Function not found', { binding });
           return new CellError(ErrorType.REF, 'Function not found');
         }
 
         if (subscribe) {
-          const unsubscribe = effect(() => {
+          const unsubscribe = Obj.subscribe(fn, () => {
             log('function changed', { fn });
-            const _ = fn?.version;
-
             // TODO(wittjosiah): `ttl` should be 0 to force a recalculation when a new version is deployed.
             //  This needs a ttl to prevent a binding change from causing the function not to be found.
-            this.runAsyncFunction(ast, state, handler(false), { ttl: FUNCTION_TTL });
+            this.runAsyncFunction(ast, state, handler(false), {
+              ttl: FUNCTION_TTL,
+            });
           });
 
           this.context.createSubscription(ast.procedureName, unsubscribe);
         }
 
-        const body: Record<string, any> = {};
+        const runtime = this.context.runtime;
+        const functionDef = Operation.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 schema = JsonSchema.toEffectSchema(fn.inputSchema);
+          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 path = getUserFunctionUrlInMetadata(getMeta(fn));
-        const response = await fetch(`${this.context.remoteFunctionUrl}${path}`, {
-          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(Operation.invoke(functionDef, input).pipe(Effect.orDie));
+        return result as any;
       };
 
-    return this.runAsyncFunction(ast, state, handler(true), { ttl: FUNCTION_TTL });
+    return this.runAsyncFunction(ast, state, handler(true), {
+      ttl: FUNCTION_TTL,
+    });
   }
 }
 

package/src/hyperformula.test.ts

@@ -4,7 +4,7 @@
 
 import { describe, expect, test } from 'vitest';
 
-import { HyperFormula } from '#hyperformula';
+import { HyperFormula } from '@dxos/vendor-hyperformula';
 
 describe('hyperformula', () => {
   test('sanity test', async () => {

package/src/index.ts

@@ -2,33 +2,6 @@
 // Copyright 2024 DXOS.org
 //
 
-// TODO(burdon): Separate hyperformula (client compute) from remote/edge functions.
-
-// TODO(burdon): Reconcile: types.
-//  - dxos/graph
-//  - dxos/compute
-//  - dxos/functions
-//  - dxos/assistant
-//  - dxos/plugin-automation
-//  - dxos/plugin-script
-//  - dxos/plugin-sheet
-
-// TODO(burdon): Tech debt.
-//  - move hyperformula defs from sheet to compute.
-//  - standard from ./types exports for plugins.
-//  - dxos/agent
-//  - dxos/agent-functions
-//  - dxos/mosaic, dxos-card
-
-// TODO(burdon): Reconcile UX.
-//  - dxos/plugin-explorer
-//  - dxos/plugin-canvas
-//  - dxos/gem-*
-
-// TODO(burdon): Next
-//  - dxos/plugin-search
-//  - dxos/plugin-threads
-
 export * from './compute-graph';
 export * from './compute-graph-registry';
 export * from './compute-node';

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

@@ -7,8 +7,9 @@ import { type Context, Resource } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
 
 import { type ComputeGraphOptions, ComputeGraphRegistry } from '../compute-graph-registry';
+import { createMockedComputeRuntimeProvider } from './test-runtime';
 
-export type TestBuilderOptions = ClientOptions & ComputeGraphOptions;
+export type TestBuilderOptions = ClientOptions & Partial<ComputeGraphOptions>;
 
 // TODO(burdon): Reconcile with @dxos/client/testing.
 export class TestBuilder extends Resource {
@@ -43,7 +44,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-plugin.ts

@@ -2,12 +2,9 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type InterpreterState } from 'hyperformula/typings/interpreter/InterpreterState';
-import { type ProcedureAst } from 'hyperformula/typings/parser';
-
 import { getDeep } from '@dxos/util';
-
-import { FunctionArgumentType } from '#hyperformula';
+import { type InterpreterState, type ProcedureAst } from '@dxos/vendor-hyperformula';
+import { FunctionArgumentType } from '@dxos/vendor-hyperformula';
 
 import { type ComputeGraphPlugin } from '../compute-graph-registry';
 import { type AsyncFunction, AsyncFunctionPlugin } from '../functions';

package/src/testing/test-runtime.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
+
+import { type SpaceId } from '@dxos/client/echo';
+import { Operation, OperationHandlerSet } from '@dxos/operation';
+
+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?: OperationHandlerSet.OperationHandlerSet } = {}): FunctionsRuntimeProvider => {
+  return {
+    getRuntime: (_spaceId: SpaceId) =>
+      ManagedRuntime.make(
+        functions
+          ? Layer.effect(
+              Operation.Service,
+              Effect.gen(function* () {
+                const handlers = yield* functions.handlers;
+                return {
+                  invoke: (op: any, ...args: any[]) => {
+                    const handler = handlers.find((h: any) => h.meta.key === op.meta.key);
+                    if (!handler) {
+                      return Effect.die(`No handler found for operation: ${op.meta.key}`);
+                    }
+                    const result = handler.handler(args[0]);
+                    if (Effect.isEffect(result)) {
+                      return result as Effect.Effect<unknown>;
+                    }
+                    return Effect.promise(() => Promise.resolve(result));
+                  },
+                  schedule: () => Effect.void,
+                  invokePromise: async () => ({ error: new Error('Not implemented in test runtime') }),
+                } as Operation.OperationService;
+              }),
+            )
+          : Layer.succeed(Operation.Service, {
+              invoke: () => Effect.die('Operation.Service not available in test.'),
+              schedule: () => Effect.die('Operation.Service not available in test.'),
+              invokePromise: async () => ({ error: new Error('Not available') }),
+            } as any),
+      ),
+  };
+};

package/src/testing/util.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { HyperFormula } from 'hyperformula';
+import { HyperFormula } from '@dxos/vendor-hyperformula';
 
 export const getRegisteredFunctionNames = () => {
   return HyperFormula.buildEmpty({ licenseKey: 'gpl-v3' }).getRegisteredFunctionNames();

package/src/types/hyperformula.ts

@@ -2,16 +2,16 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type SimpleCellRange } from 'hyperformula/typings/AbsoluteCellRange';
-import { type SimpleCellAddress } from 'hyperformula/typings/Cell';
-import { type SimpleDate, type SimpleDateTime } from 'hyperformula/typings/DateTimeHelper';
-
-// TODO(burdon): Explain special import.
-import { DetailedCellError, ExportedCellChange } from '#hyperformula';
+import {
+  type SimpleCellAddress,
+  type SimpleCellRange,
+  type SimpleDate,
+  type SimpleDateTime,
+} from '@dxos/vendor-hyperformula';
+import { DetailedCellError, ExportedCellChange } from '@dxos/vendor-hyperformula';
 
 /**
- * Hyperformula had issues during bundling with vite,
- * so we pre-bundle hyperformula and place it in the vendor directory of this package.
+ * Re-exported from vendored hyperformula package.
  */
 
 export { DetailedCellError, ExportedCellChange };