@dxos/functions-testing 0.8.4-main.3c1ae3b → 0.8.4-main.422d1c7879

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@dxos/functions-testing",
-  "version": "0.8.4-main.3c1ae3b",
+  "version": "0.8.4-main.422d1c7879",
   "description": "Functions tests",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
   "license": "MIT",
   "author": "info@dxos.org",
   "sideEffects": true,
@@ -21,31 +25,25 @@
     }
   },
   "types": "dist/types/src/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "testing": [
-        "dist/types/src/testing/index.d.ts"
-      ]
-    }
-  },
   "files": [
     "dist",
     "src"
   ],
   "dependencies": {
-    "@effect/platform": "0.92.1",
-    "@dxos/async": "0.8.4-main.3c1ae3b",
-    "@dxos/client": "0.8.4-main.3c1ae3b",
-    "@dxos/functions": "0.8.4-main.3c1ae3b",
-    "@dxos/config": "0.8.4-main.3c1ae3b",
-    "@dxos/echo": "0.8.4-main.3c1ae3b",
-    "@dxos/functions-runtime": "0.8.4-main.3c1ae3b",
-    "@dxos/functions-runtime-cloudflare": "0.8.4-main.3c1ae3b",
-    "@dxos/invariant": "0.8.4-main.3c1ae3b",
-    "@dxos/log": "0.8.4-main.3c1ae3b",
-    "@dxos/protocols": "0.8.4-main.3c1ae3b"
+    "@effect/platform": "0.94.4",
+    "@dxos/async": "0.8.4-main.422d1c7879",
+    "@dxos/config": "0.8.4-main.422d1c7879",
+    "@dxos/client": "0.8.4-main.422d1c7879",
+    "@dxos/echo": "0.8.4-main.422d1c7879",
+    "@dxos/context": "0.8.4-main.422d1c7879",
+    "@dxos/functions": "0.8.4-main.422d1c7879",
+    "@dxos/functions-runtime": "0.8.4-main.422d1c7879",
+    "@dxos/invariant": "0.8.4-main.422d1c7879",
+    "@dxos/log": "0.8.4-main.422d1c7879",
+    "@dxos/functions-runtime-cloudflare": "0.8.4-main.422d1c7879",
+    "@dxos/operation": "0.8.4-main.422d1c7879",
+    "@dxos/protocols": "0.8.4-main.422d1c7879"
   },
-  "devDependencies": {},
   "publishConfig": {
     "access": "public"
   },

package/src/bundle.test.ts

@@ -3,7 +3,6 @@
 //
 
 import { join } from 'node:path';
-
 import { describe, it } from 'vitest';
 
 import { bundleFunction } from '@dxos/functions-runtime/native';

package/src/cpu-limit.test.ts

@@ -5,6 +5,7 @@
 import { describe, test } from 'vitest';
 
 import { configPreset } from '@dxos/config';
+import { Context } from '@dxos/context';
 import { Obj, Ref } from '@dxos/echo';
 import { Trigger } from '@dxos/functions';
 import { FunctionRuntimeKind } from '@dxos/protocols';
@@ -26,6 +27,7 @@ describe.runIf(process.env.DX_TEST_TAGS?.includes('functions-e2e'))('CPU limit',
       FunctionRuntimeKind.enums.WORKERS_FOR_PLATFORMS,
     );
     const result = await functionsServiceClient.invoke(
+      Context.default(),
       func,
       {
         iterations: 100,
@@ -49,12 +51,12 @@ describe.runIf(process.env.DX_TEST_TAGS?.includes('functions-e2e'))('CPU limit',
       Obj.make(Trigger.Trigger, {
         enabled: true,
         function: Ref.make(func),
-        spec: { kind: 'timer', cron: '* */30 * * * *' },
+        spec: Trigger.specTimer('* */30 * * * *'),
         input: { iterations: 100 },
       }),
     );
     await sync(space);
-    const result = await functionsServiceClient.forceRunCronTrigger(space.id, trigger.id);
+    const result = await functionsServiceClient.forceRunCronTrigger(Context.default(), space.id, trigger.id);
     console.log(result);
   });
 
