@dxos/functions 0.6.10 → 0.6.11-staging.30cf5ba

package/dist/lib/node/testing/index.cjs

@@ -37,17 +37,30 @@ __export(testing_exports, {
   triggerWebhook: () => triggerWebhook
 });
 module.exports = __toCommonJS(testing_exports);
-var import_chunk_ITQU6E54 = require("../chunk-ITQU6E54.cjs");
-var import_chunk_3E6PY6JH = require("../chunk-3E6PY6JH.cjs");
+var import_chunk_V7JNSENS = require("../chunk-V7JNSENS.cjs");
+var import_chunk_GGTHSME4 = require("../chunk-GGTHSME4.cjs");
 var import_get_port_please = require("get-port-please");
 var import_node_path = __toESM(require("node:path"));
 var import_async = require("@dxos/async");
 var import_client = require("@dxos/client");
 var import_util = require("@dxos/util");
 var import_echo_schema = require("@dxos/echo-schema");
+var import_express = __toESM(require("express"));
+var import_get_port_please2 = require("get-port-please");
+var import_node_path2 = require("node:path");
+var import_async2 = require("@dxos/async");
+var import_context = require("@dxos/context");
+var import_invariant = require("@dxos/invariant");
+var import_log = require("@dxos/log");
+var import_node_path3 = __toESM(require("node:path"));
+var import_async3 = require("@dxos/async");
 var import_echo = require("@dxos/client/echo");
+var import_context2 = require("@dxos/context");
+var import_echo_protocol = require("@dxos/echo-protocol");
+var import_log2 = require("@dxos/log");
+var import_echo2 = require("@dxos/client/echo");
 var import_testing = require("@dxos/client/testing");
