@dxos/functions 0.8.4-main.5ea62a8 → 0.8.4-main.66e292d

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.4-main.5ea62a8",
-  "description": "Functions API and runtime.",
+  "version": "0.8.4-main.66e292d",
+  "description": "Functions API.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
   "license": "MIT",
@@ -14,87 +14,33 @@
       "types": "./dist/types/src/index.d.ts",
       "browser": "./dist/lib/browser/index.mjs",
       "node": "./dist/lib/node-esm/index.mjs"
-    },
-    "./bundler": {
-      "source": "./src/bundler/index.ts",
-      "types": "./dist/types/src/bundler/index.d.ts",
-      "browser": "./dist/lib/browser/bundler/index.mjs",
-      "node": "./dist/lib/node-esm/bundler/index.mjs"
-    },
-    "./edge": {
-      "source": "./src/edge/index.ts",
-      "types": "./dist/types/src/edge/index.d.ts",
-      "browser": "./dist/lib/browser/edge/index.mjs",
-      "node": "./dist/lib/node-esm/edge/index.mjs"
-    },
-    "./testing": {
-      "source": "./src/testing/index.ts",
-      "types": "./dist/types/src/testing/index.d.ts",
-      "browser": "./dist/lib/browser/testing/index.mjs",
-      "node": "./dist/lib/node-esm/testing/index.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "bundler": [
-        "dist/types/src/bundler/index.d.ts"
-      ],
-      "edge": [
-        "dist/types/src/edge/index.d.ts"
-      ]
-    }
-  },
   "files": [
     "dist",
     "schema",
     "src"
   ],
   "dependencies": {
-    "@effect/platform": "0.90.2",
-    "@preact/signals-core": "^1.9.0",
-    "cron": "^3.1.6",
-    "cron-schedule": "^5.0.4",
-    "effect": "3.17.7",
-    "esbuild-wasm": "^0.16.14",
-    "express": "^4.19.2",
-    "get-port-please": "^3.1.1",
-    "i18next": "^24.2.1",
-    "iso-did": "^1.6.0",
-    "ws": "^8.14.2",
-    "@dxos/ai": "0.8.4-main.5ea62a8",
-    "@dxos/async": "0.8.4-main.5ea62a8",
-    "@dxos/context": "0.8.4-main.5ea62a8",
-    "@dxos/client": "0.8.4-main.5ea62a8",
-    "@dxos/crypto": "0.8.4-main.5ea62a8",
-    "@dxos/debug": "0.8.4-main.5ea62a8",
-    "@dxos/echo-db": "0.8.4-main.5ea62a8",
-    "@dxos/echo-pipeline": "0.8.4-main.5ea62a8",
-    "@dxos/echo-schema": "0.8.4-main.5ea62a8",
-    "@dxos/echo": "0.8.4-main.5ea62a8",
-    "@dxos/echo-protocol": "0.8.4-main.5ea62a8",
-    "@dxos/edge-client": "0.8.4-main.5ea62a8",
-    "@dxos/effect": "0.8.4-main.5ea62a8",
-    "@dxos/errors": "0.8.4-main.5ea62a8",
-    "@dxos/invariant": "0.8.4-main.5ea62a8",
-    "@dxos/keys": "0.8.4-main.5ea62a8",
-    "@dxos/kv-store": "0.8.4-main.5ea62a8",
-    "@dxos/live-object": "0.8.4-main.5ea62a8",
-    "@dxos/log": "0.8.4-main.5ea62a8",
-    "@dxos/protocols": "0.8.4-main.5ea62a8",
-    "@dxos/schema": "0.8.4-main.5ea62a8",
-    "@dxos/util": "0.8.4-main.5ea62a8",
-    "@dxos/node-std": "0.8.4-main.5ea62a8"
-  },
-  "devDependencies": {
-    "@types/express": "^4.17.17",
-    "@types/ws": "^7.4.0",
-    "@dxos/agent": "0.8.4-main.5ea62a8"
+    "@effect/platform": "0.92.1",
+    "effect": "3.18.3",
+    "@dxos/ai": "0.8.4-main.66e292d",
+    "@dxos/context": "0.8.4-main.66e292d",
+    "@dxos/echo-db": "0.8.4-main.66e292d",
+    "@dxos/effect": "0.8.4-main.66e292d",
+    "@dxos/echo": "0.8.4-main.66e292d",
+    "@dxos/errors": "0.8.4-main.66e292d",
+    "@dxos/invariant": "0.8.4-main.66e292d",
+    "@dxos/log": "0.8.4-main.66e292d",
+    "@dxos/node-std": "0.8.4-main.66e292d",
+    "@dxos/protocols": "0.8.4-main.66e292d",
+    "@dxos/keys": "0.8.4-main.66e292d",
+    "@dxos/types": "0.8.4-main.66e292d",
+    "@dxos/schema": "0.8.4-main.66e292d"
   },
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "gen-schema": "ts-node ./tools/schema.ts"
-  }
+  "scripts": {}
 }