@@ -70,25 +72,27 @@ describe.runIf(process.env.DX_TEST_TAGS?.includes('functions-e2e'))('CPU limit',
       Obj.make(Trigger.Trigger, {
         enabled: true,
         function: Ref.make(func),
-        spec: { kind: 'timer', cron: '* */30 * * * *' },
+        spec: Trigger.specTimer('* */30 * * * *'),
         input: { iterations: 1_000_000_000 },
       }),
     );
     await sync(space);
     {
-      const result = await functionsServiceClient.forceRunCronTrigger(space.id, trigger.id);
+      const result = await functionsServiceClient.forceRunCronTrigger(Context.default(), space.id, trigger.id);
       console.log(result);
     }
 
     {
-      const result = await functionsServiceClient.forceRunCronTrigger(space.id, trigger.id);
+      const result = await functionsServiceClient.forceRunCronTrigger(Context.default(), space.id, trigger.id);
       console.log(result);
     }
 
     {
-      trigger.input!.iterations = 100;
+      Obj.change(trigger, (trigger) => {
+        trigger.input!.iterations = 100;
+      });
       await sync(space);
-      const result = await functionsServiceClient.forceRunCronTrigger(space.id, trigger.id);
+      const result = await functionsServiceClient.forceRunCronTrigger(Context.default(), space.id, trigger.id);
       console.log(result);
     }
   });
@@ -105,7 +109,7 @@ describe.runIf(process.env.DX_TEST_TAGS?.includes('functions-e2e'))('CPU limit',
       Obj.make(Trigger.Trigger, {
         enabled: true,
         function: Ref.make(func),
-        spec: { kind: 'timer', cron: '* * * * * *' },
+        spec: Trigger.specTimer('* * * * * *'),
         input: { iterations: 1_000_000 },
       }),
     );
@@ -113,7 +117,7 @@ describe.runIf(process.env.DX_TEST_TAGS?.includes('functions-e2e'))('CPU limit',
     await observeInvocations(space, 100);
   });
 
-  test('break CPU limit through natural exection', { timeout: 520_000 }, async ({ expect }) => {
+  test.only('break CPU limit through natural exection', { timeout: 520_000 }, async ({ expect }) => {
     const { client, space, functionsServiceClient } = await setup(config);
     const func = await deployFunction(
       space,
@@ -125,18 +129,22 @@ describe.runIf(process.env.DX_TEST_TAGS?.includes('functions-e2e'))('CPU limit',
       Obj.make(Trigger.Trigger, {
         enabled: true,
         function: Ref.make(func),
-        spec: { kind: 'timer', cron: '* * * * * *' },
+        spec: Trigger.specTimer('* * * * * *'),
         input: { iterations: 100 },
       }),
     );
     await sync(space);
     await observeInvocations(space, 5);
 
-    trigger.input!.iterations = 1_000_000_000;
+    Obj.change(trigger, (trigger) => {
+      trigger.input!.iterations = 1_000_000_000;
+    });
     await sync(space);
     await observeInvocations(space, 10);
 
-    trigger.input!.iterations = 100;
+    Obj.change(trigger, (trigger) => {
+      trigger.input!.iterations = 100;
+    });
     await sync(space);
     await observeInvocations(space, 1_000);
   });

package/src/functions/definitions.ts

@@ -0,0 +1,61 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Database } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+
+export const Fibonacci = Operation.make({
+  meta: {
+    key: 'example.org/function/fib',
+    name: 'Fibonacci',
+    description: 'Function that calculates a Fibonacci number',
+  },
+  input: Schema.Struct({
+    iterations: Schema.optional(Schema.Number).annotations({
+      description: 'Number of iterations',
+      default: 100_000,
+    }),
+  }),
+  output: Schema.Struct({
+    result: Schema.String,
+  }),
+});
+
+export const Reply = Operation.make({
+  meta: {
+    key: 'example.org/function/reply',
+    name: 'Reply',
+    description: 'Function that echoes the input',
+  },
+  input: Schema.Any,
+  output: Schema.Any,
+});
+
+export const Sleep = Operation.make({
+  meta: {
+    key: 'example.org/function/sleep',
+    name: 'Sleep',
+    description: 'Function that sleeps for a given amount of time',
+  },
+  input: Schema.Struct({
+    duration: Schema.optional(Schema.Number).annotations({
+      description: 'Milliseconds to sleep',
+      default: 100_000,
+    }),
+  }),
+  output: Schema.Void,
+});
+
+export const QueryDb = Operation.make({
+  meta: {
+    key: 'example.org/function/query',
+    name: 'Query',
+    description: 'Queries the database',
+  },
+  input: Schema.Any,
+  output: Schema.Any,
+  services: [Database.Service],
+});

package/src/functions/fib.ts

@@ -3,30 +3,21 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
-import { defineFunction } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
 
-export default defineFunction({
-  key: 'example.org/function/fib',
-  name: 'Fibonacci',
-  description: 'Function that calculates a Fibonacci number',
-  inputSchema: Schema.Struct({
-    iterations: Schema.optional(Schema.Number).annotations({
-      description: 'Number of iterations',
-      default: 100_000,
+import { Fibonacci } from './definitions';
+
+export default Fibonacci.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ iterations = 100_000 }) {
+      let a = 0n;
+      let b = 1n;
+      for (let i = 0; i < iterations; i++) {
+        a += b;
+        b = a - b;
+      }
+      return { result: a.toString() };
     }),
-  }),
-  outputSchema: Schema.Struct({
-    result: Schema.String,
-  }),
-  handler: Effect.fn(function* ({ data: { iterations = 100_000 } }) {
-    let a = 0n;
-    let b = 1n;
-    for (let i = 0; i < iterations; i++) {
-      a += b;
-      b = a - b;
-    }
-    return { result: a.toString() };
-  }),
-});
+  ),
+);

