@dxos/functions 0.8.1 → 0.8.2-main.2f9c567

package/dist/lib/node-esm/testing/index.mjs

@@ -1,670 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  FunctionRegistry,
-  TriggerRegistry
-} from "../chunk-SQSJO5HI.mjs";
-import {
-  FunctionDef,
-  FunctionTrigger
-} from "../chunk-HBD2FZXO.mjs";
-import {
-  __require
-} from "../chunk-DHGBFXSZ.mjs";
-
-// packages/core/functions/src/testing/setup.ts
-import { getRandomPort } from "get-port-please";
-import path2 from "node: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 "node: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 "node: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