@dxos/functions-testing 0.8.4-main.1068cf700f

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@dxos/functions-testing",
+  "version": "0.8.4-main.1068cf700f",
+  "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,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types/src/index.d.ts",
+      "browser": "./dist/lib/browser/index.mjs",
+      "node": "./dist/lib/node-esm/index.mjs"
+    },
+    "./testing": {
+      "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": {
+    "*": {
+      "testing": [
+        "dist/types/src/testing/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@effect/platform": "0.94.4",
+    "@dxos/async": "0.8.4-main.1068cf700f",
+    "@dxos/client": "0.8.4-main.1068cf700f",
+    "@dxos/config": "0.8.4-main.1068cf700f",
+    "@dxos/echo": "0.8.4-main.1068cf700f",
+    "@dxos/functions": "0.8.4-main.1068cf700f",
+    "@dxos/functions-runtime": "0.8.4-main.1068cf700f",
+    "@dxos/functions-runtime-cloudflare": "0.8.4-main.1068cf700f",
+    "@dxos/invariant": "0.8.4-main.1068cf700f",
+    "@dxos/log": "0.8.4-main.1068cf700f",
+    "@dxos/protocols": "0.8.4-main.1068cf700f"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "beast": {}
+}

package/src/bundle.test.ts

@@ -0,0 +1,21 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { join } from 'node:path';
+
+import { describe, it } from 'vitest';
+
+import { bundleFunction } from '@dxos/functions-runtime/native';
+
+import { writeBundle } from './testing';
+
+describe('bundle', () => {
+  it('should bundle', async () => {
+    const result = await bundleFunction({
+      entryPoint: new URL('./functions/reply.ts', import.meta.url).pathname,
+    });
+    writeBundle('./dist/test/bundle-reply', result);
+    console.log(join('dist/test/bundle-reply', result.entryPoint));
+  });
+});

package/src/cpu-limit.test.ts

@@ -0,0 +1,149 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { configPreset } from '@dxos/config';
+import { Obj, Ref } from '@dxos/echo';
+import { Trigger } from '@dxos/functions';
+import { FunctionRuntimeKind } from '@dxos/protocols';
+
+import { deployFunction, observeInvocations, setup, sync } from './testing';
+
+const FIB_FUNCTION_PATH = new URL('./functions/fib.ts', import.meta.url).pathname;
+
+// Test suite to explore who CPU time limits influence function execution
+describe.runIf(process.env.DX_TEST_TAGS?.includes('functions-e2e'))('CPU limit', () => {
+  const config = configPreset({ edge: 'dev' });
+
+  test('invoke directly', { timeout: 120_000 }, async ({ expect }) => {
+    const { client, space, functionsServiceClient } = await setup(config);
+    const func = await deployFunction(
+      space,
+      functionsServiceClient,
+      FIB_FUNCTION_PATH,
+      FunctionRuntimeKind.enums.WORKERS_FOR_PLATFORMS,
+    );
+    const result = await functionsServiceClient.invoke(
+      func,
+      {
+        iterations: 100,
+      },
+      {
+        spaceId: space.id,
+      },
+    );
+    console.log(result);
+  });
+
+  test('force-trigger', { timeout: 120_000 }, async ({ expect }) => {
+    const { client, space, functionsServiceClient } = await setup(config);
+    const func = await deployFunction(
+      space,
+      functionsServiceClient,
+      FIB_FUNCTION_PATH,
+      FunctionRuntimeKind.enums.WORKERS_FOR_PLATFORMS,
+    );
+    const trigger = space.db.add(
+      Obj.make(Trigger.Trigger, {
+        enabled: true,
+        function: Ref.make(func),
+        spec: { kind: 'timer', cron: '* */30 * * * *' },
+        input: { iterations: 100 },
+      }),
+    );
+    await sync(space);
+    const result = await functionsServiceClient.forceRunCronTrigger(space.id, trigger.id);
+    console.log(result);
+  });
+
+  test('break CPU limit', { timeout: 120_000 }, async ({ expect }) => {
+    const { client, space, functionsServiceClient } = await setup(config);
+    const func = await deployFunction(
+      space,
+      functionsServiceClient,
+      FIB_FUNCTION_PATH,
+      FunctionRuntimeKind.enums.WORKERS_FOR_PLATFORMS,
+    );
+    const trigger = space.db.add(
+      Obj.make(Trigger.Trigger, {
+        enabled: true,
+        function: Ref.make(func),
+        spec: { kind: 'timer', cron: '* */30 * * * *' },
+        input: { iterations: 1_000_000_000 },
+      }),
+    );
+    await sync(space);
+    {
+      const result = await functionsServiceClient.forceRunCronTrigger(space.id, trigger.id);
+      console.log(result);
+    }
+
+    {
+      const result = await functionsServiceClient.forceRunCronTrigger(space.id, trigger.id);
+      console.log(result);
+    }
+
+    {
+      Obj.change(trigger, (t) => {
+        t.input!.iterations = 100;
+      });
+      await sync(space);
+      const result = await functionsServiceClient.forceRunCronTrigger(space.id, trigger.id);
+      console.log(result);
+    }
+  });
+
+  test('observe invocations', { timeout: 520_000 }, async ({ expect }) => {
+    const { client, space, functionsServiceClient } = await setup(config);
+    const func = await deployFunction(
+      space,
+      functionsServiceClient,
+      FIB_FUNCTION_PATH,
+      FunctionRuntimeKind.enums.WORKERS_FOR_PLATFORMS,
+    );
+    const trigger = space.db.add(
+      Obj.make(Trigger.Trigger, {
+        enabled: true,
+        function: Ref.make(func),
+        spec: { kind: 'timer', cron: '* * * * * *' },
+        input: { iterations: 1_000_000 },
+      }),
+    );
+    await sync(space);
+    await observeInvocations(space, 100);
+  });
+
+  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,
+      functionsServiceClient,
+      FIB_FUNCTION_PATH,
+      FunctionRuntimeKind.enums.WORKERS_FOR_PLATFORMS,
+    );
+    const trigger = space.db.add(
+      Obj.make(Trigger.Trigger, {
+        enabled: true,
+        function: Ref.make(func),
+        spec: { kind: 'timer', cron: '* * * * * *' },
+        input: { iterations: 100 },
+      }),
+    );
+    await sync(space);
+    await observeInvocations(space, 5);
+
+    Obj.change(trigger, (t) => {
+      t.input!.iterations = 1_000_000_000;
+    });
+    await sync(space);
+    await observeInvocations(space, 10);
+
+    Obj.change(trigger, (t) => {
+      t.input!.iterations = 100;
+    });
+    await sync(space);
+    await observeInvocations(space, 1_000);
+  });
+});