package/src/functions/forex-effect.ts

@@ -10,35 +10,39 @@ import * as Effect from 'effect/Effect';
 import * as Schedule from 'effect/Schedule';
 import * as Schema from 'effect/Schema';
 
-import { defineFunction } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
 
-export default defineFunction({
-  key: 'dxos.org/script/forex-effect',
-  name: 'Forex Effect',
-  description: 'Returns the exchange rate between two currencies.',
-
-  inputSchema: Schema.Struct({
+const ForexEffect = Operation.make({
+  meta: {
+    key: 'org.dxos.script.forex-effect',
+    name: 'Forex Effect',
+    description: 'Returns the exchange rate between two currencies.',
+  },
+  input: Schema.Struct({
     from: Schema.String.annotations({ description: 'The source currency' }),
     to: Schema.String.annotations({ description: 'The target currency' }),
   }),
+  output: Schema.String.annotations({ description: 'The exchange rate between the two currencies' }),
+});
 
-  outputSchema: Schema.String.annotations({ description: 'The exchange rate between the two currencies' }),
-
-  handler: Effect.fnUntraced(function* ({ data: { from, to } }: any) {
-    const res = yield* HttpClientRequest.get(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`).pipe(
-      HttpClient.execute,
-      Effect.flatMap(
-        HttpClientResponse.schemaBodyJson(
-          Schema.Struct({
-            data: Schema.Struct({ rates: Schema.Record({ key: Schema.String, value: Schema.Number }) }),
-          }),
+export default ForexEffect.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ from, to }) {
+      const res = yield* HttpClientRequest.get(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`).pipe(
+        HttpClient.execute,
+        Effect.flatMap(
+          HttpClientResponse.schemaBodyJson(
+            Schema.Struct({
+              data: Schema.Struct({ rates: Schema.Record({ key: Schema.String, value: Schema.Number }) }),
+            }),
+          ),
         ),
-      ),
-      Effect.timeout('1 second'),
-      Effect.retry(Schedule.exponential(1_000).pipe(Schedule.compose(Schedule.recurs(3)))),
-      Effect.scoped,
-    );
+        Effect.timeout('1 second'),
+        Effect.retry(Schedule.exponential(1_000).pipe(Schedule.compose(Schedule.recurs(3)))),
+        Effect.scoped,
+      );
 
-    return res.data.rates[to].toString();
-  }, Effect.provide(FetchHttpClient.layer)),
-});
+      return res.data.rates[to].toString();
+    }, Effect.provide(FetchHttpClient.layer)),
+  ),
+);

package/src/functions/query.ts

@@ -3,19 +3,17 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
-import { Database, Filter, Query } from '@dxos/echo';
-import { defineFunction } from '@dxos/functions';
+import { Database, Filter, Query as EchoQuery } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
 
-export default defineFunction({
-  key: 'example.org/function/query',
-  name: 'Query',
-  description: 'Queries the database',
-  inputSchema: Schema.Any,
-  outputSchema: Schema.Any,
-  handler: Effect.fn(function* ({ data }) {
-    const results = yield* Database.Service.runQuery(Query.select(Filter.everything()));
-    return { count: results.length };
-  }),
-});
+import { QueryDb } from './definitions';
+
+export default QueryDb.pipe(
+  Operation.withHandler(
+    Effect.fn(function* (data) {
+      const results = yield* Database.runQuery(EchoQuery.select(Filter.everything()));
+      return { count: results.length };
+    }),
+  ),
+);

package/src/functions/reply.ts

@@ -4,18 +4,16 @@
 
 import * as Console from 'effect/Console';
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
-import { defineFunction } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
 
-export default defineFunction({
-  key: 'example.org/function/reply',
-  name: 'Reply',
-  description: 'Function that echoes the input',
-  inputSchema: Schema.Any,
-  outputSchema: Schema.Any,
-  handler: Effect.fn(function* ({ data }) {
-    yield* Console.log('reply', { data });
-    return data;
-  }),
-});
+import { Reply } from './definitions';
+
+export default Reply.pipe(
+  Operation.withHandler(
+    Effect.fn(function* (data) {
+      yield* Console.log('reply', { data });
+      return data;
+    }),
+  ),
+);

package/src/functions/sleep.ts

@@ -3,22 +3,15 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
-import { defineFunction } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
 
