@dxos/functions 0.8.2-main.fbd8ed0 → 0.8.2-staging.7ac8446

package/dist/lib/browser/testing/index.mjs

@@ -0,0 +1,670 @@
+import "@dxos/node-std/globals";
+import {
+  FunctionRegistry,
+  TriggerRegistry
+} from "../chunk-HI7YZO2K.mjs";
+import {
+  FunctionDef,
+  FunctionTrigger
+} from "../chunk-RVSG6WTL.mjs";
+import {
+  __require
+} from "../chunk-XRCXIG74.mjs";
+
+// packages/core/functions/src/testing/setup.ts
+import { getRandomPort } from "get-port-please";
+import path2 from "@dxos/node-std/path";
+import { waitForCondition } from "@dxos/async";
+import { Client, Config } from "@dxos/client";
+import { range } from "@dxos/util";
+
+// packages/core/functions/src/testing/types.ts
+import { S, TypedObject } from "@dxos/echo-schema";
+var TestType = class extends TypedObject({
+  typename: "example.com/type/Test",
+  version: "0.1.0"
+})({
+  title: S.String
+}) {
+};
+
+// packages/core/functions/src/runtime/dev-server.ts
+import express from "express";
+import { getPort } from "get-port-please";
+import { join } from "@dxos/node-std/path";
+import { asyncTimeout, Event, Trigger } from "@dxos/async";
+import { Context } from "@dxos/context";
+import { invariant } from "@dxos/invariant";
+import { log } from "@dxos/log";
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/functions/src/runtime/dev-server.ts";
+var FN_TIMEOUT = 2e4;
+var DevServer = class {
+  constructor(_client, _functionsRegistry, _options) {
+    this._client = _client;
+    this._functionsRegistry = _functionsRegistry;
+    this._options = _options;
+    this._ctx = createContext();
+    this._handlers = {};
+    this._seq = 0;
+    this.update = new Event();
+  }
+  get stats() {
+    return {
+      seq: this._seq
+    };
+  }
+  get endpoint() {
+    invariant(this._port, void 0, {
+      F: __dxlog_file,
+      L: 60,
+      S: this,
+      A: [
+        "this._port",
+        ""
+      ]
+    });
+    return `http://localhost:${this._port}`;
+  }
+  get proxy() {
+    return this._proxy;
+  }
+  get functions() {
+    return Object.values(this._handlers);
+  }
+  async start() {
+    invariant(!this._server, void 0, {
+      F: __dxlog_file,
+      L: 73,
+      S: this,
+      A: [
+        "!this._server",
+        ""
+      ]
+    });
+    log.info("starting...", void 0, {
+      F: __dxlog_file,
+      L: 74,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._ctx = createContext();
+    const app = express();
+    app.use(express.json());
+    app.post("/:path", async (req, res) => {
+      const { path: path3 } = req.params;
+      try {
+        log.info("calling", {
+          path: path3
+        }, {
+          F: __dxlog_file,
+          L: 84,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        if (this._options.reload) {
+          const { def } = this._handlers["/" + path3];
+          await this._load(def, true);
+        }
+        res.statusCode = await asyncTimeout(this.invoke("/" + path3, req.body), FN_TIMEOUT);
+        res.end();
+      } catch (err) {
+        log.catch(err, void 0, {
+          F: __dxlog_file,
+          L: 94,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        res.statusCode = 500;
+        res.end();
+      }
+    });
+    this._port = this._options.port ?? await getPort({
+      host: "localhost",
+      port: 7200,
+      portRange: [
+        7200,
+        7299
+      ]
+    });
+    this._server = app.listen(this._port);
+    try {
+      const { registrationId, endpoint } = await this._client.services.services.FunctionRegistryService.register({
+        endpoint: this.endpoint
+      });
+      log.info("registered", {
+        endpoint
+      }, {
+        F: __dxlog_file,
+        L: 109,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._proxy = endpoint;
+      this._functionServiceRegistration = registrationId;
+      await this._handleNewFunctions(this._functionsRegistry.getUniqueByUri());
+      this._ctx.onDispose(this._functionsRegistry.registered.on(({ added }) => this._handleNewFunctions(added)));
+    } catch (err) {
+      await this.stop();
+      throw new Error("FunctionRegistryService not available (check plugin is configured).");
+    }
+    log.info("started", {
+      port: this._port
+    }, {
+      F: __dxlog_file,
+      L: 121,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async stop() {
+    if (!this._server) {
+      return;
+    }
+    log.info("stopping...", void 0, {
+      F: __dxlog_file,
+      L: 129,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this._ctx.dispose();
+    const trigger = new Trigger();
+    this._server.close(async () => {
+      log.info("server stopped", void 0, {
+        F: __dxlog_file,
+        L: 134,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      try {
+        if (this._functionServiceRegistration) {
+          invariant(this._client.services.services.FunctionRegistryService, void 0, {
+            F: __dxlog_file,
+            L: 137,
+            S: this,
+            A: [
+              "this._client.services.services.FunctionRegistryService",
+              ""
+            ]
+          });
+          await this._client.services.services.FunctionRegistryService.unregister({
+            registrationId: this._functionServiceRegistration
+          });
+          log.info("unregistered", {
+            registrationId: this._functionServiceRegistration
+          }, {
+            F: __dxlog_file,
+            L: 142,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this._functionServiceRegistration = void 0;
+          this._proxy = void 0;
+        }
+        trigger.wake();
+      } catch (err) {
+        trigger.throw(err);
+      }
+    });
+    await trigger.wait();
+    this._port = void 0;
+    this._server = void 0;
+    log.info("stopped", void 0, {
+      F: __dxlog_file,
+      L: 156,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async _handleNewFunctions(newFunctions) {
+    newFunctions.forEach((def) => this._load(def));
+    await this._safeUpdateRegistration();
+    log("new functions loaded", {
+      newFunctions
+    }, {
+      F: __dxlog_file,
+      L: 162,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  /**
+  * Load function.
+  */
+  async _load(def, force) {
+    const { uri, route, handler } = def;
+    const filePath = join(this._options.baseDir, handler);
+    log.info("loading", {
+      uri,
+      force
+    }, {
+      F: __dxlog_file,
+      L: 171,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (force) {
+      Object.keys(__require.cache).filter((key) => key.startsWith(filePath)).forEach((key) => {
+        delete __require.cache[key];
+      });
+    }
+    const module = __require(filePath);
+    if (typeof module.default !== "function") {
+      throw new Error(`Handler must export default function: ${uri}`);
+    }
+    this._handlers[route] = {
+      def,
+      handler: module.default
+    };
+  }
+  async _safeUpdateRegistration() {
+    invariant(this._functionServiceRegistration, void 0, {
+      F: __dxlog_file,
+      L: 193,
+      S: this,
+      A: [
+        "this._functionServiceRegistration",
+        ""
+      ]
+    });
+    try {
+      await this._client.services.services.FunctionRegistryService.updateRegistration({
+        registrationId: this._functionServiceRegistration,
+        functions: this.functions.map(({ def: { id, route } }) => ({
+          id,
+          route
+        }))
+      });
+    } catch (err) {
+      log.catch(err, void 0, {
+        F: __dxlog_file,
+        L: 200,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  /**
+  * Invoke function.
+  */
+  async invoke(path3, data) {
+    const seq = ++this._seq;
+    const now = Date.now();
+    log.info("req", {
+      seq,
+      path: path3
+    }, {
+      F: __dxlog_file,
+      L: 211,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const statusCode = await this._invoke(path3, {
+      data
+    });
+    log.info("res", {
+      seq,
+      path: path3,
+      statusCode,
+      duration: Date.now() - now
+    }, {
+      F: __dxlog_file,
+      L: 214,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this.update.emit(statusCode);
+    return statusCode;
+  }
+  async _invoke(path3, event) {
+    const { handler } = this._handlers[path3] ?? {};
+    invariant(handler, `invalid path: ${path3}`, {
+      F: __dxlog_file,
+      L: 221,
+      S: this,
+      A: [
+        "handler",
+        "`invalid path: ${path}`"
+      ]
+    });
+    const context = {
+      client: this._client,
+      dataDir: this._options.dataDir
+    };
+    let statusCode = 200;
+    const response = {
+      status: (code) => {
+        statusCode = code;
+        return response;
+      }
+    };
+    await handler({
+      context,
+      event,
+      response
+    });
+    return statusCode;
+  }
+};
+var createContext = () => new Context({
+  name: "DevServer"
+}, {
+  F: __dxlog_file,
+  L: 240
+});
+
+// packages/core/functions/src/runtime/scheduler.ts
+import path from "@dxos/node-std/path";
+import { Mutex } from "@dxos/async";
+import { loadObjectReferences } from "@dxos/client/echo";
+import { Context as Context2 } from "@dxos/context";
+import { Reference } from "@dxos/echo-protocol";
+import { log as log2 } from "@dxos/log";
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/functions/src/runtime/scheduler.ts";
+var Scheduler = class {
+  constructor(functions, triggers, _options = {}) {
+    this.functions = functions;
+    this.triggers = triggers;
+    this._options = _options;
+    this._ctx = createContext2();
+    this._functionUriToCallMutex = /* @__PURE__ */ new Map();
+    this.functions.registered.on(async ({ space, added }) => {
+      await this._safeActivateTriggers(space, this.triggers.getInactiveTriggers(space), added);
+    });
+    this.triggers.registered.on(async ({ space, triggers: triggers2 }) => {
+      await this._safeActivateTriggers(space, triggers2, this.functions.getFunctions(space));
+    });
+  }
+  async start() {
+    await this._ctx.dispose();
+    this._ctx = createContext2();
+    await this.functions.open(this._ctx);
+    await this.triggers.open(this._ctx);
+  }
+  async stop() {
+    await this._ctx.dispose();
+    await this.functions.close();
+    await this.triggers.close();
+  }
+  // TODO(burdon): Remove and update registries directly?
+  async register(space, manifest) {
+    await this.functions.register(space, manifest.functions);
+    await this.triggers.register(space, manifest);
+  }
+  async _safeActivateTriggers(space, triggers, functions) {
+    const mountTasks = triggers.map((trigger) => {
+      return this.activate(space, functions, trigger);
+    });
+    await Promise.all(mountTasks).catch(log2.catch);
+  }
+  /**
+  * Activate trigger.
+  */
+  // TODO(burdon): How are triggers deactivated?
+  async activate(space, functions, trigger) {
+    const definition = functions.find((def) => def.uri === trigger.function);
+    if (!definition) {
+      log2.info("function is not found for trigger", {
+        trigger
+      }, {
+        F: __dxlog_file2,
+        L: 85,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    const execFunction = async (args) => {
+      const mutex = this._functionUriToCallMutex.get(definition.uri) ?? new Mutex();
+      this._functionUriToCallMutex.set(definition.uri, mutex);
+      log2.info("function triggered, waiting for mutex", {
+        uri: definition.uri
+      }, {
+        F: __dxlog_file2,
+        L: 93,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return mutex.executeSynchronized(async () => {
+        log2.info("mutex acquired", {
+          uri: definition.uri
+        }, {
+          F: __dxlog_file2,
+          L: 95,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        await loadObjectReferences(trigger, (t) => Object.values(t.meta ?? {}));
+        const meta = {};
+        for (const [key, value] of Object.entries(trigger.meta ?? {})) {
+          if (value instanceof Reference) {
+            const object = await space.db.query({
+              id: value.objectId
+            }).first();
+            if (object) {
+              meta[key] = object;
+            }
+          } else {
+            meta[key] = value;
+          }
+        }
+        return this._execFunction(definition, trigger, {
+          meta,
+          data: {
+            ...args,
+            spaceKey: space.key
+          }
+        });
+      });
+    };
+    await this.triggers.activate(space, trigger, execFunction);
+    log2("activated trigger", {
+      space: space.key,
+      trigger
+    }, {
+      F: __dxlog_file2,
+      L: 119,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  /**
+  * Invoke function RPC.
+  */
+  async _execFunction(def, trigger, { meta, data }) {
+    let status = 0;
+    try {
+      const payload = Object.assign({}, meta && {
+        meta
+      }, data);
+      const { endpoint, callback } = this._options;
+      if (endpoint) {
+        const url = path.join(endpoint, def.route);
+        log2.info("exec", {
+          function: def.uri,
+          url,
+          triggerType: trigger.spec?.type
+        }, {
+          F: __dxlog_file2,
+          L: 139,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(payload)
+        });
+        status = response.status;
+      } else if (callback) {
+        log2.info("exec", {
+          function: def.uri
+        }, {
+          F: __dxlog_file2,
+          L: 150,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        status = await callback(payload) ?? 200;
+      }
+      if (status && status >= 400) {
+        throw new Error(`Response: ${status}`);
+      }
+      log2.info("done", {
+        function: def.uri,
+        status
+      }, {
+        F: __dxlog_file2,
+        L: 160,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    } catch (err) {
+      log2.error("error", {
+        function: def.uri,
+        error: err.message
+      }, {
+        F: __dxlog_file2,
+        L: 162,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      status = 500;
+    }
+    return status;
+  }
+};
+var createContext2 = () => new Context2({
+  name: "FunctionScheduler"
+}, {
+  F: __dxlog_file2,
+  L: 170
+});
+
+// packages/core/functions/src/testing/setup.ts
+var createInitializedClients = async (testBuilder, count = 1, config) => {
+  const clients = range(count).map(() => new Client({
+    config,
+    services: testBuilder.createLocalClientServices(),
+    types: [
+      FunctionDef,
+      FunctionTrigger,
+      TestType
+    ]
+  }));
+  testBuilder.ctx.onDispose(() => Promise.all(clients.map((client) => client.destroy())));
+  return Promise.all(clients.map(async (client, index) => {
+    await client.initialize();
+    await client.halo.createIdentity({
+      displayName: `Peer ${index}`
+    });
+    await client.spaces.waitUntilReady();
+    return client;
+  }));
+};
+var createFunctionRuntime = async (testBuilder, pluginInitializer) => {
+  const functionsPort = await getRandomPort("127.0.0.1");
+  const config = new Config({
+    runtime: {
+      agent: {
+        plugins: [
+          {
+            id: "dxos.org/agent/plugin/functions",
+            config: {
+              port: functionsPort
+            }
+          }
+        ]
+      }
+    }
+  });
+  const [client] = await createInitializedClients(testBuilder, 1, config);
+  const plugin = await pluginInitializer(client);
+  testBuilder.ctx.onDispose(() => plugin.close());
+  return client;
+};
+var startFunctionsHost = async (testBuilder, pluginInitializer, options) => {
+  const functionRuntime = await createFunctionRuntime(testBuilder, pluginInitializer);
+  const functionsRegistry = new FunctionRegistry(functionRuntime);
+  const devServer = await startDevServer(testBuilder, functionRuntime, functionsRegistry, options);
+  const scheduler = await startScheduler(testBuilder, functionRuntime, devServer, functionsRegistry);
+  return {
+    scheduler,
+    client: functionRuntime,
+    waitForActiveTriggers: async (space) => {
+      await waitForCondition({
+        condition: () => scheduler.triggers.getActiveTriggers(space).length > 0
+      });
+    }
+  };
+};
+var startScheduler = async (testBuilder, client, devServer, functionRegistry) => {
+  const triggerRegistry = new TriggerRegistry(client);
+  const scheduler = new Scheduler(functionRegistry, triggerRegistry, {
+    endpoint: devServer.endpoint
+  });
+  await scheduler.start();
+  testBuilder.ctx.onDispose(() => scheduler.stop());
+  return scheduler;
+};
+var startDevServer = async (testBuilder, client, functionRegistry, options) => {
+  const server = new DevServer(client, functionRegistry, {
+    baseDir: path2.join(__dirname, "../testing"),
+    port: await getRandomPort("127.0.0.1"),
+    ...options
+  });
+  await server.start();
+  testBuilder.ctx.onDispose(() => server.stop());
+  return server;
+};
+
+// packages/core/functions/src/testing/util.ts
+import { Filter } from "@dxos/client/echo";
+import { performInvitation } from "@dxos/client/testing";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { Invitation } from "@dxos/protocols/proto/dxos/client/services";
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/functions/src/testing/util.ts";
+var triggerWebhook = async (space, uri) => {
+  const trigger = (await space.db.query(Filter.schema(FunctionTrigger, (trigger2) => trigger2.function === uri)).run()).objects[0];
+  invariant2(trigger.spec?.type === "webhook", void 0, {
+    F: __dxlog_file3,
+    L: 17,
+    S: void 0,
+    A: [
+      "trigger.spec?.type === 'webhook'",
+      ""
+    ]
+  });
+  void fetch(`http://localhost:${trigger.spec.port}`);
+};
+var inviteMember = async (host, guest) => {
+  const [{ invitation: hostInvitation }] = await Promise.all(performInvitation({
+    host,
+    guest: guest.spaces
+  }));
+  if (hostInvitation?.state !== Invitation.State.SUCCESS) {
+    throw new Error(`Expected ${hostInvitation?.state} to be ${Invitation.State.SUCCESS}.`);
+  }
+};
+
+// packages/core/functions/src/testing/manifest.ts
+var testFunctionManifest = {
+  functions: [
+    {
+      uri: "example.com/function/test",
+      route: "test",
+      handler: "test"
+    }
+  ]
+};
+export {
+  TestType,
+  createFunctionRuntime,
+  createInitializedClients,
+  inviteMember,
+  startFunctionsHost,
+  testFunctionManifest,
+  triggerWebhook
+};
+//# sourceMappingURL=index.mjs.map