@dxos/functions 0.6.11-staging.e6894a4 → 0.6.12-main.5cc132e

package/dist/lib/node-esm/chunk-KFC4XAIY.mjs

@@ -0,0 +1,78 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// packages/core/functions/src/types.ts
+import { RawObject, S, TypedObject } from "@dxos/echo-schema";
+var SubscriptionTriggerSchema = S.mutable(S.Struct({
+  type: S.Literal("subscription"),
+  // TODO(burdon): Define query DSL (from ECHO).
+  filter: S.Array(S.Struct({
+    type: S.String,
+    props: S.optional(S.Record(S.String, S.Any))
+  })),
+  options: S.optional(S.Struct({
+    // Watch changes to object (not just creation).
+    deep: S.optional(S.Boolean),
+    // Debounce changes (delay in ms).
+    delay: S.optional(S.Number)
+  }))
+}));
+var TimerTriggerSchema = S.mutable(S.Struct({
+  type: S.Literal("timer"),
+  cron: S.String
+}));
+var WebhookTriggerSchema = S.mutable(S.Struct({
+  type: S.Literal("webhook"),
+  method: S.String,
+  // Assigned port.
+  port: S.optional(S.Number)
+}));
+var WebsocketTriggerSchema = S.mutable(S.Struct({
+  type: S.Literal("websocket"),
+  url: S.String,
+  init: S.optional(S.Record(S.String, S.Any))
+}));
+var TriggerSpecSchema = S.Union(TimerTriggerSchema, WebhookTriggerSchema, WebsocketTriggerSchema, SubscriptionTriggerSchema);
+var FunctionDef = class extends TypedObject({
+  typename: "dxos.org/type/FunctionDef",
+  version: "0.1.0"
+})({
+  uri: S.String,
+  description: S.optional(S.String),
+  route: S.String,
+  handler: S.String
+}) {
+};
+var FunctionTrigger = class extends TypedObject({
+  typename: "dxos.org/type/FunctionTrigger",
+  version: "0.1.0"
+})({
+  name: S.optional(S.String),
+  enabled: S.optional(S.Boolean),
+  function: S.String.pipe(S.description("Function URI.")),
+  // The `meta` property is merged into the event data passed to the function.
+  meta: S.optional(S.mutable(S.Record(S.String, S.Any))),
+  spec: TriggerSpecSchema
+}) {
+};
+var FunctionManifestSchema = S.Struct({
+  functions: S.optional(S.mutable(S.Array(RawObject(FunctionDef)))),
+  triggers: S.optional(S.mutable(S.Array(RawObject(FunctionTrigger))))
+});
+var FUNCTION_SCHEMA = [
+  FunctionDef,
+  FunctionTrigger
+];
+
+export {
+  __require,
+  FunctionDef,
+  FunctionTrigger,
+  FunctionManifestSchema,
+  FUNCTION_SCHEMA
+};
+//# sourceMappingURL=chunk-KFC4XAIY.mjs.map