-export default defineFunction({
-  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({
-      description: 'Milliseconds to sleep',
-      default: 100_000,
+import { Sleep } from './definitions';
+
+export default Sleep.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ duration = 100_000 }) {
+      yield* Effect.sleep(duration);
     }),
-  }),
-  outputSchema: Schema.Void,
-  handler: Effect.fn(function* ({ data: { duration = 100_000 } }) {
-    yield* Effect.sleep(duration);
-  }),
-});
+  ),
+);

package/src/testing/util.ts

@@ -7,14 +7,15 @@ import fs from 'node:fs';
 import { sleep } from '@dxos/async';
 import { Client, type Config } from '@dxos/client';
 import { type Space } from '@dxos/client/echo';
-import { Filter, Obj, Query } from '@dxos/echo';
-import { Function } from '@dxos/functions';
+import { Context } from '@dxos/context';
+import { Feed, Obj } from '@dxos/echo';
 import { Trigger } from '@dxos/functions';
 import { InvocationTraceEndEvent, InvocationTraceStartEvent } from '@dxos/functions-runtime';
 import { FunctionsServiceClient } from '@dxos/functions-runtime/edge';
 import { bundleFunction } from '@dxos/functions-runtime/native';
 import type { BundleResult } from '@dxos/functions-runtime/native';
-import { type FunctionRuntimeKind } from '@dxos/protocols';
+import { Operation } from '@dxos/operation';
+import { ErrorCodec, type FunctionRuntimeKind } from '@dxos/protocols';
 import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
 
 export const writeBundle = (path: string, bundle: BundleResult) => {
@@ -27,7 +28,7 @@ export const writeBundle = (path: string, bundle: BundleResult) => {
 export const setup = async (config: Config) => {
   const client = await new Client({
     config,
-    types: [Function.Function, Trigger.Trigger],
+    types: [Operation.PersistentOperation, Trigger.Trigger],
   }).initialize();
   await client.halo.createIdentity();
 
@@ -41,7 +42,7 @@ export const setup = async (config: Config) => {
 };
 
 export const sync = async (space: Space) => {
-  await space.db.flush({ indexes: true });
+  await space.db.flush();
   await space.internal.syncToEdge({
     onProgress: (state) =>
       console.log(state ? `${state.unsyncedDocumentCount} documents syncing...` : 'connecting to edge...'),
@@ -53,12 +54,12 @@ export const deployFunction = async (
   functionsServiceClient: FunctionsServiceClient,
   entryPoint: string,
   runtime: FunctionRuntimeKind,
-) => {
+): Promise<Operation.PersistentOperation> => {
   const artifact = await bundleFunction({
     entryPoint,
     verbose: true,
   });
-  const func = await functionsServiceClient.deploy({
+  const func = await functionsServiceClient.deploy(Context.default(), {
     version: '0.0.1',
     ownerPublicKey: space.key,
     entryPoint: artifact.entryPoint,
@@ -83,8 +84,9 @@ export const observeInvocations = async (space: Space, maxCount: number | null)
   let count = 0;
   while (true) {
     try {
-      const invocations =
-        (await space.properties.invocationTraceQueue?.target!.query(Query.select(Filter.everything())).run()) ?? [];
+      const traceFeed = space.properties.invocationTraceFeed?.target;
+      const traceQueueDxn = traceFeed ? Feed.getQueueDxn(traceFeed) : undefined;
+      const invocations = traceQueueDxn ? ((await space.queues.get(traceQueueDxn).queryObjects()) ?? []) : [];
 
       for (const invocation of invocations) {
         if (Obj.instanceOf(InvocationTraceStartEvent, invocation)) {
@@ -95,7 +97,9 @@ export const observeInvocations = async (space: Space, maxCount: number | null)
             count: count++,
             begin: invocation,
           });
-          console.log(`${count.toString().padStart(3, ' ')}: BEGIN ${JSON.stringify(invocation.input)}`);
+          console.log(
+            `${count.toString().padStart(3, ' ')}: BEGIN ${invocation.runtime ?? '(unknown runtime)'} ${JSON.stringify(invocation.input)}`,
+          );
         } else if (Obj.instanceOf(InvocationTraceEndEvent, invocation)) {
           const data = invocationData.get(invocation.invocationId);
           if (!data || !!data.end) {
@@ -107,8 +111,8 @@ export const observeInvocations = async (space: Space, maxCount: number | null)
           console.log(
             `${data.count.toString().padStart(3, ' ')}: END outcome=${outcome} duration=${data.end.timestamp - data.begin.timestamp}`,
           );
-          if (outcome === 'failure') {
-            console.log(data.end.error?.stack);
+          if (outcome === 'failure' && data.end.error) {
+            console.error(ErrorCodec.decode(data.end.error));
           }
         }
       }