@dxos/functions 0.8.4-main.dedc0f3 → 0.8.4-main.e8ec1fe

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.4-main.dedc0f3",
-  "description": "Functions API and runtime.",
+  "version": "0.8.4-main.e8ec1fe",
+  "description": "Functions API.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
   "license": "MIT",
@@ -14,83 +14,29 @@
       "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.dedc0f3",
-    "@dxos/async": "0.8.4-main.dedc0f3",
-    "@dxos/context": "0.8.4-main.dedc0f3",
-    "@dxos/client": "0.8.4-main.dedc0f3",
-    "@dxos/client-protocol": "0.8.4-main.dedc0f3",
-    "@dxos/crypto": "0.8.4-main.dedc0f3",
-    "@dxos/debug": "0.8.4-main.dedc0f3",
-    "@dxos/echo-db": "0.8.4-main.dedc0f3",
-    "@dxos/echo": "0.8.4-main.dedc0f3",
-    "@dxos/echo-pipeline": "0.8.4-main.dedc0f3",
-    "@dxos/echo-protocol": "0.8.4-main.dedc0f3",
-    "@dxos/echo-schema": "0.8.4-main.dedc0f3",
-    "@dxos/edge-client": "0.8.4-main.dedc0f3",
-    "@dxos/invariant": "0.8.4-main.dedc0f3",
-    "@dxos/effect": "0.8.4-main.dedc0f3",
-    "@dxos/errors": "0.8.4-main.dedc0f3",
-    "@dxos/keys": "0.8.4-main.dedc0f3",
-    "@dxos/kv-store": "0.8.4-main.dedc0f3",
-    "@dxos/live-object": "0.8.4-main.dedc0f3",
-    "@dxos/log": "0.8.4-main.dedc0f3",
-    "@dxos/node-std": "0.8.4-main.dedc0f3",
-    "@dxos/protocols": "0.8.4-main.dedc0f3",
-    "@dxos/util": "0.8.4-main.dedc0f3",
-    "@dxos/schema": "0.8.4-main.dedc0f3"
-  },
-  "devDependencies": {
-    "@types/express": "^4.17.17",
-    "@types/ws": "^7.4.0",
-    "@dxos/agent": "0.8.4-main.dedc0f3"
+    "@effect/platform": "0.92.1",
+    "effect": "3.18.3",
+    "@dxos/ai": "0.8.4-main.e8ec1fe",
+    "@dxos/echo-db": "0.8.4-main.e8ec1fe",
+    "@dxos/effect": "0.8.4-main.e8ec1fe",
+    "@dxos/errors": "0.8.4-main.e8ec1fe",
+    "@dxos/invariant": "0.8.4-main.e8ec1fe",
+    "@dxos/echo": "0.8.4-main.e8ec1fe",
+    "@dxos/keys": "0.8.4-main.e8ec1fe",
+    "@dxos/node-std": "0.8.4-main.e8ec1fe",
+    "@dxos/log": "0.8.4-main.e8ec1fe",
+    "@dxos/schema": "0.8.4-main.e8ec1fe",
+    "@dxos/types": "0.8.4-main.e8ec1fe",
+    "@dxos/protocols": "0.8.4-main.e8ec1fe"
   },
   "publishConfig": {
     "access": "public"

package/src/errors.ts

@@ -2,20 +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 FunctionNotFoundError extends BaseError.extend('FUNCTION_NOT_FOUND') {
-  constructor(functionKey: string) {
-    super(`Function not found: ${functionKey}`);
+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') {}
+export class FunctionError extends BaseError.extend('FUNCTION_ERROR', 'Function invocation error') {}
 
-export class TriggerStateNotFoundError extends BaseError.extend('TRIGGER_STATE_NOT_FOUND') {}
+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

@@ -3,12 +3,8 @@
 //
 
 export * from './errors';
-export * from './handler';
-export * from './schema';
-export * from './trace';
-export * from './types';
-export * from './url';
-export * from './triggers';
+export * from './example';
+export * from './sdk';
 export * from './services';
-export * from './executor';
-export * as exampleFunctions from './examples';
+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,145 @@
+//
+// 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 { Type } from '@dxos/echo';
+import { EchoClient } from '@dxos/echo-db';
+import { acquireReleaseResource } from '@dxos/effect';
+import { 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',
+        });
+      }
+
+      try {
+        if (!SchemaAST.isAnyKeyword(func.inputSchema.ast)) {
+          Schema.validateSync(func.inputSchema)(data);
+        }
+
+        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(createServiceLayer(context)),
+            ),
+          );
+        }
+
+        if (func.outputSchema && !SchemaAST.isAnyKeyword(func.outputSchema.ast)) {
+          Schema.validateSync(func.outputSchema)(result);
+        }
+
+        return result;
+      } catch (error) {
+        if (FunctionError.is(error)) {
+          throw error;
+        } else {
+          throw new FunctionError({
+            cause: error,
+            context: { func: func.key },
+          });
+        }
+      }
+    },
+  };
+};
+
+/**
+ * Creates a layer of services for the function.
+ */
+const createServiceLayer = (context: FunctionProtocol.Context): Layer.Layer<FunctionServices> => {
+  return Layer.unwrapScoped(
+    Effect.gen(function* () {
+      let client: EchoClient | undefined;
+
+      if (context.services.dataService && context.services.queryService) {
+        client = yield* acquireReleaseResource(() => {
+          invariant(context.services.dataService && context.services.queryService);
+          // TODO(dmaretskyi): Queues service.
+          return new EchoClient().connectToService({
+            dataService: context.services.dataService,
+            queryService: context.services.queryService,
+            queueService: context.services.queueService,
+          });
+        });
+      }
+
+      const db =
+        client && context.spaceId
+          ? yield* acquireReleaseResource(() =>
+              client.constructDatabase({
+                spaceId: context.spaceId ?? failedInvariant(),
+                spaceKey: PublicKey.fromHex(context.spaceKey ?? failedInvariant('spaceKey missing in context')),
+                reactiveSchemaQuery: false,
+              }),
+            )
+          : undefined;
+
+      if (db) {
+        console.log('Setting space root', context.spaceRootUrl);
+        yield* Effect.promise(() =>
+          db!.setSpaceRoot(context.spaceRootUrl ?? failedInvariant('spaceRootUrl missing in context')),
+        );
+      }
+
+      const queues = client && context.spaceId ? client.constructQueueFactory(context.spaceId) : undefined;
+
+      const dbLayer = db ? DatabaseService.layer(db) : DatabaseService.notAvailable;
+      const queuesLayer = queues ? QueueService.layer(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.'),
+});