package/src/functions/fib.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { defineFunction } from '@dxos/functions';
+
+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,
+    }),
+  }),
+  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

@@ -0,0 +1,44 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as HttpClientRequest from '@effect/platform/HttpClientRequest';
+import * as HttpClientResponse from '@effect/platform/HttpClientResponse';
+import * as Effect from 'effect/Effect';
+import * as Schedule from 'effect/Schedule';
+import * as Schema from 'effect/Schema';
+
+import { defineFunction } from '@dxos/functions';
+
+export default defineFunction({
+  key: 'dxos.org/script/forex-effect',
+  name: 'Forex Effect',
+  description: 'Returns the exchange rate between two currencies.',
+
+  inputSchema: Schema.Struct({
+    from: Schema.String.annotations({ description: 'The source currency' }),
+    to: Schema.String.annotations({ description: 'The target currency' }),
+  }),
+
+  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 }) }),
+          }),
+        ),
+      ),
+      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)),
+});

package/src/functions/query.ts

@@ -0,0 +1,21 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Database, Filter, Query } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
+
+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.runQuery(Query.select(Filter.everything()));
+    return { count: results.length };
+  }),
+});

package/src/functions/reply.ts

@@ -0,0 +1,21 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { defineFunction } from '@dxos/functions';
+
+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;
+  }),
+});