-var import_invariant = require("@dxos/invariant");
+var import_invariant2 = require("@dxos/invariant");
 var import_services = require("@dxos/protocols/proto/dxos/client/services");
 var TestType = class extends (0, import_echo_schema.TypedObject)({
   typename: "example.com/type/Test",
@@ -56,6 +69,501 @@ var TestType = class extends (0, import_echo_schema.TypedObject)({
   title: import_echo_schema.S.String
 }) {
 };
+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 import_async2.Event();
+  }
+  get stats() {
+    return {
+      seq: this._seq
+    };
+  }
+  get endpoint() {
+    (0, import_invariant.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() {
+    (0, import_invariant.invariant)(!this._server, void 0, {
+      F: __dxlog_file,
+      L: 73,
+      S: this,
+      A: [
+        "!this._server",
+        ""
+      ]
+    });
+    import_log.log.info("starting...", void 0, {
+      F: __dxlog_file,
+      L: 74,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._ctx = createContext();
+    const app = (0, import_express.default)();
+    app.use(import_express.default.json());
+    app.post("/:path", async (req, res) => {
+      const { path: path3 } = req.params;
+      try {
+        import_log.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 (0, import_async2.asyncTimeout)(this.invoke("/" + path3, req.body), FN_TIMEOUT);
+        res.end();
+      } catch (err) {
+        import_log.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 (0, import_get_port_please2.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
+      });
+      import_log.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).");
+    }
+    import_log.log.info("started", {
+      port: this._port
+    }, {
+      F: __dxlog_file,
+      L: 121,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async stop() {
+    if (!this._server) {
+      return;
+    }
+    import_log.log.info("stopping...", void 0, {
+      F: __dxlog_file,
+      L: 129,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this._ctx.dispose();
+    const trigger = new import_async2.Trigger();
+    this._server.close(async () => {
+      import_log.log.info("server stopped", void 0, {
+        F: __dxlog_file,
+        L: 134,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      try {
+        if (this._functionServiceRegistration) {
+          (0, import_invariant.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
+          });
+          import_log.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;
+    import_log.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();
+    (0, import_log.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 = (0, import_node_path2.join)(this._options.baseDir, handler);
+    import_log.log.info("loading", {
+      uri,
+      force
+    }, {
+      F: __dxlog_file,
+      L: 171,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (force) {
+      Object.keys(import_chunk_GGTHSME4.__require.cache).filter((key) => key.startsWith(filePath)).forEach((key) => {
+        delete import_chunk_GGTHSME4.__require.cache[key];
+      });
+    }
+    const module2 = (0, import_chunk_GGTHSME4.__require)(filePath);
+    if (typeof module2.default !== "function") {
+      throw new Error(`Handler must export default function: ${uri}`);
+    }
+    this._handlers[route] = {
+      def,
+      handler: module2.default
+    };
+  }
+  async _safeUpdateRegistration() {
+    (0, import_invariant.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) {
+      import_log.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();
+    import_log.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
+    });
+    import_log.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] ?? {};
+    (0, import_invariant.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 import_context.Context({
+  name: "DevServer"
+}, {
+  F: __dxlog_file,
+  L: 240
+});
+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(import_log2.log.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) {
+      import_log2.log.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 import_async3.Mutex();
+      this._functionUriToCallMutex.set(definition.uri, mutex);
+      import_log2.log.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 () => {
+        import_log2.log.info("mutex acquired", {
+          uri: definition.uri
+        }, {
+          F: __dxlog_file2,
+          L: 95,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        await (0, import_echo.loadObjectReferences)(trigger, (t) => Object.values(t.meta ?? {}));
+        const meta = {};
+        for (const [key, value] of Object.entries(trigger.meta ?? {})) {
+          if (value instanceof import_echo_protocol.Reference) {
+            const object = await space.db.loadObjectById(value.objectId);
+            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);
+    (0, import_log2.log)("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 = import_node_path3.default.join(endpoint, def.route);
+        import_log2.log.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) {
+        import_log2.log.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}`);
+      }
+      import_log2.log.info("done", {
+        function: def.uri,
+        status
+      }, {
+        F: __dxlog_file2,
+        L: 160,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    } catch (err) {
+      import_log2.log.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 import_context2.Context({
+  name: "FunctionScheduler"
+}, {
+  F: __dxlog_file2,
+  L: 170
+});
 var createInitializedClients = async (testBuilder, count = 1, config) => {
   const clients = (0, import_util.range)(count).map(() => new import_client.Client({
     config,
@@ -69,8 +577,8 @@ var createInitializedClients = async (testBuilder, count = 1, config) => {
     });
     await client.spaces.isReady.wait();
     client.addTypes([
-      import_chunk_3E6PY6JH.FunctionDef,
-      import_chunk_3E6PY6JH.FunctionTrigger,
+      import_chunk_GGTHSME4.FunctionDef,
+      import_chunk_GGTHSME4.FunctionTrigger,
       TestType
     ]);
     return client;
@@ -99,7 +607,7 @@ var createFunctionRuntime = async (testBuilder, pluginInitializer) => {
 };
 var startFunctionsHost = async (testBuilder, pluginInitializer, options) => {
   const functionRuntime = await createFunctionRuntime(testBuilder, pluginInitializer);
-  const functionsRegistry = new import_chunk_ITQU6E54.FunctionRegistry(functionRuntime);
+  const functionsRegistry = new import_chunk_V7JNSENS.FunctionRegistry(functionRuntime);
   const devServer = await startDevServer(testBuilder, functionRuntime, functionsRegistry, options);
   const scheduler = await startScheduler(testBuilder, functionRuntime, devServer, functionsRegistry);
   return {
@@ -113,8 +621,8 @@ var startFunctionsHost = async (testBuilder, pluginInitializer, options) => {
   };
 };
 var startScheduler = async (testBuilder, client, devServer, functionRegistry) => {
-  const triggerRegistry = new import_chunk_ITQU6E54.TriggerRegistry(client);
-  const scheduler = new import_chunk_ITQU6E54.Scheduler(functionRegistry, triggerRegistry, {
+  const triggerRegistry = new import_chunk_V7JNSENS.TriggerRegistry(client);
+  const scheduler = new Scheduler(functionRegistry, triggerRegistry, {
     endpoint: devServer.endpoint
   });
   await scheduler.start();
@@ -122,7 +630,7 @@ var startScheduler = async (testBuilder, client, devServer, functionRegistry) =>
   return scheduler;
 };
 var startDevServer = async (testBuilder, client, functionRegistry, options) => {
-  const server = new import_chunk_ITQU6E54.DevServer(client, functionRegistry, {
+  const server = new DevServer(client, functionRegistry, {
     baseDir: import_node_path.default.join(__dirname, "../testing"),
     port: await (0, import_get_port_please.getRandomPort)("127.0.0.1"),
     ...options
@@ -131,11 +639,11 @@ var startDevServer = async (testBuilder, client, functionRegistry, options) => {
   testBuilder.ctx.onDispose(() => server.stop());
   return server;
 };
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/functions/src/testing/util.ts";
+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(import_echo.Filter.schema(import_chunk_3E6PY6JH.FunctionTrigger, (t) => t.function === uri)).run()).objects[0];
-  (0, import_invariant.invariant)(trigger.spec.type === "webhook", void 0, {
-    F: __dxlog_file,
+  const trigger = (await space.db.query(import_echo2.Filter.schema(import_chunk_GGTHSME4.FunctionTrigger, (t) => t.function === uri)).run()).objects[0];
+  (0, import_invariant2.invariant)(trigger.spec.type === "webhook", void 0, {
+    F: __dxlog_file3,
     L: 17,
     S: void 0,
     A: [