@objectstack/plugin-webhooks 5.0.0 → 5.2.0

package/dist/index.cjs

@@ -0,0 +1,747 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkM4M5FWIHcjs = require('./chunk-M4M5FWIH.cjs');
+
+
+
+var _chunkOW7ESXOKcjs = require('./chunk-OW7ESXOK.cjs');
+
+// src/webhook-outbox-plugin.ts
+var _integration = require('@objectstack/platform-objects/integration');
+
+// src/auto-enqueuer.ts
+var AutoEnqueuer = class {
+  constructor(engine, realtime, outbox, opts = {}) {
+    this.engine = engine;
+    this.realtime = realtime;
+    this.outbox = outbox;
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.running = false;
+    this.subscriptionsObject = _nullishCoalesce(opts.subscriptionsObject, () => ( "sys_webhook"));
+    this.refreshIntervalMs = _nullishCoalesce(opts.refreshIntervalMs, () => ( 6e4));
+    this.logger = _nullishCoalesce(opts.logger, () => ( {}));
+  }
+  /**
+   * Load the subscription cache and start listening for events.
+   */
+  async start() {
+    if (this.running) return;
+    this.running = true;
+    await this.refresh();
+    this.subId = await this.realtime.subscribe(
+      "webhook-auto-enqueuer",
+      (event) => this.handleEvent(event)
+    );
+    this.subIdSelfHeal = await this.realtime.subscribe(
+      "webhook-auto-enqueuer-self-heal",
+      (event) => this.handleSelfHealEvent(event),
+      { object: this.subscriptionsObject }
+    );
+    if (this.refreshIntervalMs > 0) {
+      this.refreshTimer = setInterval(() => {
+        this.refresh().catch(
+          (err) => _optionalChain([this, 'access', _ => _.logger, 'access', _2 => _2.warn, 'optionalCall', _3 => _3("[webhook-auto-enqueuer] periodic refresh failed", err)])
+        );
+      }, this.refreshIntervalMs);
+      _optionalChain([this, 'access', _4 => _4.refreshTimer, 'access', _5 => _5.unref, 'optionalCall', _6 => _6()]);
+    }
+  }
+  async stop() {
+    if (!this.running) return;
+    this.running = false;
+    if (this.subId) await this.realtime.unsubscribe(this.subId);
+    if (this.subIdSelfHeal) await this.realtime.unsubscribe(this.subIdSelfHeal);
+    if (this.refreshTimer) clearInterval(this.refreshTimer);
+    this.subId = void 0;
+    this.subIdSelfHeal = void 0;
+    this.refreshTimer = void 0;
+  }
+  /**
+   * Force-refresh the subscription cache from storage. Concurrent
+   * callers share a single in-flight refresh.
+   */
+  async refresh() {
+    if (this.refreshing) return this.refreshing;
+    this.refreshing = this.doRefresh().finally(() => {
+      this.refreshing = void 0;
+    });
+    return this.refreshing;
+  }
+  async doRefresh() {
+    let rows;
+    try {
+      rows = await this.engine.find(this.subscriptionsObject, {
+        where: { active: true }
+      });
+    } catch (err) {
+      _optionalChain([this, 'access', _7 => _7.logger, 'access', _8 => _8.warn, 'optionalCall', _9 => _9(
+        `[webhook-auto-enqueuer] failed to load ${this.subscriptionsObject}`,
+        err
+      )]);
+      return;
+    }
+    const next = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const sub = this.parseRow(row);
+      if (!sub) continue;
+      const key = _nullishCoalesce(sub.objectName, () => ( "*"));
+      const arr = _nullishCoalesce(next.get(key), () => ( []));
+      arr.push(sub);
+      next.set(key, arr);
+    }
+    this.subscriptions.clear();
+    for (const [k, v] of next) this.subscriptions.set(k, v);
+    _optionalChain([this, 'access', _10 => _10.logger, 'access', _11 => _11.debug, 'optionalCall', _12 => _12("[webhook-auto-enqueuer] cache refreshed", {
+      objects: this.subscriptions.size,
+      rows: rows.length
+    })]);
+  }
+  parseRow(row) {
+    if (!_optionalChain([row, 'optionalAccess', _13 => _13.id]) || !_optionalChain([row, 'optionalAccess', _14 => _14.url])) return null;
+    const triggersField = _nullishCoalesce(row.triggers, () => ( ""));
+    const triggers = new Set(
+      triggersField.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean)
+    );
+    if (triggers.size === 0) {
+      return null;
+    }
+    let defn = {};
+    if (typeof row.definition_json === "string" && row.definition_json.length > 0) {
+      try {
+        defn = _nullishCoalesce(JSON.parse(row.definition_json), () => ( {}));
+      } catch (e2) {
+        defn = {};
+      }
+    }
+    return {
+      id: row.id,
+      name: _nullishCoalesce(row.name, () => ( row.id)),
+      objectName: row.object_name ? String(row.object_name) : void 0,
+      triggers,
+      url: String(row.url),
+      method: _nullishCoalesce(_nullishCoalesce(row.method, () => ( defn.method)), () => ( "POST")),
+      headers: defn.headers,
+      secret: defn.secret,
+      timeoutMs: defn.timeoutMs
+    };
+  }
+  /**
+   * Handler for the firehose subscription.
+   *
+   * NOTE: we intentionally `void` the inner enqueue() so the realtime
+   * publisher (and therefore the user's request) is never blocked on
+   * webhook persistence.
+   */
+  handleEvent(event) {
+    if (!_optionalChain([event, 'access', _15 => _15.type, 'optionalAccess', _16 => _16.startsWith, 'call', _17 => _17("data.record.")])) return;
+    if (!event.object) return;
+    if (event.object === this.subscriptionsObject) return;
+    const action = event.type.slice("data.record.".length);
+    const trigger = mapActionToTrigger(action);
+    if (!trigger) return;
+    const subs = [
+      ..._nullishCoalesce(this.subscriptions.get(event.object), () => ( [])),
+      ..._nullishCoalesce(this.subscriptions.get("*"), () => ( []))
+    ];
+    if (subs.length === 0) return;
+    const payload = _nullishCoalesce(event.payload, () => ( {}));
+    const recordId = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(payload.recordId, () => ( payload.id)), () => ( _optionalChain([payload, 'access', _18 => _18.after, 'optionalAccess', _19 => _19.id]))), () => ( _optionalChain([payload, 'access', _20 => _20.before, 'optionalAccess', _21 => _21.id]))), () => ( "unknown"));
+    const eventId = `${event.object}:${recordId}:${action}:${event.timestamp}`;
+    for (const sub of subs) {
+      if (!sub.triggers.has(trigger)) continue;
+      void this.outbox.enqueue({
+        webhookId: sub.id,
+        eventId,
+        eventType: event.type,
+        url: sub.url,
+        method: sub.method,
+        headers: sub.headers,
+        secret: sub.secret,
+        timeoutMs: sub.timeoutMs,
+        payload: {
+          object: event.object,
+          recordId,
+          action,
+          timestamp: event.timestamp,
+          ...payload
+        }
+      }).catch(
+        (err) => _optionalChain([this, 'access', _22 => _22.logger, 'access', _23 => _23.warn, 'optionalCall', _24 => _24("[webhook-auto-enqueuer] enqueue failed", {
+          webhook: sub.name,
+          eventId,
+          err: _nullishCoalesce(_optionalChain([err, 'optionalAccess', _25 => _25.message]), () => ( err))
+        })])
+      );
+    }
+  }
+  handleSelfHealEvent(event) {
+    if (event.object !== this.subscriptionsObject) return;
+    if (!_optionalChain([event, 'access', _26 => _26.type, 'optionalAccess', _27 => _27.startsWith, 'call', _28 => _28("data.record.")])) return;
+    this.refresh().catch(
+      (err) => _optionalChain([this, 'access', _29 => _29.logger, 'access', _30 => _30.warn, 'optionalCall', _31 => _31("[webhook-auto-enqueuer] self-heal refresh failed", err)])
+    );
+  }
+  /** Test / admin accessor. */
+  snapshot() {
+    return this.subscriptions;
+  }
+};
+function mapActionToTrigger(action) {
+  switch (action) {
+    case "created":
+      return "create";
+    case "updated":
+      return "update";
+    case "deleted":
+      return "delete";
+    case "undeleted":
+      return "undelete";
+    default:
+      return null;
+  }
+}
+
+// src/http-sender.ts
+var _crypto = require('crypto');
+var DEFAULT_TIMEOUT_MS = 15e3;
+var RESPONSE_BODY_CAP = 16 * 1024;
+async function sendOnce(delivery, fetchImpl) {
+  const body = typeof delivery.payload === "string" ? delivery.payload : JSON.stringify(delivery.payload);
+  const headers = {
+    "Content-Type": "application/json",
+    "User-Agent": "ObjectStack-Webhooks/1.0",
+    "X-Objectstack-Event": delivery.eventType,
+    "X-Objectstack-Delivery": delivery.id,
+    "X-Objectstack-Attempt": String(delivery.attempts + 1),
+    ..._nullishCoalesce(delivery.headers, () => ( {}))
+  };
+  if (delivery.secret) {
+    const sig = _crypto.createHmac.call(void 0, "sha256", delivery.secret).update(body).digest("hex");
+    headers["X-Objectstack-Signature"] = `sha256=${sig}`;
+  }
+  const timeoutMs = _nullishCoalesce(delivery.timeoutMs, () => ( DEFAULT_TIMEOUT_MS));
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const start = Date.now();
+  try {
+    const res = await fetchImpl(delivery.url, {
+      method: _nullishCoalesce(delivery.method, () => ( "POST")),
+      headers,
+      body,
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    const responseText = await safeReadBody(res);
+    const durationMs = Date.now() - start;
+    if (res.ok) {
+      return { success: true, httpStatus: res.status, responseBody: responseText, durationMs };
+    }
+    const retriable = res.status === 408 || res.status === 429 || res.status >= 500;
+    return {
+      success: false,
+      retriable,
+      httpStatus: res.status,
+      responseBody: responseText,
+      error: `HTTP ${res.status}`,
+      durationMs
+    };
+  } catch (err) {
+    clearTimeout(timer);
+    const durationMs = Date.now() - start;
+    const e = err;
+    const error = _optionalChain([e, 'optionalAccess', _32 => _32.name]) === "AbortError" ? `timeout after ${timeoutMs}ms` : _nullishCoalesce(_optionalChain([e, 'optionalAccess', _33 => _33.message]), () => ( String(err)));
+    return { success: false, retriable: true, error, durationMs };
+  }
+}
+async function safeReadBody(res) {
+  try {
+    const text = await res.text();
+    return text.length > RESPONSE_BODY_CAP ? text.slice(0, RESPONSE_BODY_CAP) : text;
+  } catch (e3) {
+    return void 0;
+  }
+}
+function nextRetryDelayMs(attemptsSoFar, rng = Math.random) {
+  const SCHEDULE = [1e3, 1e4, 6e4, 6e5, 36e5, 216e5, 864e5];
+  if (attemptsSoFar < 1 || attemptsSoFar > SCHEDULE.length) return null;
+  const base = SCHEDULE[attemptsSoFar - 1];
+  const jitter = 0.8 + rng() * 0.4;
+  return Math.floor(base * jitter);
+}
+function classifyAttempt(outcome, attemptsSoFar, now = Date.now(), rng) {
+  if (outcome.success) return outcome;
+  if (!outcome.retriable) {
+    return {
+      success: false,
+      httpStatus: outcome.httpStatus,
+      responseBody: outcome.responseBody,
+      error: outcome.error,
+      durationMs: outcome.durationMs,
+      dead: true
+    };
+  }
+  const delay = nextRetryDelayMs(attemptsSoFar + 1, rng);
+  if (delay === null) {
+    return {
+      success: false,
+      httpStatus: outcome.httpStatus,
+      responseBody: outcome.responseBody,
+      error: outcome.error,
+      durationMs: outcome.durationMs,
+      dead: true
+    };
+  }
+  return {
+    success: false,
+    httpStatus: outcome.httpStatus,
+    responseBody: outcome.responseBody,
+    error: outcome.error,
+    durationMs: outcome.durationMs,
+    nextRetryAt: now + delay
+  };
+}
+
+// src/dispatcher.ts
+var WebhookDispatcher = class {
+  constructor(options) {
+    this.running = false;
+    const intervalMs = _nullishCoalesce(options.intervalMs, () => ( 250));
+    const lockTtlMs = _nullishCoalesce(options.lockTtlMs, () => ( intervalMs * 5));
+    this.opts = {
+      nodeId: options.nodeId,
+      cluster: options.cluster,
+      outbox: options.outbox,
+      partitionCount: _nullishCoalesce(options.partitionCount, () => ( 8)),
+      batchSize: _nullishCoalesce(options.batchSize, () => ( 32)),
+      intervalMs,
+      lockTtlMs,
+      claimTtlMs: _nullishCoalesce(options.claimTtlMs, () => ( lockTtlMs * 2)),
+      onAttempt: options.onAttempt,
+      fetchImpl: options.fetchImpl,
+      rng: options.rng,
+      logger: options.logger
+    };
+  }
+  /** Begin the periodic loop. Safe to call once; subsequent calls are no-ops. */
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.scheduleTick();
+    this.timer = setInterval(() => this.scheduleTick(), this.opts.intervalMs);
+  }
+  /** Stop the loop and wait for the in-flight tick to drain. */
+  async stop() {
+    if (!this.running) return;
+    this.running = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+    if (this.inflightTick) {
+      try {
+        await this.inflightTick;
+      } catch (e4) {
+      }
+    }
+  }
+  /**
+   * Run one full tick (all partitions, single attempt each). Exposed for
+   * deterministic tests that want to step the dispatcher manually.
+   */
+  async tick() {
+    await this.runTick();
+  }
+  scheduleTick() {
+    if (this.inflightTick) return;
+    this.inflightTick = this.runTick().catch((err) => {
+      _optionalChain([this, 'access', _34 => _34.opts, 'access', _35 => _35.logger, 'optionalAccess', _36 => _36.warn, 'optionalCall', _37 => _37("webhook-dispatcher: tick failed", {
+        nodeId: this.opts.nodeId,
+        error: _nullishCoalesce(_optionalChain([err, 'optionalAccess', _38 => _38.message]), () => ( String(err)))
+      })]);
+    }).finally(() => {
+      this.inflightTick = void 0;
+    });
+  }
+  async runTick() {
+    const partitionCount = this.opts.partitionCount;
+    const offset = stableNodeOffset(this.opts.nodeId, partitionCount);
+    for (let step = 0; step < partitionCount; step++) {
+      const i = (offset + step) % partitionCount;
+      await this.runPartition(i);
+    }
+  }
+  async runPartition(index) {
+    const key = `webhook.dispatcher.partition.${index}`;
+    const handle = await this.opts.cluster.lock.acquire(key, {
+      ttlMs: this.opts.lockTtlMs,
+      // waitMs=0 → fail-fast; we'll try this partition again next tick.
+      waitMs: 0
+    });
+    if (!handle) return;
+    try {
+      const claimed = await this.opts.outbox.claim({
+        nodeId: this.opts.nodeId,
+        limit: this.opts.batchSize,
+        partition: { index, count: this.opts.partitionCount },
+        claimTtlMs: this.opts.claimTtlMs
+      });
+      if (claimed.length === 0) return;
+      await handle.renew(this.opts.lockTtlMs);
+      for (const row of claimed) {
+        if (!handle.isHeld()) break;
+        await this.processRow(row);
+      }
+    } finally {
+      await handle.release();
+    }
+  }
+  async processRow(row) {
+    const fetchImpl = _nullishCoalesce(this.opts.fetchImpl, () => ( globalThis.fetch));
+    if (!fetchImpl) {
+      _optionalChain([this, 'access', _39 => _39.opts, 'access', _40 => _40.logger, 'optionalAccess', _41 => _41.warn, 'optionalCall', _42 => _42("webhook-dispatcher: no fetch impl available", {
+        rowId: row.id
+      })]);
+      await this.opts.outbox.ack(row.id, {
+        success: false,
+        error: "no fetch implementation",
+        durationMs: 0,
+        dead: true
+      });
+      return;
+    }
+    const outcome = await sendOnce(row, fetchImpl);
+    const result = classifyAttempt(outcome, row.attempts, Date.now(), this.opts.rng);
+    await this.opts.outbox.ack(row.id, result);
+    _optionalChain([this, 'access', _43 => _43.opts, 'access', _44 => _44.onAttempt, 'optionalCall', _45 => _45(row, result.success)]);
+  }
+};
+function stableNodeOffset(nodeId, partitionCount) {
+  let h = 0;
+  for (let i = 0; i < nodeId.length; i++) {
+    h = h * 31 + nodeId.charCodeAt(i) | 0;
+  }
+  return Math.abs(h) % partitionCount;
+}
+
+// src/memory-outbox.ts
+
+var MemoryWebhookOutbox = class {
+  constructor() {
+    this.rows = /* @__PURE__ */ new Map();
+    /** Dedup index keyed by `${eventId}::${webhookId}` -> row id. */
+    this.dedup = /* @__PURE__ */ new Map();
+  }
+  async enqueue(input) {
+    const dedupKey = `${input.eventId}::${input.webhookId}`;
+    const existing = this.dedup.get(dedupKey);
+    if (existing) return existing;
+    const id = _crypto.randomUUID.call(void 0, );
+    const now = Date.now();
+    const row = {
+      id,
+      webhookId: input.webhookId,
+      eventId: input.eventId,
+      eventType: input.eventType,
+      url: input.url,
+      method: _nullishCoalesce(input.method, () => ( "POST")),
+      headers: input.headers,
+      secret: input.secret,
+      timeoutMs: input.timeoutMs,
+      payload: input.payload,
+      status: "pending",
+      attempts: 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.rows.set(id, row);
+    this.dedup.set(dedupKey, id);
+    return id;
+  }
+  async claim(opts) {
+    const now = _nullishCoalesce(opts.now, () => ( Date.now()));
+    const claimed = [];
+    for (const row of this.rows.values()) {
+      if (row.status === "in_flight" && row.claimedAt !== void 0 && now - row.claimedAt > opts.claimTtlMs) {
+        row.status = "pending";
+        row.claimedBy = void 0;
+        row.claimedAt = void 0;
+        row.updatedAt = now;
+      }
+    }
+    for (const row of this.rows.values()) {
+      if (claimed.length >= opts.limit) break;
+      if (row.status !== "pending") continue;
+      if (row.nextRetryAt !== void 0 && row.nextRetryAt > now) continue;
+      if (opts.partition) {
+        const p = _chunkM4M5FWIHcjs.hashPartition.call(void 0, row.webhookId, opts.partition.count);
+        if (p !== opts.partition.index) continue;
+      }
+      row.status = "in_flight";
+      row.claimedBy = opts.nodeId;
+      row.claimedAt = now;
+      row.updatedAt = now;
+      claimed.push({ ...row });
+    }
+    return claimed;
+  }
+  async ack(id, result) {
+    const row = this.rows.get(id);
+    if (!row) return;
+    const now = Date.now();
+    row.attempts += 1;
+    row.lastAttemptedAt = now;
+    row.updatedAt = now;
+    row.claimedBy = void 0;
+    row.claimedAt = void 0;
+    row.responseCode = result.httpStatus;
+    row.responseBody = result.responseBody;
+    let status;
+    if (result.success) {
+      status = "success";
+      row.nextRetryAt = void 0;
+      row.error = void 0;
+    } else if (result.dead) {
+      status = "dead";
+      row.error = result.error;
+      row.nextRetryAt = void 0;
+    } else {
+      status = "pending";
+      row.error = result.error;
+      row.nextRetryAt = result.nextRetryAt;
+    }
+    row.status = status;
+  }
+  async list(filter) {
+    const all = Array.from(this.rows.values()).map((r) => ({ ...r }));
+    return _optionalChain([filter, 'optionalAccess', _46 => _46.status]) ? all.filter((r) => r.status === filter.status) : all;
+  }
+};
+
+// src/retention.ts
+var DEFAULTS = {
+  successTtlMs: 7 * 24 * 60 * 60 * 1e3,
+  deadTtlMs: 30 * 24 * 60 * 60 * 1e3,
+  sweepIntervalMs: 60 * 60 * 1e3
+};
+var DeliveryRetentionSweeper = class {
+  constructor(engine, opts = {}) {
+    this.engine = engine;
+    this.running = false;
+    this.objectName = _nullishCoalesce(opts.objectName, () => ( _chunkOW7ESXOKcjs.SYS_WEBHOOK_DELIVERY));
+    this.successTtlMs = _nullishCoalesce(opts.successTtlMs, () => ( DEFAULTS.successTtlMs));
+    this.deadTtlMs = _nullishCoalesce(opts.deadTtlMs, () => ( DEFAULTS.deadTtlMs));
+    this.sweepIntervalMs = _nullishCoalesce(opts.sweepIntervalMs, () => ( DEFAULTS.sweepIntervalMs));
+    this.logger = _nullishCoalesce(opts.logger, () => ( {}));
+  }
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.timer = setInterval(() => {
+      this.sweep().catch(
+        (err) => _optionalChain([this, 'access', _47 => _47.logger, 'access', _48 => _48.warn, 'optionalCall', _49 => _49("[webhook-retention] sweep failed", err)])
+      );
+    }, this.sweepIntervalMs);
+    _optionalChain([this, 'access', _50 => _50.timer, 'access', _51 => _51.unref, 'optionalCall', _52 => _52()]);
+  }
+  stop() {
+    if (!this.running) return;
+    this.running = false;
+    if (this.timer) clearInterval(this.timer);
+    this.timer = void 0;
+  }
+  /** Run one sweep immediately. Returns the number of rows deleted. */
+  async sweep(now = Date.now()) {
+    let successDeleted = 0;
+    let deadDeleted = 0;
+    if (this.successTtlMs > 0) {
+      try {
+        const res = await this.engine.delete(this.objectName, {
+          where: {
+            status: "success",
+            updated_at: { $lt: now - this.successTtlMs }
+          }
+        });
+        successDeleted = _nullishCoalesce(_optionalChain([res, 'optionalAccess', _53 => _53.affected]), () => ( 0));
+      } catch (err) {
+        _optionalChain([this, 'access', _54 => _54.logger, 'access', _55 => _55.warn, 'optionalCall', _56 => _56("[webhook-retention] success sweep failed", err)]);
+      }
+    }
+    if (this.deadTtlMs > 0) {
+      try {
+        const res = await this.engine.delete(this.objectName, {
+          where: {
+            status: "dead",
+            updated_at: { $lt: now - this.deadTtlMs }
+          }
+        });
+        deadDeleted = _nullishCoalesce(_optionalChain([res, 'optionalAccess', _57 => _57.affected]), () => ( 0));
+      } catch (err) {
+        _optionalChain([this, 'access', _58 => _58.logger, 'access', _59 => _59.warn, 'optionalCall', _60 => _60("[webhook-retention] dead sweep failed", err)]);
+      }
+    }
+    if (successDeleted + deadDeleted > 0) {
+      _optionalChain([this, 'access', _61 => _61.logger, 'access', _62 => _62.info, 'optionalCall', _63 => _63("[webhook-retention] sweep complete", {
+        success: successDeleted,
+        dead: deadDeleted
+      })]);
+    }
+    return { success: successDeleted, dead: deadDeleted };
+  }
+};
+
+// src/webhook-outbox-plugin.ts
+var WebhookOutboxPlugin = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.name = "com.objectstack.plugin-webhook-outbox";
+    this.version = "1.1.0";
+    this.type = "standard";
+    this.dependencies = ["com.objectstack.service.cluster"];
+  }
+  async init(ctx) {
+    const cluster = ctx.getService("cluster");
+    if (!cluster) {
+      throw new Error(
+        'WebhookOutboxPlugin: required service "cluster" not found \u2014 register ClusterServicePlugin first'
+      );
+    }
+    const manifest = ctx.getService("manifest");
+    if (manifest && typeof manifest.register === "function") {
+      manifest.register({
+        id: "com.objectstack.plugin-webhook-outbox.schema",
+        namespace: "sys",
+        version: this.version,
+        type: "plugin",
+        scope: "system",
+        name: "Webhook Outbox Schemas",
+        description: "Registers sys_webhook (configuration) and sys_webhook_delivery (durable outbox telemetry).",
+        objects: [_integration.SysWebhook, _chunkOW7ESXOKcjs.SysWebhookDelivery]
+      });
+    } else {
+      _optionalChain([ctx, 'access', _64 => _64.logger, 'access', _65 => _65.warn, 'optionalCall', _66 => _66(
+        "[webhook-outbox] manifest service unavailable \u2014 sys_webhook / sys_webhook_delivery will NOT appear in REST or Studio nav. Register MetadataService before WebhookOutboxPlugin."
+      )]);
+    }
+    const outbox = this.resolveOutbox(ctx);
+    this.outboxInstance = outbox;
+    const nodeId = _nullishCoalesce(_nullishCoalesce(this.options.nodeId, () => ( process.env.OBJECTSTACK_NODE_ID)), () => ( `node-${Math.random().toString(36).slice(2, 10)}`));
+    const dispatcher = new WebhookDispatcher({
+      nodeId,
+      cluster,
+      outbox,
+      partitionCount: this.options.partitionCount,
+      batchSize: this.options.batchSize,
+      intervalMs: this.options.intervalMs,
+      lockTtlMs: this.options.lockTtlMs,
+      claimTtlMs: this.options.claimTtlMs,
+      fetchImpl: this.options.fetchImpl,
+      onAttempt: this.options.onAttempt,
+      rng: this.options.rng,
+      logger: ctx.logger
+    });
+    this.dispatcher = dispatcher;
+    ctx.registerService("webhook.outbox", outbox);
+    ctx.registerService("webhook.dispatcher", dispatcher);
+    if (this.options.autoStart !== false) {
+      dispatcher.start();
+    }
+    const usingMemoryOutbox = outbox instanceof MemoryWebhookOutbox;
+    if (usingMemoryOutbox && process.env.NODE_ENV === "production") {
+      _optionalChain([ctx, 'access', _67 => _67.logger, 'access', _68 => _68.warn, 'optionalCall', _69 => _69(
+        '[webhook-outbox] MemoryWebhookOutbox in production \u2014 webhook deliveries WILL be lost on process exit. Pass `outbox: (ctx) => new SqlWebhookOutbox(ctx.getService("objectql"), { partitionCount: 8 })` from `@objectstack/plugin-webhooks/sql`.'
+      )]);
+    }
+    const autoEnqueueOpt = _nullishCoalesce(this.options.autoEnqueue, () => ( true));
+    const retentionOpt = _nullishCoalesce(this.options.retention, () => ( true));
+    const needsReadyHook = autoEnqueueOpt !== false || retentionOpt !== false;
+    if (needsReadyHook && typeof ctx.hook === "function") {
+      ctx.hook("kernel:ready", async () => {
+        await this.bootAutoEnqueue(ctx, autoEnqueueOpt);
+        this.bootRetention(ctx, retentionOpt);
+      });
+    }
+    _optionalChain([ctx, 'access', _70 => _70.logger, 'access', _71 => _71.info, 'optionalCall', _72 => _72("[webhook-outbox] initialised", {
+      nodeId,
+      partitions: _nullishCoalesce(this.options.partitionCount, () => ( 8)),
+      interval: _nullishCoalesce(this.options.intervalMs, () => ( 250)),
+      autoEnqueue: autoEnqueueOpt !== false,
+      retention: retentionOpt !== false
+    })]);
+  }
+  async dispose() {
+    await _optionalChain([this, 'access', _73 => _73.autoEnqueuer, 'optionalAccess', _74 => _74.stop, 'call', _75 => _75()]);
+    _optionalChain([this, 'access', _76 => _76.retention, 'optionalAccess', _77 => _77.stop, 'call', _78 => _78()]);
+    await _optionalChain([this, 'access', _79 => _79.dispatcher, 'optionalAccess', _80 => _80.stop, 'call', _81 => _81()]);
+  }
+  resolveOutbox(ctx) {
+    const opt = this.options.outbox;
+    if (!opt) return new MemoryWebhookOutbox();
+    if (typeof opt === "function") return opt(ctx);
+    return opt;
+  }
+  async bootAutoEnqueue(ctx, opt) {
+    if (opt === false) return;
+    const engine = this.tryGetService(ctx, ["objectql", "data"]);
+    const realtime = this.tryGetService(ctx, ["realtime"]);
+    if (!engine || !realtime) {
+      _optionalChain([ctx, 'access', _82 => _82.logger, 'access', _83 => _83.warn, 'optionalCall', _84 => _84(
+        "[webhook-auto-enqueuer] disabled \u2014 ObjectQL or Realtime service not available",
+        { hasEngine: !!engine, hasRealtime: !!realtime }
+      )]);
+      return;
+    }
+    if (!this.outboxInstance) return;
+    const enqOpts = typeof opt === "object" ? opt : {};
+    this.autoEnqueuer = new AutoEnqueuer(
+      engine,
+      realtime,
+      this.outboxInstance,
+      { ...enqOpts, logger: ctx.logger }
+    );
+    await this.autoEnqueuer.start();
+    ctx.registerService("webhook.autoEnqueuer", this.autoEnqueuer);
+    _optionalChain([ctx, 'access', _85 => _85.logger, 'access', _86 => _86.info, 'optionalCall', _87 => _87("[webhook-auto-enqueuer] started")]);
+  }
+  bootRetention(ctx, opt) {
+    if (opt === false) return;
+    if (this.outboxInstance instanceof MemoryWebhookOutbox) return;
+    const engine = this.tryGetService(ctx, ["objectql", "data"]);
+    if (!engine) {
+      _optionalChain([ctx, 'access', _88 => _88.logger, 'access', _89 => _89.warn, 'optionalCall', _90 => _90(
+        "[webhook-retention] disabled \u2014 ObjectQL service not available"
+      )]);
+      return;
+    }
+    const retOpts = typeof opt === "object" ? opt : {};
+    this.retention = new DeliveryRetentionSweeper(engine, {
+      ...retOpts,
+      logger: ctx.logger
+    });
+    this.retention.start();
+    ctx.registerService("webhook.retention", this.retention);
+    _optionalChain([ctx, 'access', _91 => _91.logger, 'access', _92 => _92.info, 'optionalCall', _93 => _93("[webhook-retention] sweeper started")]);
+  }
+  tryGetService(ctx, names) {
+    for (const n of names) {
+      try {
+        const svc = ctx.getService(n);
+        if (svc) return svc;
+      } catch (e5) {
+      }
+    }
+    return void 0;
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+exports.AutoEnqueuer = AutoEnqueuer; exports.DEFAULT_TIMEOUT_MS = DEFAULT_TIMEOUT_MS; exports.DeliveryRetentionSweeper = DeliveryRetentionSweeper; exports.MemoryWebhookOutbox = MemoryWebhookOutbox; exports.WebhookDispatcher = WebhookDispatcher; exports.WebhookOutboxPlugin = WebhookOutboxPlugin; exports.classifyAttempt = classifyAttempt; exports.hashPartition = _chunkM4M5FWIHcjs.hashPartition; exports.nextRetryDelayMs = nextRetryDelayMs; exports.sendOnce = sendOnce;
+//# sourceMappingURL=index.cjs.map