@dxos/functions-simulator-cloudflare 0.8.4-main.21d9917

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@dxos/functions-simulator-cloudflare",
+  "version": "0.8.4-main.21d9917",
+  "description": "Simulate functions running in Cloudflare runtime",
+  "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": {
+    "miniflare": "^4.20251128.0",
+    "@dxos/context": "0.8.4-main.21d9917",
+    "@dxos/protocols": "0.8.4-main.21d9917"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "beast": {}
+}

package/src/function-worker.test.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import { FunctionWorker, makeJsModule } from './function-worker';
+
+describe('FunctionWorker', async () => {
+  test('hello world', async () => {
+    await using worker = new FunctionWorker({
+      mainModule: 'index.js',
+      modules: {
+        'index.js': makeJsModule(`
+          export default {
+            async fetch(request, env, ctx) {
+              return new Response(JSON.stringify({ success: true, data: 'Hello Miniflare!' }));
+            }
+          }
+        `),
+      },
+    });
+    const result = await worker.invoke({});
+    expect(result).toEqual({ _kind: 'success', result: 'Hello Miniflare!' });
+  });
+
+  test('multiple modules', async () => {
+    await using worker = new FunctionWorker({
+      mainModule: 'index.js',
+      modules: {
+        'const.js': makeJsModule(`
+          export const constValue = 'Hello Miniflare!';
+        `),
+        'index.js': makeJsModule(`
+          import { constValue } from './const.js';
+          export default {
+            async fetch(request, env, ctx) {
+              return new Response(JSON.stringify({ success: true, data: constValue }));
+            }
+          }
+        `),
+      },
+    });
+    const result = await worker.invoke({});
+    expect(result).toEqual({ _kind: 'success', result: 'Hello Miniflare!' });
+  });
+});

package/src/function-worker.ts

@@ -0,0 +1,113 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Miniflare, Request } from 'miniflare';
+
+import { type Context, Resource } from '@dxos/context';
+import { type EdgeEnvelope, type SerializedError } from '@dxos/protocols';
+
+export type InvokeResult =
+  | {
+      _kind: 'success';
+      /**
+       * The output of the function.
+       */
+      result: unknown;
+    }
+  | {
+      _kind: 'error';
+      error: SerializedError;
+    };
+
+export type FunctionWorkerOptions = {
+  mainModule: string;
+  modules: {
+    [filename: string]: {
+      contents: Uint8Array<ArrayBuffer>;
+      contentType: string;
+    };
+  };
+};
+
+export const makeJsModule = (source: string) => ({
+  contentType: 'application/javascript',
+  contents: new TextEncoder().encode(source),
+});
+
+export class FunctionWorker extends Resource {
+  #miniflare: Miniflare;
+
+  constructor(opts: FunctionWorkerOptions) {
+    super();
+    if (!opts.modules[opts.mainModule]) {
+      throw new Error(`Main module not found: ${opts.mainModule}`);
+    }
+
+    const modules: MiniflareModule[] = Object.entries(opts.modules).map(([filename, mod]) => {
+      switch (mod.contentType) {
+        case 'application/javascript':
+          return {
+            type: 'ESModule' as const,
+            path: filename,
+            contents: mod.contents,
+          };
+        case 'application/wasm':
+          return {
+            type: 'CompiledWasm' as const,
+            path: filename,
+            contents: mod.contents,
+          };
+        default:
+          throw new Error(`Unsupported content type: ${mod.contentType}`);
+      }
+    });
+
+    modules.sort((a, b) => (a.path === opts.mainModule ? -1 : 1));
+
+    this.#miniflare = new Miniflare({
+      modules,
+    });
+  }
+
+  protected override async _close(_ctx: Context): Promise<void> {
+    await this.#miniflare.dispose();
+  }
+
+  async invoke(input: unknown): Promise<InvokeResult> {
+    const request = new Request('http://functions.dxos.internal/', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Edge-Env': 'test',
+      },
+      body: JSON.stringify({ data: input }),
+    });
+    const response = await this.#miniflare.dispatchFetch(request);
+    try {
+      const envelope = (await response.clone().json()) as EdgeEnvelope<unknown>;
+      if (envelope.success) {
+        return { _kind: 'success', result: envelope.data };
+      }
+      return {
+        _kind: 'error',
+        error: envelope.error ?? {
+          message: envelope.message,
+        },
+      };
+    } catch (err) {
+      return {
+        _kind: 'error',
+        error: {
+          message: (await response.text()).slice(0, 1024),
+        },
+      };
+    }
+  }
+}
+
+type MiniflareModule = {
+  type: 'ESModule' | 'CommonJS' | 'Text' | 'Data' | 'CompiledWasm' | 'PythonModule' | 'PythonRequirement';
+  path: string;
+  contents?: string | Uint8Array<ArrayBuffer> | undefined;
+};

package/src/index.ts

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

package/src/testing/index.ts

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