package/dist/lib/node-esm/chunk-KFC4XAIY.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/types.ts"],
+  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport { RawObject, S, TypedObject } from '@dxos/echo-schema';\n\n/**\n * Type discriminator for TriggerSpec.\n * Every spec has a type field of type FunctionTriggerType that we can use to understand which\n * type we're working with.\n * https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions\n */\nexport type FunctionTriggerType = 'subscription' | 'timer' | 'webhook' | 'websocket';\n\nconst SubscriptionTriggerSchema = S.mutable(\n  S.Struct({\n    type: S.Literal('subscription'),\n    // TODO(burdon): Define query DSL (from ECHO).\n    filter: S.Array(\n      S.Struct({\n        type: S.String,\n        props: S.optional(S.Record(S.String, S.Any)),\n      }),\n    ),\n    options: S.optional(\n      S.Struct({\n        // Watch changes to object (not just creation).\n        deep: S.optional(S.Boolean),\n        // Debounce changes (delay in ms).\n        delay: S.optional(S.Number),\n      }),\n    ),\n  }),\n);\n\nexport type SubscriptionTrigger = S.Schema.Type<typeof SubscriptionTriggerSchema>;\n\nconst TimerTriggerSchema = S.mutable(\n  S.Struct({\n    type: S.Literal('timer'),\n    cron: S.String,\n  }),\n);\n\nexport type TimerTrigger = S.Schema.Type<typeof TimerTriggerSchema>;\n\nconst WebhookTriggerSchema = S.mutable(\n  S.Struct({\n    type: S.Literal('webhook'),\n    method: S.String,\n    // Assigned port.\n    port: S.optional(S.Number),\n  }),\n);\n\nexport type WebhookTrigger = S.Schema.Type<typeof WebhookTriggerSchema>;\n\nconst WebsocketTriggerSchema = S.mutable(\n  S.Struct({\n    type: S.Literal('websocket'),\n    url: S.String,\n    init: S.optional(S.Record(S.String, S.Any)),\n  }),\n);\n\nexport type WebsocketTrigger = S.Schema.Type<typeof WebsocketTriggerSchema>;\n\nconst TriggerSpecSchema = S.Union(\n  TimerTriggerSchema,\n  WebhookTriggerSchema,\n  WebsocketTriggerSchema,\n  SubscriptionTriggerSchema,\n);\n\nexport type TriggerSpec = TimerTrigger | WebhookTrigger | WebsocketTrigger | SubscriptionTrigger;\n\n/**\n * Function definition.\n */\nexport class FunctionDef extends TypedObject({\n  typename: 'dxos.org/type/FunctionDef',\n  version: '0.1.0',\n})({\n  uri: S.String,\n  description: S.optional(S.String),\n  route: S.String,\n  handler: S.String,\n}) {}\n\n/**\n * Function trigger.\n */\nexport class FunctionTrigger extends TypedObject({\n  typename: 'dxos.org/type/FunctionTrigger',\n  version: '0.1.0',\n})({\n  name: S.optional(S.String),\n  enabled: S.optional(S.Boolean),\n  function: S.String.pipe(S.description('Function URI.')),\n  // The `meta` property is merged into the event data passed to the function.\n  meta: S.optional(S.mutable(S.Record(S.String, S.Any))),\n  spec: TriggerSpecSchema,\n}) {}\n\n/**\n * Function manifest file.\n */\nexport const FunctionManifestSchema = S.Struct({\n  functions: S.optional(S.mutable(S.Array(RawObject(FunctionDef)))),\n  triggers: S.optional(S.mutable(S.Array(RawObject(FunctionTrigger)))),\n});\n\nexport type FunctionManifest = S.Schema.Type<typeof FunctionManifestSchema>;\n\n// TODO(burdon): Standards?\nexport const FUNCTION_SCHEMA = [FunctionDef, FunctionTrigger];\n"],
+  "mappings": ";;;;;;;;AAIA,SAASA,WAAWC,GAAGC,mBAAmB;AAU1C,IAAMC,4BAA4BC,EAAEC,QAClCD,EAAEE,OAAO;EACPC,MAAMH,EAAEI,QAAQ,cAAA;;EAEhBC,QAAQL,EAAEM,MACRN,EAAEE,OAAO;IACPC,MAAMH,EAAEO;IACRC,OAAOR,EAAES,SAAST,EAAEU,OAAOV,EAAEO,QAAQP,EAAEW,GAAG,CAAA;EAC5C,CAAA,CAAA;EAEFC,SAASZ,EAAES,SACTT,EAAEE,OAAO;;IAEPW,MAAMb,EAAES,SAAST,EAAEc,OAAO;;IAE1BC,OAAOf,EAAES,SAAST,EAAEgB,MAAM;EAC5B,CAAA,CAAA;AAEJ,CAAA,CAAA;AAKF,IAAMC,qBAAqBjB,EAAEC,QAC3BD,EAAEE,OAAO;EACPC,MAAMH,EAAEI,QAAQ,OAAA;EAChBc,MAAMlB,EAAEO;AACV,CAAA,CAAA;AAKF,IAAMY,uBAAuBnB,EAAEC,QAC7BD,EAAEE,OAAO;EACPC,MAAMH,EAAEI,QAAQ,SAAA;EAChBgB,QAAQpB,EAAEO;;EAEVc,MAAMrB,EAAES,SAAST,EAAEgB,MAAM;AAC3B,CAAA,CAAA;AAKF,IAAMM,yBAAyBtB,EAAEC,QAC/BD,EAAEE,OAAO;EACPC,MAAMH,EAAEI,QAAQ,WAAA;EAChBmB,KAAKvB,EAAEO;EACPiB,MAAMxB,EAAES,SAAST,EAAEU,OAAOV,EAAEO,QAAQP,EAAEW,GAAG,CAAA;AAC3C,CAAA,CAAA;AAKF,IAAMc,oBAAoBzB,EAAE0B,MAC1BT,oBACAE,sBACAG,wBACAvB,yBAAAA;AAQK,IAAM4B,cAAN,cAA0BC,YAAY;EAC3CC,UAAU;EACVC,SAAS;AACX,CAAA,EAAG;EACDC,KAAK/B,EAAEO;EACPyB,aAAahC,EAAES,SAAST,EAAEO,MAAM;EAChC0B,OAAOjC,EAAEO;EACT2B,SAASlC,EAAEO;AACb,CAAA,EAAA;AAAI;AAKG,IAAM4B,kBAAN,cAA8BP,YAAY;EAC/CC,UAAU;EACVC,SAAS;AACX,CAAA,EAAG;EACDM,MAAMpC,EAAES,SAAST,EAAEO,MAAM;EACzB8B,SAASrC,EAAES,SAAST,EAAEc,OAAO;EAC7BwB,UAAUtC,EAAEO,OAAOgC,KAAKvC,EAAEgC,YAAY,eAAA,CAAA;;EAEtCQ,MAAMxC,EAAES,SAAST,EAAEC,QAAQD,EAAEU,OAAOV,EAAEO,QAAQP,EAAEW,GAAG,CAAA,CAAA;EACnD8B,MAAMhB;AACR,CAAA,EAAA;AAAI;AAKG,IAAMiB,yBAAyB1C,EAAEE,OAAO;EAC7CyC,WAAW3C,EAAES,SAAST,EAAEC,QAAQD,EAAEM,MAAMsC,UAAUjB,WAAAA,CAAAA,CAAAA,CAAAA;EAClDkB,UAAU7C,EAAES,SAAST,EAAEC,QAAQD,EAAEM,MAAMsC,UAAUT,eAAAA,CAAAA,CAAAA,CAAAA;AACnD,CAAA;AAKO,IAAMW,kBAAkB;EAACnB;EAAaQ;;",
+  "names": ["RawObject", "S", "TypedObject", "SubscriptionTriggerSchema", "S", "mutable", "Struct", "type", "Literal", "filter", "Array", "String", "props", "optional", "Record", "Any", "options", "deep", "Boolean", "delay", "Number", "TimerTriggerSchema", "cron", "WebhookTriggerSchema", "method", "port", "WebsocketTriggerSchema", "url", "init", "TriggerSpecSchema", "Union", "FunctionDef", "TypedObject", "typename", "version", "uri", "description", "route", "handler", "FunctionTrigger", "name", "enabled", "function", "pipe", "meta", "spec", "FunctionManifestSchema", "functions", "RawObject", "triggers", "FUNCTION_SCHEMA"]
+}

package/dist/lib/node-esm/chunk-ZZQ234R7.mjs

@@ -0,0 +1,597 @@
+import {
+  FunctionDef,
+  FunctionTrigger
+} from "./chunk-KFC4XAIY.mjs";
+
+// packages/core/functions/src/function/function-registry.ts
+import { Event } from "@dxos/async";
+import { create, Filter } from "@dxos/client/echo";
+import { Resource } from "@dxos/context";
+import { PublicKey } from "@dxos/keys";
+import { log } from "@dxos/log";
+import { ComplexMap, diff } from "@dxos/util";
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/functions/src/function/function-registry.ts";
+var FunctionRegistry = class extends Resource {
+  constructor(_client) {
+    super();
+    this._client = _client;
+    this._functionBySpaceKey = new ComplexMap(PublicKey.hash);
+    this.registered = new Event();
+  }
+  getFunctions(space) {
+    return this._functionBySpaceKey.get(space.key) ?? [];
+  }
+  getUniqueByUri() {
+    const uniqueByUri = [
+      ...this._functionBySpaceKey.values()
+    ].flatMap((defs) => defs).reduce((acc, v) => {
+      acc.set(v.uri, v);
+      return acc;
+    }, /* @__PURE__ */ new Map());
+    return [
+      ...uniqueByUri.values()
+    ];
+  }
+  /**
+  * Loads function definitions from the manifest into the space.
+  * We first load all the definitions from the space to deduplicate by functionId.
+  */
+  async register(space, functions) {
+    log("register", {
+      space: space.key,
+      functions: functions?.length ?? 0
+    }, {
+      F: __dxlog_file,
+      L: 48,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (!functions?.length) {
+      return;
+    }
+    if (!space.db.graph.schemaRegistry.hasSchema(FunctionDef)) {
+      space.db.graph.schemaRegistry.addSchema([
+        FunctionDef
+      ]);
+    }
+    const { objects: existing } = await space.db.query(Filter.schema(FunctionDef)).run();
+    const { added } = diff(existing, functions, (a, b) => a.uri === b.uri);
+    added.forEach((def) => space.db.add(create(FunctionDef, def)));
+    if (added.length > 0) {
+      await space.db.flush({
+        indexes: true,
+        updates: true
+      });
+    }
+  }
+  async _open() {
+    log.info("opening...", void 0, {
+      F: __dxlog_file,
+      L: 68,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const spacesSubscription = this._client.spaces.subscribe(async (spaces) => {
+      for (const space of spaces) {
+        if (this._functionBySpaceKey.has(space.key)) {
+          continue;
+        }
+        const registered = [];
+        this._functionBySpaceKey.set(space.key, registered);
+        await space.waitUntilReady();
+        if (this._ctx.disposed) {
+          break;
+        }
+        this._ctx.onDispose(space.db.query(Filter.schema(FunctionDef)).subscribe(({ objects }) => {
+          const { added } = diff(registered, objects, (a, b) => a.uri === b.uri);
+          if (added.length > 0) {
+            registered.push(...added);
+            this.registered.emit({
+              space,
+              added
+            });
+          }
+        }));
+      }
+    });
+    this._ctx.onDispose(() => spacesSubscription.unsubscribe());
+  }
+  async _close(_) {
+    log.info("closing...", void 0, {
+      F: __dxlog_file,
+      L: 101,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._functionBySpaceKey.clear();
+  }
+};
+
+// packages/core/functions/src/trigger/type/subscription-trigger.ts
+import { debounce, UpdateScheduler } from "@dxos/async";
+import { Filter as Filter2 } from "@dxos/client/echo";
+import { createSubscription } from "@dxos/echo-db";
+import { log as log2 } from "@dxos/log";
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/type/subscription-trigger.ts";
+var createSubscriptionTrigger = async (ctx, space, spec, callback) => {
+  const objectIds = /* @__PURE__ */ new Set();
+  const task = new UpdateScheduler(ctx, async () => {
+    if (objectIds.size > 0) {
+      const objects = Array.from(objectIds);
+      objectIds.clear();
+      await callback({
+        objects
+      });
+    }
+  }, {
+    maxFrequency: 4
+  });
+  const subscriptions = [];
+  const subscription = createSubscription(({ added, updated }) => {
+    const sizeBefore = objectIds.size;
+    for (const object of added) {
+      objectIds.add(object.id);
+    }
+    for (const object of updated) {
+      objectIds.add(object.id);
+    }
+    if (objectIds.size > sizeBefore) {
+      log2.info("updated", {
+        added: added.length,
+        updated: updated.length
+      }, {
+        F: __dxlog_file2,
+        L: 46,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      task.trigger();
+    }
+  });
+  subscriptions.push(() => subscription.unsubscribe());
+  const { filter, options: { deep, delay } = {} } = spec;
+  const update = ({ objects }) => {
+    log2.info("update", {
+      objects: objects.length
+    }, {
+      F: __dxlog_file2,
+      L: 56,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    subscription.update(objects);
+    if (deep) {
+    }
+  };
+  log2.info("subscription", {
+    filter
+  }, {
+    F: __dxlog_file2,
+    L: 74,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  if (filter) {
+    const query = space.db.query(Filter2.typename(filter[0].type, filter[0].props));
+    subscriptions.push(query.subscribe(delay ? debounce(update, delay) : update));
+  }
+  ctx.onDispose(() => {
+    subscriptions.forEach((unsubscribe) => unsubscribe());
+  });
+};
+
+// packages/core/functions/src/trigger/type/timer-trigger.ts
+import { CronJob } from "cron";
+import { DeferredTask } from "@dxos/async";
+import { log as log3 } from "@dxos/log";
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/type/timer-trigger.ts";
+var createTimerTrigger = async (ctx, space, spec, callback) => {
+  const task = new DeferredTask(ctx, async () => {
+    await callback({});
+  });
+  let last = 0;
+  let run = 0;
+  const job = CronJob.from({
+    cronTime: spec.cron,
+    runOnInit: false,
+    onTick: () => {
+      const now = Date.now();
+      const delta = last ? now - last : 0;
+      last = now;
+      run++;
+      log3.info("tick", {
+        space: space.key.truncate(),
+        count: run,
+        delta
+      }, {
+        F: __dxlog_file3,
+        L: 38,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      task.schedule();
+    }
+  });
+  job.start();
+  ctx.onDispose(() => job.stop());
+};
+
+// packages/core/functions/src/trigger/type/websocket-trigger.ts
+import { sleep, Trigger } from "@dxos/async";
+import { log as log4 } from "@dxos/log";
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/type/websocket-trigger.ts";
+var createWebsocketTrigger = async (ctx, space, spec, callback, options = {
+  retryDelay: 2,
+  maxAttempts: 5
+}) => {
+  const { url, init } = spec;
+  let wasOpen = false;
+  let ws;
+  for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
+    const open = new Trigger();
+    ws = await createWebSocket(url);
+    Object.assign(ws, {
+      onopen: () => {
+        log4.info("opened", {
+          url
+        }, {
+          F: __dxlog_file4,
+          L: 39,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+        if (spec.init) {
+          ws.send(new TextEncoder().encode(JSON.stringify(init)));
+        }
+        open.wake(true);
+      },
+      onclose: (event) => {
+        log4.info("closed", {
+          url,
+          code: event.code
+        }, {
+          F: __dxlog_file4,
+          L: 48,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+        if (event.code === 1006 && wasOpen && !ctx.disposed) {
+          setTimeout(async () => {
+            log4.info(`reconnecting in ${options.retryDelay}s...`, {
+              url
+            }, {
+              F: __dxlog_file4,
+              L: 53,
+              S: void 0,
+              C: (f, a) => f(...a)
+            });
+            await createWebsocketTrigger(ctx, space, spec, callback, options);
+          }, options.retryDelay * 1e3);
+        }
+        open.wake(false);
+      },
+      onerror: (event) => {
+        log4.catch(event.error ?? new Error("Unspecified ws error."), {
+          url
+        }, {
+          F: __dxlog_file4,
+          L: 61,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+        open.wake(false);
+      },
+      onmessage: async (event) => {
+        try {
+          log4.info("message", void 0, {
+            F: __dxlog_file4,
+            L: 67,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+          const data = JSON.parse(new TextDecoder().decode(event.data));
+          await callback({
+            data
+          });
+        } catch (err) {
+          log4.catch(err, {
+            url
+          }, {
+            F: __dxlog_file4,
+            L: 71,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+        }
+      }
+    });
+    const isOpen = await open.wait();
+    if (ctx.disposed) {
+      break;
+    }
+    if (isOpen) {
+      wasOpen = true;
+      break;
+    }
+    const wait = Math.pow(attempt, 2) * options.retryDelay;
+    if (attempt < options.maxAttempts) {
+      log4.warn(`failed to connect; trying again in ${wait}s`, {
+        attempt
+      }, {
+        F: __dxlog_file4,
+        L: 86,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      await sleep(wait * 1e3);
+    }
+  }
+  ctx.onDispose(() => {
+    ws?.close();
+  });
+};
+var createNodeWebSocket = async (url) => {
+  const importESM = Function("path", "return import(path)");
+  const { default: { WebSocket: WebSocket1 } } = await importESM("ws");
+  return new WebSocket1(url);
+};
+var createWebSocket = async (url) => {
+  return typeof globalThis.WebSocket === "undefined" ? await createNodeWebSocket(url) : new WebSocket(url);
+};
+
+// packages/core/functions/src/trigger/trigger-registry.ts
+import { Event as Event2 } from "@dxos/async";
+import { create as create2, Filter as Filter3, getMeta } from "@dxos/client/echo";
+import { Context, Resource as Resource2 } from "@dxos/context";
+import { compareForeignKeys, ECHO_ATTR_META, foreignKey } from "@dxos/echo-schema";
+import { invariant } from "@dxos/invariant";
+import { PublicKey as PublicKey2 } from "@dxos/keys";
+import { log as log5 } from "@dxos/log";
+import { ComplexMap as ComplexMap2, diff as diff2 } from "@dxos/util";
+var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/trigger-registry.ts";
+var triggerFactory = {
+  subscription: createSubscriptionTrigger,
+  timer: createTimerTrigger,
+  // TODO(burdon): Cannot use in browser.
+  // webhook: createWebhookTrigger,
+  webhook: null,
+  websocket: createWebsocketTrigger
+};
+var TriggerRegistry = class extends Resource2 {
+  constructor(_client, _options) {
+    super();
+    this._client = _client;
+    this._options = _options;
+    this._triggersBySpaceKey = new ComplexMap2(PublicKey2.hash);
+    this.registered = new Event2();
+    this.removed = new Event2();
+  }
+  getActiveTriggers(space) {
+    return this._getTriggers(space, (t) => t.activationCtx != null);
+  }
+  getInactiveTriggers(space) {
+    return this._getTriggers(space, (t) => t.activationCtx == null);
+  }
+  /**
+  * Set callback for trigger.
+  */
+  async activate(space, trigger, callback) {
+    log5("activate", {
+      space: space.key,
+      trigger
+    }, {
+      F: __dxlog_file5,
+      L: 77,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const activationCtx = new Context({
+      name: `FunctionTrigger-${trigger.function}`
+    }, {
+      F: __dxlog_file5,
+      L: 79
+    });
+    this._ctx.onDispose(() => activationCtx.dispose());
+    const registeredTrigger = this._triggersBySpaceKey.get(space.key)?.find((reg) => reg.trigger.id === trigger.id);
+    invariant(registeredTrigger, `Trigger is not registered: ${trigger.function}`, {
+      F: __dxlog_file5,
+      L: 82,
+      S: this,
+      A: [
+        "registeredTrigger",
+        "`Trigger is not registered: ${trigger.function}`"
+      ]
+    });
+    registeredTrigger.activationCtx = activationCtx;
+    try {
+      const options = this._options?.[trigger.spec.type];
+      const createTrigger = triggerFactory[trigger.spec.type];
+      invariant(createTrigger, `Trigger factory not found: ${trigger.spec.type}`, {
+        F: __dxlog_file5,
+        L: 89,
+        S: this,
+        A: [
+          "createTrigger",
+          "`Trigger factory not found: ${trigger.spec.type}`"
+        ]
+      });
+      await createTrigger(activationCtx, space, trigger.spec, callback, options);
+    } catch (err) {
+      delete registeredTrigger.activationCtx;
+      throw err;
+    }
+  }
+  /**
+  * Loads triggers from the manifest into the space.
+  */
+  async register(space, manifest) {
+    log5("register", {
+      space: space.key
+    }, {
+      F: __dxlog_file5,
+      L: 101,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (!manifest.triggers?.length) {
+      return;
+    }
+    if (!space.db.graph.schemaRegistry.hasSchema(FunctionTrigger)) {
+      space.db.graph.schemaRegistry.addSchema([
+        FunctionTrigger
+      ]);
+    }
+    const manifestTriggers = manifest.triggers.map((trigger) => {
+      let keys = trigger[ECHO_ATTR_META]?.keys;
+      delete trigger[ECHO_ATTR_META];
+      if (!keys?.length) {
+        keys = [
+          foreignKey("manifest", [
+            trigger.function,
+            trigger.spec.type
+          ].join(":"))
+        ];
+      }
+      return create2(FunctionTrigger, trigger, {
+        keys
+      });
+    });
+    const { objects: existing } = await space.db.query(Filter3.schema(FunctionTrigger)).run();
+    const { added } = diff2(existing, manifestTriggers, compareForeignKeys);
+    added.forEach((trigger) => {
+      space.db.add(trigger);
+      log5.info("added", {
+        meta: getMeta(trigger)
+      }, {
+        F: __dxlog_file5,
+        L: 128,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    });
+    if (added.length > 0) {
+      await space.db.flush();
+    }
+  }
+  async _open() {
+    log5.info("open...", void 0, {
+      F: __dxlog_file5,
+      L: 137,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const spaceListSubscription = this._client.spaces.subscribe(async (spaces) => {
+      for (const space of spaces) {
+        if (this._triggersBySpaceKey.has(space.key)) {
+          continue;
+        }
+        const registered = [];
+        this._triggersBySpaceKey.set(space.key, registered);
+        await space.waitUntilReady();
+        if (this._ctx.disposed) {
+          break;
+        }
+        this._ctx.onDispose(space.db.query(Filter3.schema(FunctionTrigger)).subscribe(async ({ objects: current }) => {
+          log5.info("update", {
+            space: space.key,
+            registered: registered.length,
+            current: current.length
+          }, {
+            F: __dxlog_file5,
+            L: 154,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          await this._handleRemovedTriggers(space, current, registered);
+          this._handleNewTriggers(space, current, registered);
+        }));
+      }
+    });
+    this._ctx.onDispose(() => spaceListSubscription.unsubscribe());
+    log5.info("opened", void 0, {
+      F: __dxlog_file5,
+      L: 163,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async _close(_) {
+    log5.info("close...", void 0, {
+      F: __dxlog_file5,
+      L: 167,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._triggersBySpaceKey.clear();
+    log5.info("closed", void 0, {
+      F: __dxlog_file5,
+      L: 169,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  _handleNewTriggers(space, current, registered) {
+    const added = current.filter((candidate) => {
+      return candidate.enabled && registered.find((reg) => reg.trigger.id === candidate.id) == null;
+    });
+    if (added.length > 0) {
+      const newRegisteredTriggers = added.map((trigger) => ({
+        trigger
+      }));
+      registered.push(...newRegisteredTriggers);
+      log5.info("added", () => ({
+        spaceKey: space.key,
+        triggers: added.map((trigger) => trigger.function)
+      }), {
+        F: __dxlog_file5,
+        L: 180,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this.registered.emit({
+        space,
+        triggers: added
+      });
+    }
+  }
+  async _handleRemovedTriggers(space, current, registered) {
+    const removed = [];
+    for (let i = registered.length - 1; i >= 0; i--) {
+      const wasRemoved = current.filter((trigger) => trigger.enabled).find((trigger) => trigger.id === registered[i].trigger.id) == null;
+      if (wasRemoved) {
+        const unregistered = registered.splice(i, 1)[0];
+        await unregistered.activationCtx?.dispose();
+        removed.push(unregistered.trigger);
+      }
+    }
+    if (removed.length > 0) {
+      log5.info("removed", () => ({
+        spaceKey: space.key,
+        triggers: removed.map((trigger) => trigger.function)
+      }), {
+        F: __dxlog_file5,
+        L: 206,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this.removed.emit({
+        space,
+        triggers: removed
+      });
+    }
+  }
+  _getTriggers(space, predicate) {
+    const allSpaceTriggers = this._triggersBySpaceKey.get(space.key) ?? [];
+    return allSpaceTriggers.filter(predicate).map((trigger) => trigger.trigger);
+  }
+};
+
+export {
+  FunctionRegistry,
+  createSubscriptionTrigger,
+  createTimerTrigger,
+  createWebsocketTrigger,
+  createWebSocket,
+  TriggerRegistry
+};
+//# sourceMappingURL=chunk-ZZQ234R7.mjs.map