package/src/errors.ts

@@ -2,12 +2,20 @@
 // Copyright 2025 DXOS.org
 //
 
-import { BaseError } from '@dxos/errors';
+import { BaseError, type BaseErrorOptions } from '@dxos/errors';
 
-export class ServiceNotAvailableError extends BaseError.extend('SERVICE_NOT_AVAILABLE') {
-  constructor(serviceName: string) {
-    super(`Service not available: ${serviceName}`);
+export class ServiceNotAvailableError extends BaseError.extend('SERVICE_NOT_AVAILABLE', 'Service not available') {
+  constructor(service: string, options?: Omit<BaseErrorOptions, 'context'>) {
+    super({ context: { service }, ...options });
   }
 }
 
-export class FunctionError extends BaseError.extend('FUNCTION_ERROR') {}
+export class FunctionNotFoundError extends BaseError.extend('FUNCTION_NOT_FOUND', 'Function not found') {
+  constructor(functionKey: string, options?: Omit<BaseErrorOptions, 'context'>) {
+    super({ context: { function: functionKey }, ...options });
+  }
+}
+
+export class FunctionError extends BaseError.extend('FUNCTION_ERROR', 'Function invocation error') {}
+
+export class TriggerStateNotFoundError extends BaseError.extend('TRIGGER_STATE_NOT_FOUND', 'Trigger state not found') {}

package/src/{examples → example}/fib.ts

@@ -2,12 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect, Schema } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
 
-import { defineFunction } from '../handler';
+import { defineFunction } from '../sdk';
 
 export default defineFunction({
-  name: 'example.org/function/fib',
+  key: 'example.org/function/fib',
+  name: 'Fibonacci',
   description: 'Function that calculates a Fibonacci number',
   inputSchema: Schema.Struct({
     iterations: Schema.optional(Schema.Number).annotations({

package/src/example/forex-effect.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @ts-ignore
+import { S, defineFunction } from 'dxos:functions';
+import {
+  FetchHttpClient,
+  HttpClient,
+  HttpClientRequest,
+  // @ts-ignore
+} from 'https://esm.sh/@effect/platform@0.89.0?deps=effect@3.17.0&bundle=false';
+// @ts-ignore
+import { Effect, Schedule } from 'https://esm.sh/effect@3.17.0?bundle=false';
+
+export default defineFunction({
+  key: 'dxos.org/script/forex-effect',
+  name: 'Forex Effect',
+  description: 'Returns the exchange rate between two currencies.',
+
+  inputSchema: S.Struct({
+    from: S.String.annotations({ description: 'The source currency' }),
+    to: S.String.annotations({ description: 'The target currency' }),
+  }),
+
+  outputSchema: S.String.annotations({ description: 'The exchange rate between the two currencies' }),
+
+  handler: async ({ data: { from, to } }: any) =>
+    Effect.gen(function* () {
+      const res = yield* HttpClientRequest.get(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`).pipe(
+        HttpClient.execute,
+        Effect.flatMap((res: any) => res.json),
+        Effect.timeout('1 second'),
+        Effect.retry(Schedule.exponential(1_000).pipe(Schedule.compose(Schedule.recurs(3)))),
+        Effect.scoped,
+      );
+
+      return res.data.rates[to].toString();
+    }).pipe(Effect.provide(FetchHttpClient.layer)),
+});

package/src/example/index.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { default as fib$ } from './fib';
+import { default as reply$ } from './reply';
+import { default as sleep$ } from './sleep';
+
+export namespace Example {
+  export const fib = fib$;
+  export const reply = reply$;
+  export const sleep = sleep$;
+}

package/src/{examples → example}/reply.ts

@@ -2,12 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Console, Effect, Schema } from 'effect';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
 
-import { defineFunction } from '../handler';
+import { defineFunction } from '../sdk';
 
 export default defineFunction({
-  name: 'example.org/function/reply',
+  key: 'example.org/function/reply',
+  name: 'Reply',
   description: 'Function that echoes the input',
   inputSchema: Schema.Any,
   outputSchema: Schema.Any,

package/src/{examples → example}/sleep.ts

@@ -2,12 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect, Schema } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
 
-import { defineFunction } from '../handler';
+import { defineFunction } from '../sdk';
 
 export default defineFunction({
-  name: 'example.org/function/sleep',
+  key: 'example.org/function/sleep',
+  name: 'Sleep',
   description: 'Function that sleeps for a given amount of time',
   inputSchema: Schema.Struct({
     duration: Schema.optional(Schema.Number).annotations({

package/src/index.ts

@@ -2,13 +2,9 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './handler';
-export * from './schema';
-export * from './trace';
-export * from './types';
-export * from './url';
-export * from './services';
-export * from './executor';
 export * from './errors';
-
-// Blow up cache
+export * from './example';
+export * from './sdk';
+export * from './services';
+export * from './types';
+export * from './protocol';

package/src/{executor → protocol}/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './executor';
+export * from './protocol';

package/src/protocol/protocol.test.ts

@@ -0,0 +1,59 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { FunctionError } from '../errors';
+import fibFunc from '../example/fib';
+import replyFunc from '../example/reply';
+
+import { wrapFunctionHandler } from './protocol';
+
+describe('wrapFunctionHandler', () => {
+  test('wraps reply function and executes handler', async ({ expect }) => {
+    const wrapped = wrapFunctionHandler(replyFunc);
+
+    expect(wrapped.meta.key).toBe('example.org/function/reply');
+    expect(wrapped.meta.name).toBe('Reply');
+
+    const testData = { message: 'hello' };
+    const result = await wrapped.handler({
+      data: testData,
+      context: {
+        services: {},
+      },
+    });
+
+    expect(result).toEqual(testData);
+  });
+
+  test('wraps fibonacci function with valid input', async ({ expect }) => {
+    const wrapped = wrapFunctionHandler(fibFunc);
+
+    expect(wrapped.meta.key).toBe('example.org/function/fib');
+    expect(wrapped.meta.name).toBe('Fibonacci');
+
+    const result = await wrapped.handler({
+      data: { iterations: 10 },
+      context: {
+        services: {},
+      },
+    });
+
+    expect(result).toEqual({ result: '55' });
+  });
+
+  test('throws FunctionError on invalid input schema for fibonacci', async ({ expect }) => {
+    const wrapped = wrapFunctionHandler(fibFunc);
+
+    await expect(
+      wrapped.handler({
+        data: { iterations: 'invalid' },
+        context: {
+          services: {},
+        },
+      }),
+    ).rejects.toThrow(FunctionError);
+  });
+});

package/src/protocol/protocol.ts

@@ -0,0 +1,156 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { AiService } from '@dxos/ai';
+import { LifecycleState, Resource } from '@dxos/context';
+import { Type } from '@dxos/echo';
+import { EchoClient, type EchoDatabaseImpl, type QueueFactory } from '@dxos/echo-db';
+import { assertState, failedInvariant, invariant } from '@dxos/invariant';
+import { PublicKey } from '@dxos/keys';
+import { type FunctionProtocol } from '@dxos/protocols';
+
+import { FunctionError } from '../errors';
+import { FunctionDefinition, type FunctionServices } from '../sdk';
+import { CredentialsService, DatabaseService, FunctionInvocationService, TracingService } from '../services';
+import { QueueService } from '../services';
+
+/**
+ * Wraps a function handler made with `defineFunction` to a protocol that the functions-runtime expects.
+ */
+export const wrapFunctionHandler = (func: FunctionDefinition): FunctionProtocol.Func => {
+  if (!FunctionDefinition.isFunction(func)) {
+    throw new TypeError('Invalid function definition');
+  }
+
+  return {
+    meta: {
+      key: func.key,
+      name: func.name,
+      description: func.description,
+      inputSchema: Type.toJsonSchema(func.inputSchema),
+      outputSchema: func.outputSchema === undefined ? undefined : Type.toJsonSchema(func.outputSchema),
+      services: func.services,
+    },
+    handler: async ({ data, context }) => {
+      if (
+        (func.services.includes(DatabaseService.key) || func.services.includes(QueueService.key)) &&
+        (!context.services.dataService || !context.services.queryService)
+      ) {
+        throw new FunctionError({
+          message: 'Services not provided: dataService, queryService',
+        });
+      }
+
+      // eslint-disable-next-line no-useless-catch
+      try {
+        if (!SchemaAST.isAnyKeyword(func.inputSchema.ast)) {
+          try {
+            Schema.validateSync(func.inputSchema)(data);
+          } catch (error) {
+            throw new FunctionError({ message: 'Invalid input schema', cause: error });
+          }
+        }
+
+        await using funcContext = await new FunctionContext(context).open();
+
+        if (func.types.length > 0) {
+          invariant(funcContext.db, 'Database is required for functions with types');
+          funcContext.db.graph.schemaRegistry.addSchema(func.types);
+        }
+
+        let result = await func.handler({
+          // TODO(dmaretskyi): Fix the types.
+          context: context as any,
+          data,
+        });
+
+        if (Effect.isEffect(result)) {
+          result = await Effect.runPromise(
+            (result as Effect.Effect<unknown, unknown, FunctionServices>).pipe(
+              Effect.orDie,
+              Effect.provide(funcContext.createLayer()),
+            ),
+          );
+        }
+
+        if (func.outputSchema && !SchemaAST.isAnyKeyword(func.outputSchema.ast)) {
+          Schema.validateSync(func.outputSchema)(result);
+        }
+
+        return result;
+      } catch (error) {
+        // TODO(dmaretskyi): We might do error wrapping here and add extra context.
+        throw error;
+      }
+    },
+  };
+};
+
+/**
+ * Container for services and context for a function.
+ */
+class FunctionContext extends Resource {
+  readonly context: FunctionProtocol.Context;
+  readonly client: EchoClient | undefined;
+  db: EchoDatabaseImpl | undefined;
+  queues: QueueFactory | undefined;
+
+  constructor(context: FunctionProtocol.Context) {
+    super();
+    this.context = context;
+    if (context.services.dataService && context.services.queryService) {
+      this.client = new EchoClient().connectToService({
+        dataService: context.services.dataService,
+        queryService: context.services.queryService,
+        queueService: context.services.queueService,
+      });
+    }
+  }
+
+  override async _open() {
+    await this.client?.open();
+    this.db =
+      this.client && this.context.spaceId
+        ? this.client.constructDatabase({
+            spaceId: this.context.spaceId ?? failedInvariant(),
+            spaceKey: PublicKey.fromHex(this.context.spaceKey ?? failedInvariant('spaceKey missing in context')),
+            reactiveSchemaQuery: false,
+          })
+        : undefined;
+
+    await this.db?.setSpaceRoot(this.context.spaceRootUrl ?? failedInvariant('spaceRootUrl missing in context'));
+    await this.db?.open();
+    this.queues =
+      this.client && this.context.spaceId ? this.client.constructQueueFactory(this.context.spaceId) : undefined;
+  }
+
+  override async _close() {
+    await this.db?.close();
+    await this.client?.close();
+  }
+
+  createLayer(): Layer.Layer<FunctionServices> {
+    assertState(this._lifecycleState === LifecycleState.OPEN, 'FunctionContext is not open');
+
+    const dbLayer = this.db ? DatabaseService.layer(this.db) : DatabaseService.notAvailable;
+    const queuesLayer = this.queues ? QueueService.layer(this.queues) : QueueService.notAvailable;
+    const credentials = dbLayer
+      ? CredentialsService.layerFromDatabase().pipe(Layer.provide(dbLayer))
+      : CredentialsService.configuredLayer([]);
+    const functionInvocationService = MockedFunctionInvocationService;
+    const aiService = AiService.notAvailable;
+    const tracing = TracingService.layerNoop;
+
+    return Layer.mergeAll(dbLayer, queuesLayer, credentials, functionInvocationService, aiService, tracing);
+  }
+}
+
+const MockedFunctionInvocationService = Layer.succeed(FunctionInvocationService, {
+  invokeFunction: () => Effect.die('Calling functions from functions is not implemented yet.'),
+});