package/src/functions/sleep.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { defineFunction } from '@dxos/functions';
+
+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,
+    }),
+  }),
+  outputSchema: Schema.Void,
+  handler: Effect.fn(function* ({ data: { duration = 100_000 } }) {
+    yield* Effect.sleep(duration);
+  }),
+});

package/src/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export {};

package/src/testing/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './util';

package/src/testing/util.ts

@@ -0,0 +1,129 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+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 { 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 { ErrorCodec, type FunctionRuntimeKind } from '@dxos/protocols';
+import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
+
+export const writeBundle = (path: string, bundle: BundleResult) => {
+  fs.mkdirSync(path, { recursive: true });
+  Object.entries(bundle.assets).forEach(([name, content]) => {
+    fs.writeFileSync(path + '/' + name, content);
+  });
+};
+
+export const setup = async (config: Config) => {
+  const client = await new Client({
+    config,
+    types: [Function.Function, Trigger.Trigger],
+  }).initialize();
+  await client.halo.createIdentity();
+
+  const space = await client.spaces.create();
+  await space.waitUntilReady();
+  await space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED);
+
+  const functionsServiceClient = FunctionsServiceClient.fromClient(client);
+
+  return { client, space, functionsServiceClient };
+};
+
+export const sync = async (space: Space) => {
+  await space.db.flush({ indexes: true });
+  await space.internal.syncToEdge({
+    onProgress: (state) =>
+      console.log(state ? `${state.unsyncedDocumentCount} documents syncing...` : 'connecting to edge...'),
+  });
+};
+
+export const deployFunction = async (
+  space: Space,
+  functionsServiceClient: FunctionsServiceClient,
+  entryPoint: string,
+  runtime: FunctionRuntimeKind,
+) => {
+  const artifact = await bundleFunction({
+    entryPoint,
+    verbose: true,
+  });
+  const func = await functionsServiceClient.deploy({
+    version: '0.0.1',
+    ownerPublicKey: space.key,
+    entryPoint: artifact.entryPoint,
+    assets: artifact.assets,
+    runtime,
+  });
+  space.db.add(func);
+
+  return func;
+};
+
+export const observeInvocations = async (space: Space, maxCount: number | null) => {
+  let initialCount = null;
+  const invocationData = new Map<
+    string,
+    {
+      count: number;
+      begin: InvocationTraceStartEvent;
+      end?: InvocationTraceEndEvent;
+    }
+  >();
+  let count = 0;
+  while (true) {
+    try {
+      const invocations =
+        (await space.properties.invocationTraceQueue?.target!.query(Query.select(Filter.everything())).run()) ?? [];
+
+      for (const invocation of invocations) {
+        if (Obj.instanceOf(InvocationTraceStartEvent, invocation)) {
+          if (invocationData.has(invocation.invocationId)) {
+            continue;
+          }
+          invocationData.set(invocation.invocationId, {
+            count: count++,
+            begin: invocation,
+          });
+          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) {
+            continue;
+          }
+          data.end = invocation;
+
+          const outcome = data.end.outcome;
+          console.log(
+            `${data.count.toString().padStart(3, ' ')}: END outcome=${outcome} duration=${data.end.timestamp - data.begin.timestamp}`,
+          );
+          if (outcome === 'failure' && data.end.error) {
+            console.error(ErrorCodec.decode(data.end.error));
+          }
+        }
+      }
+      if (initialCount === null) {
+        initialCount = invocations.length;
+      }
+
+      if (maxCount !== null && invocationData.size >= maxCount + initialCount) {
+        break;
+      }
+    } catch (err) {
+      console.error(err);
+    }
+    await sleep(1_000);
+  }
+};