@vytches/ddd-messaging 0.29.3 → 0.31.0-alpha.0

package/dist/index.js

@@ -1,7 +1,59 @@
-import { Logger as u } from "@vytches/ddd-logging";
-import { LibUtils as p, safeRun as d } from "@vytches/ddd-utils";
-var n = /* @__PURE__ */ ((i) => (i.PENDING = "PENDING", i.PROCESSING = "PROCESSING", i.PROCESSED = "PROCESSED", i.FAILED = "FAILED", i))(n || {}), g = /* @__PURE__ */ ((i) => (i.LOW = "low", i.NORMAL = "normal", i.HIGH = "high", i.CRITICAL = "critical", i))(g || {});
-class m {
+import { LibUtils as y, safeRun as g } from "@vytches/ddd-utils";
+import { internalLogger as c } from "@vytches/ddd-contracts/internal";
+var n = /* @__PURE__ */ ((i) => (i.PENDING = "PENDING", i.PROCESSING = "PROCESSING", i.PROCESSED = "PROCESSED", i.FAILED = "FAILED", i))(n || {}), l = /* @__PURE__ */ ((i) => (i.LOW = "low", i.NORMAL = "normal", i.HIGH = "high", i.CRITICAL = "critical", i))(l || {});
+const f = [
+  "critical",
+  "high",
+  "normal",
+  "low"
+  /* LOW */
+];
+function R(i, e, t = f) {
+  const s = t.includes(i) ? t.indexOf(i) : t.length, a = t.includes(e) ? t.indexOf(e) : t.length;
+  return s - a;
+}
+class w {
+  /**
+   * Atomically claims a batch of unprocessed messages: reads PENDING
+   * messages *and* marks them `PROCESSING` in the same operation, so two
+   * concurrent callers (two processor instances, or two racing calls on one
+   * instance) never both receive the same message.
+   *
+   * **Optional, and non-atomic by default.** This method is declared with
+   * `?` — it is NOT part of the required abstract contract, so existing
+   * `IOutboxRepository` subclasses keep compiling unmodified (AC#5). The
+   * default implementation provided here is a convenience shim only: it
+   * calls {@link getUnprocessedMessages} and then `updateStatusBatch(...,
+   * PROCESSING)` as two separate steps. **That is NOT atomic** — it has the
+   * exact same read-then-mark race window as calling
+   * `getUnprocessedMessages` + `updateStatus` manually, and is safe only for
+   * a single-worker deployment. Override `claimBatch` in a concrete
+   * repository (e.g. backed by `SELECT ... FOR UPDATE SKIP LOCKED`, or a
+   * single atomic `UPDATE ... WHERE status='PENDING' LIMIT n RETURNING *`)
+   * to get real multi-worker/multi-processor safety.
+   *
+   * `OutboxProcessor` only calls this method when
+   * `OutboxProcessorOptions.useClaimBatch` is explicitly set to `true`
+   * (opt-in, default `false`) — see AC#1/AC#2. When enabled, the processor
+   * skips its own redundant `updateStatus(id, PROCESSING)` call for messages
+   * returned by `claimBatch`, since claiming already performed that mark.
+   *
+   * Handlers should be idempotent to side effects regardless — transient
+   * failures or duplicate-claim races (e.g. with the non-atomic default
+   * implementation) may still cause a handler to run more than once.
+   *
+   * @param limit - Maximum number of messages to claim.
+   * @param priorityOrder - See {@link getUnprocessedMessages}.
+   * @param messageTypes - See {@link getUnprocessedMessages}.
+   * @returns Messages that were claimed (already marked `PROCESSING`).
+   */
+  async claimBatch(e, t, s) {
+    const a = await this.getUnprocessedMessages(e, t, s);
+    return a.length === 0 ? a : (await this.updateStatusBatch(
+      a.map((r) => r.id),
+      n.PROCESSING
+    ), a.map((r) => ({ ...r, status: n.PROCESSING })));
+  }
   /**
    * Schedules a retry for a failed message at a specific future time.
    *
@@ -43,7 +95,7 @@ class m {
     return Promise.resolve(0);
   }
 }
-class h {
+class d {
   /**
    * Creates a new outbox message
    * @param messageType Type of the message
@@ -52,17 +104,17 @@ class h {
    * @returns Outbox message
    */
   static createMessage(e, t, s) {
-    const r = {
-      id: p.getUUID(),
+    const a = {
+      id: y.getUUID(),
       messageType: e,
       payload: t,
       metadata: s?.metadata || {},
       status: n.PENDING,
       attempts: 0,
       createdAt: /* @__PURE__ */ new Date(),
-      priority: s?.priority || g.NORMAL
+      priority: s?.priority || l.NORMAL
     };
-    return s?.processAfter && (r.processAfter = s.processAfter), r;
+    return s?.processAfter && (a.processAfter = s.processAfter), a;
   }
   /**
    * Creates a delayed outbox message
@@ -72,11 +124,11 @@ class h {
    * @param options Additional options
    * @returns Outbox message scheduled for later processing
    */
-  static createDelayedMessage(e, t, s, r) {
-    const a = new Date(Date.now() + s);
-    return h.createMessage(e, t, {
-      ...r,
-      processAfter: a
+  static createDelayedMessage(e, t, s, a) {
+    const r = new Date(Date.now() + s);
+    return d.createMessage(e, t, {
+      ...a,
+      processAfter: r
     });
   }
   /**
@@ -87,9 +139,9 @@ class h {
    * @returns High priority outbox message
    */
   static createHighPriorityMessage(e, t, s) {
-    return h.createMessage(e, t, {
+    return d.createMessage(e, t, {
       ...s,
-      priority: g.HIGH
+      priority: l.HIGH
     });
   }
   /**
@@ -105,52 +157,53 @@ class h {
         ...t?.metadata || {}
       }
     };
-    return t?.priority && (s.priority = t.priority), t?.processAfter && (s.processAfter = t.processAfter), h.createMessage(
+    return t?.priority && (s.priority = t.priority), t?.processAfter && (s.processAfter = t.processAfter), d.createMessage(
       `integration_event:${e.eventName}`,
       e.payload,
       s
     );
   }
 }
-class v {
+class P {
   constructor(e, t = {}) {
-    this.handlers = /* @__PURE__ */ new Map(), this.middlewares = [], this.isRunning = !1, this.logger = u.create("OutboxProcessor");
+    this.handlers = /* @__PURE__ */ new Map(), this.middlewares = [], this.isRunning = !1, this.warnedMissingClaimBatch = !1;
     const s = t.batchSize ?? 10;
     if (s > 1e4)
       throw new RangeError(`OutboxProcessor: batchSize must be ≤ 10,000, got ${s}`);
     if (t.retryBackoff) {
-      const { initial: o, multiplier: l, maxDelay: c } = t.retryBackoff;
-      if (o <= 0 || l <= 0 || c <= 0)
+      const { initial: o, multiplier: h, maxDelay: u } = t.retryBackoff;
+      if (o <= 0 || h <= 0 || u <= 0)
         throw new RangeError(
-          `OutboxProcessor: retryBackoff fields must be positive numbers (initial=${o}, multiplier=${l}, maxDelay=${c})`
+          `OutboxProcessor: retryBackoff fields must be positive numbers (initial=${o}, multiplier=${h}, maxDelay=${u})`
         );
     }
-    const r = t.messageTimeout ?? 3e4, a = t.crashRecoveryThresholdMs ?? Math.max(3e5, r);
-    if (a < r)
+    const a = t.messageTimeout ?? 3e4, r = t.crashRecoveryThresholdMs ?? Math.max(3e5, a);
+    if (r < a)
       throw new RangeError(
-        `OutboxProcessor: crashRecoveryThresholdMs (${a}) must be ≥ messageTimeout (${r}) to avoid resetting in-flight messages`
+        `OutboxProcessor: crashRecoveryThresholdMs (${r}) must be ≥ messageTimeout (${a}) to avoid resetting in-flight messages`
       );
     this.repository = e, this.options = {
       batchSize: s,
       maxRetries: t.maxRetries ?? 3,
       processingInterval: t.processingInterval ?? 5e3,
       priorityOrder: t.priorityOrder ?? [
-        g.CRITICAL,
-        g.HIGH,
-        g.NORMAL,
-        g.LOW
+        l.CRITICAL,
+        l.HIGH,
+        l.NORMAL,
+        l.LOW
       ],
-      messageTimeout: r,
+      messageTimeout: a,
       enableLogging: t.enableLogging ?? !1,
       retryBackoff: t.retryBackoff,
       messageTypes: t.messageTypes,
       crashRecoveryIntervalMs: t.crashRecoveryIntervalMs,
-      crashRecoveryThresholdMs: a,
+      crashRecoveryThresholdMs: r,
       adaptiveRepoll: t.adaptiveRepoll ?? !1,
       adaptiveRepollMaxConsecutive: t.adaptiveRepollMaxConsecutive ?? 5,
       adaptiveRepollPauseMs: t.adaptiveRepollPauseMs ?? 50,
       startupJitterMs: t.startupJitterMs ?? 0,
-      hooks: t.hooks
+      hooks: t.hooks,
+      useClaimBatch: t.useClaimBatch ?? !1
     };
   }
   /**
@@ -162,31 +215,54 @@ class v {
       try {
         t();
       } catch (s) {
-        const r = s instanceof Error ? s.message : String(s);
-        this.logger.error(`Outbox hook ${e} threw and was ignored: ${r}`);
+        c.error(
+          `OutboxProcessor: hook ${e} threw and was ignored`,
+          s instanceof Error ? s : void 0,
+          { hookName: e }
+        );
       }
   }
   /**
    * Registers a message handler for a specific message type
    */
   registerHandler(e, t) {
-    this.handlers.set(e, t), this.logger.debug(`Registered handler for message type: ${e}`);
+    this.handlers.set(e, t);
+  }
+  /**
+   * Registers a catch-all handler invoked when no type-specific handler matches.
+   *
+   * NOTE: Registering a default handler removes the implicit type allowlist —
+   * all future message types, including ones added by mistake or injected via
+   * compromised storage, will be dispatched to this handler. Validate
+   * `message.messageType` inside the handler against a known-types set if your
+   * domain requires an explicit allowlist.
+   *
+   * NOTE: When `messageTypes` filter option is set, the default handler handles
+   * only types that pass through that filter. To handle all types, leave
+   * `messageTypes` unset.
+   *
+   * Second/subsequent call emits a warning and replaces the previous handler.
+   */
+  registerDefaultHandler(e) {
+    this.defaultHandler && c.warn(
+      "registerDefaultHandler: replacing existing default handler — previous handler discarded"
+    ), this.defaultHandler = e;
   }
   /**
    * Registers middleware for message processing pipeline
    */
   use(e) {
-    this.middlewares.push(e), this.logger.debug("Registered middleware");
+    this.middlewares.push(e);
   }
   /**
    * Starts the processor with automatic interval processing
    */
   start() {
     if (this.isRunning) {
-      this.logger.warn("Processor is already running");
+      c.warn("OutboxProcessor: processor is already running");
       return;
     }
-    this.isRunning = !0, this.logger.info("Starting outbox processor");
+    this.isRunning = !0;
     const e = this.options.startupJitterMs > 0 ? Math.floor(Math.random() * this.options.startupJitterMs) : 0;
     this.scheduleProcessing(0, this.options.processingInterval + e), this.scheduleCrashRecovery();
   }
@@ -195,10 +271,10 @@ class v {
    */
   stop() {
     if (!this.isRunning) {
-      this.logger.warn("Processor is not running");
+      c.warn("OutboxProcessor: processor is not running");
       return;
     }
-    this.isRunning = !1, this.processingTimer && (clearTimeout(this.processingTimer), this.processingTimer = void 0), this.crashRecoveryTimer && (clearTimeout(this.crashRecoveryTimer), this.crashRecoveryTimer = void 0), this.logger.info("Stopped outbox processor");
+    this.isRunning = !1, this.processingTimer && (clearTimeout(this.processingTimer), this.processingTimer = void 0), this.crashRecoveryTimer && (clearTimeout(this.crashRecoveryTimer), this.crashRecoveryTimer = void 0);
   }
   /**
    * Processes a single batch of pending messages.
@@ -233,65 +309,82 @@ class v {
     const e = this.options.batchSize;
     if (!this.isRunning)
       return { processed: 0, batchSize: e };
-    const [t, s] = await d(
-      () => this.repository.getUnprocessedMessages(
+    const t = this.repository.claimBatch, s = this.options.useClaimBatch === !0 && typeof t == "function";
+    this.options.useClaimBatch && !s && !this.warnedMissingClaimBatch && (this.warnedMissingClaimBatch = !0, c.warn(
+      "OutboxProcessor: useClaimBatch is enabled but the repository does not implement claimBatch() — falling back to getUnprocessedMessages (no atomic-claim protection)"
+    ));
+    const [a, r] = await g(
+      () => s && t ? t.call(
+        this.repository,
+        e,
+        this.options.priorityOrder,
+        this.options.messageTypes
+      ) : this.repository.getUnprocessedMessages(
         e,
         this.options.priorityOrder,
         this.options.messageTypes
       )
     );
-    if (t) {
-      const c = t instanceof Error ? t.message : String(t);
-      return this.logger.error(`Error retrieving messages: ${c}`), { processed: 0, batchSize: e };
-    }
-    const r = s;
-    if (!r || !Array.isArray(r) || r.length === 0)
-      return this.logger.debug("No pending messages to process"), { processed: 0, batchSize: e };
-    this.logger.info(`Processing ${r.length} messages`);
-    const a = Date.now(), l = (await Promise.allSettled(
-      r.map((c) => this.processMessage(c))
+    if (a)
+      return c.error(
+        "OutboxProcessor: error retrieving messages",
+        a instanceof Error ? a : void 0
+      ), { processed: 0, batchSize: e };
+    const o = r;
+    if (!o || !Array.isArray(o) || o.length === 0)
+      return { processed: 0, batchSize: e };
+    const h = Date.now(), m = (await Promise.allSettled(
+      o.map((p) => this.processMessage(p, s))
     )).filter(
-      (c) => c.status === "rejected" || c.status === "fulfilled" && c.value === !1
+      (p) => p.status === "rejected" || p.status === "fulfilled" && p.value === !1
     ).length;
-    return this.logger.info(`Completed processing batch of ${r.length} messages`), this.safelyInvokeHook(
+    return this.safelyInvokeHook(
       "onBatchComplete",
       () => this.options.hooks?.onBatchComplete?.({
-        processed: r.length,
-        failed: l,
+        processed: o.length,
+        failed: m,
         batchSize: e,
-        durationMs: Date.now() - a
+        durationMs: Date.now() - h
       })
-    ), { processed: r.length, batchSize: e };
+    ), { processed: o.length, batchSize: e };
   }
   /**
    * Processes a single message through the middleware pipeline.
+   * @param alreadyClaimed When `true`, the message was already marked
+   *   `PROCESSING` by `IOutboxRepository.claimBatch()` — the redundant
+   *   `updateStatus(id, PROCESSING)` call is skipped.
    * @returns `true` if the message was processed successfully, `false` if it failed.
    */
-  async processMessage(e) {
-    const [t] = await d(async () => {
-      await this.repository.updateStatus(e.id, n.PROCESSING), await this.buildPipeline(e)(e), await this.repository.updateStatus(e.id, n.PROCESSED), this.logger.debug(`Successfully processed message ${e.id}`);
+  async processMessage(e, t = !1) {
+    const [s] = await g(async () => {
+      t || await this.repository.updateStatus(e.id, n.PROCESSING), await this.buildPipeline(e)(e), await this.repository.updateStatus(e.id, n.PROCESSED);
     });
-    return t ? (await this.handleMessageError(e, t), !1) : !0;
+    return s ? (await this.handleMessageError(e, s), !1) : !0;
   }
   /**
    * Builds the middleware pipeline for message processing
    */
   buildPipeline(e) {
-    const t = this.handlers.get(e.messageType);
+    const t = this.handlers.get(e.messageType) ?? this.defaultHandler;
     if (!t)
       throw new Error(`No handler registered for message type: ${e.messageType}`);
-    const s = async (r) => {
-      await Promise.race([
-        t.handle(r),
-        new Promise(
-          (a, o) => setTimeout(
-            () => o(new Error("Message processing timeout")),
-            this.options.messageTimeout
-          )
-        )
-      ]);
+    const s = async (a) => {
+      let r;
+      try {
+        await Promise.race([
+          t.handle(a),
+          new Promise((o, h) => {
+            r = setTimeout(
+              () => h(new Error("Message processing timeout")),
+              this.options.messageTimeout
+            );
+          })
+        ]);
+      } finally {
+        r !== void 0 && clearTimeout(r);
+      }
     };
-    return this.middlewares.reduceRight((r, a) => a(r), s);
+    return this.middlewares.reduceRight((a, r) => r(a), s);
   }
   /**
    * Handles errors during message processing
@@ -299,24 +392,30 @@ class v {
   async handleMessageError(e, t) {
     try {
       const s = await this.repository.incrementAttempt(e.id);
-      if (this.logger.warn(`Message ${e.id} failed, attempt ${s}: ${t?.message}`), this.safelyInvokeHook(
+      if (c.warn(
+        `OutboxProcessor: message ${e.id} failed, attempt ${s}: ${y.sanitizeLogMessage(t?.message ?? String(t))}`
+      ), this.safelyInvokeHook(
         "onMessageFailed",
         () => this.options.hooks?.onMessageFailed?.(e, t, s)
       ), s >= this.options.maxRetries)
-        await this.repository.updateStatus(e.id, n.FAILED, t), this.logger.error(`Message ${e.id} marked as failed after ${s} attempts`), this.safelyInvokeHook(
+        await this.repository.updateStatus(e.id, n.FAILED, t), c.error("OutboxProcessor: message permanently failed", t, {
+          messageId: e.id,
+          attempts: s
+        }), this.safelyInvokeHook(
           "onPermanentFailure",
           () => this.options.hooks?.onPermanentFailure?.(e, t)
         );
       else if (this.options.retryBackoff) {
-        const { initial: r, multiplier: a, maxDelay: o } = this.options.retryBackoff, l = Math.min(r * Math.pow(a, s - 1), o), c = new Date(Date.now() + l);
-        await this.repository.updateStatus(e.id, n.PENDING), await this.repository.scheduleRetry(e.id, c), this.logger.info(
-          `Message ${e.id} scheduled for retry in ${l}ms (attempt ${s})`
-        );
+        const { initial: a, multiplier: r, maxDelay: o } = this.options.retryBackoff, h = Math.min(a * Math.pow(r, s - 1), o), u = new Date(Date.now() + h);
+        await this.repository.updateStatus(e.id, n.PENDING), await this.repository.scheduleRetry(e.id, u);
       } else
-        await this.repository.updateStatus(e.id, n.PENDING), this.logger.info(`Message ${e.id} scheduled for retry (attempt ${s + 1})`);
+        await this.repository.updateStatus(e.id, n.PENDING);
     } catch (s) {
-      const r = s instanceof Error ? s.message : String(s);
-      this.logger.error(`Error updating message status: ${r}`);
+      c.error(
+        "OutboxProcessor: error updating message status",
+        s instanceof Error ? s : void 0,
+        { messageId: e.id }
+      );
     }
   }
   /**
@@ -335,8 +434,8 @@ class v {
     this.isRunning && (this.processingTimer = setTimeout(async () => {
       const s = await this.processBatch();
       if (this.options.adaptiveRepoll && s.processed > 0 && s.processed >= s.batchSize) {
-        const a = e + 1, o = a > this.options.adaptiveRepollMaxConsecutive ? this.options.adaptiveRepollPauseMs : 0;
-        this.scheduleProcessing(a, o);
+        const r = e + 1, o = r > this.options.adaptiveRepollMaxConsecutive ? this.options.adaptiveRepollPauseMs : 0;
+        this.scheduleProcessing(r, o);
       } else
         this.scheduleProcessing(0, this.options.processingInterval);
     }, t));
@@ -356,19 +455,17 @@ class v {
    * logged, never thrown — crash recovery must not crash the processor.
    */
   async runCrashRecovery() {
-    const e = new Date(Date.now() - this.options.crashRecoveryThresholdMs), [t, s] = await d(() => this.repository.resetStaleProcessing(e));
+    const e = new Date(Date.now() - this.options.crashRecoveryThresholdMs), [t, s] = await g(() => this.repository.resetStaleProcessing(e));
     if (t) {
-      const r = t instanceof Error ? t.message : String(t);
-      this.logger.error(`Crash recovery failed: ${r}`);
+      c.error(
+        "OutboxProcessor: crash recovery failed",
+        t instanceof Error ? t : void 0
+      );
       return;
     }
-    s && s > 0 && this.logger.warn(`Crash recovery reset ${s} stale PROCESSING message(s) to PENDING`);
-  }
-  /**
-   * Logs messages if logging is enabled
-   */
-  log(e) {
-    this.options.enableLogging && this.logger.info(e);
+    s && s > 0 && c.warn(
+      `OutboxProcessor: crash recovery reset ${s} stale PROCESSING message(s) to PENDING`
+    );
   }
   /**
    * Gets processor statistics
@@ -380,11 +477,12 @@ class v {
       maxRetries: this.options.maxRetries,
       processingInterval: this.options.processingInterval,
       registeredHandlers: Array.from(this.handlers.keys()),
-      middlewareCount: this.middlewares.length
+      middlewareCount: this.middlewares.length,
+      hasDefaultHandler: this.defaultHandler !== void 0
     };
   }
 }
-class M {
+class I {
   constructor(e) {
     this.eventBus = e;
   }
@@ -400,10 +498,10 @@ class M {
     await this.eventBus.publish(s);
   }
 }
-class R {
+class S {
   constructor(e, t = {}) {
-    this.logger = u.create("OutboxService"), this.repository = e, this.options = {
-      defaultPriority: t.defaultPriority ?? g.NORMAL,
+    this.repository = e, this.options = {
+      defaultPriority: t.defaultPriority ?? l.NORMAL,
       defaultMetadata: t.defaultMetadata ?? {},
       autoCleanup: t.autoCleanup ?? !1,
       cleanupAfterDays: t.cleanupAfterDays ?? 7,
@@ -414,38 +512,36 @@ class R {
    * Saves a message to the outbox
    */
   async saveMessage(e, t, s) {
-    const r = h.createMessage(e, t, {
+    const a = d.createMessage(e, t, {
       priority: this.options.defaultPriority,
       metadata: { ...this.options.defaultMetadata, ...s?.metadata },
       ...s
-    }), a = await this.repository.saveMessage(r);
-    return this.logger.debug(`Saved message ${a} of type ${e}`), a;
+    });
+    return await this.repository.saveMessage(a);
   }
   /**
    * Saves multiple messages to the outbox in a batch
    */
   async saveMessages(e) {
     const t = e.map(
-      ({ messageType: r, payload: a, options: o }) => h.createMessage(r, a, {
+      ({ messageType: a, payload: r, options: o }) => d.createMessage(a, r, {
         priority: this.options.defaultPriority,
         metadata: { ...this.options.defaultMetadata, ...o?.metadata },
         ...o
       })
-    ), s = await this.repository.saveBatch(t);
-    return this.logger.debug(`Saved batch of ${e.length} messages`), s;
+    );
+    return await this.repository.saveBatch(t);
   }
   /**
    * Schedules a message for delayed processing
    */
-  async scheduleMessage(e, t, s, r) {
-    const a = h.createDelayedMessage(e, t, s, {
+  async scheduleMessage(e, t, s, a) {
+    const r = d.createDelayedMessage(e, t, s, {
       priority: this.options.defaultPriority,
-      metadata: { ...this.options.defaultMetadata, ...r?.metadata },
-      ...r
-    }), o = await this.repository.scheduleMessage(a, a.processAfter);
-    return this.logger.debug(
-      `Scheduled message ${o} of type ${e} for processing in ${s}ms`
-    ), o;
+      metadata: { ...this.options.defaultMetadata, ...a?.metadata },
+      ...a
+    });
+    return await this.repository.scheduleMessage(r, r.processAfter);
   }
   /**
    * Saves a high priority message to the outbox
@@ -453,7 +549,7 @@ class R {
   async saveHighPriorityMessage(e, t, s) {
     return this.saveMessage(e, t, {
       ...s,
-      priority: g.HIGH
+      priority: l.HIGH
     });
   }
   /**
@@ -462,14 +558,14 @@ class R {
   async saveCriticalMessage(e, t, s) {
     return this.saveMessage(e, t, {
       ...s,
-      priority: g.CRITICAL
+      priority: l.CRITICAL
     });
   }
   /**
    * Converts a domain event to an outbox message and saves it
    */
   async saveDomainEvent(e, t) {
-    const s = h.createFromIntegrationEvent(
+    const s = d.createFromIntegrationEvent(
       {
         eventName: e.eventName,
         payload: e,
@@ -484,8 +580,8 @@ class R {
         metadata: { ...this.options.defaultMetadata, ...t?.metadata },
         ...t
       }
-    ), r = await this.repository.saveMessage(s);
-    return this.logger.debug(`Saved domain event ${e.eventName} as message ${r}`), r;
+    );
+    return await this.repository.saveMessage(s);
   }
   /**
    * Gets a message by ID
@@ -503,25 +599,23 @@ class R {
    * Retries a failed message by resetting it to pending status
    */
   async retryMessage(e) {
-    await this.repository.updateStatus(e, n.PENDING), this.logger.info(`Reset message ${e} to pending for retry`);
+    await this.repository.updateStatus(e, n.PENDING);
   }
   /**
    * Retries multiple failed messages
    */
   async retryMessages(e) {
-    await this.repository.updateStatusBatch(e, n.PENDING), this.logger.info(`Reset ${e.length} messages to pending for retry`);
+    await this.repository.updateStatusBatch(e, n.PENDING);
   }
   /**
    * Cleans up old processed messages
    */
   async cleanup(e) {
     const t = e ?? this.options.cleanupAfterDays, s = /* @__PURE__ */ new Date();
-    s.setDate(s.getDate() - t);
-    const r = await this.repository.deleteByStatusAndAge(
+    return s.setDate(s.getDate() - t), await this.repository.deleteByStatusAndAge(
       s,
       n.PROCESSED
     );
-    return this.logger.info(`Cleaned up ${r} processed messages older than ${t} days`), r;
   }
   /**
    * Gets outbox statistics
@@ -543,19 +637,14 @@ class R {
       // Would need separate query
     };
   }
-  /**
-   * Logs messages if logging is enabled
-   */
-  log(e) {
-    this.options.enableLogging && this.logger.info(e);
-  }
 }
 export {
-  M as EventBusOutboxHandler,
-  m as IOutboxRepository,
-  g as MessagePriority,
+  I as EventBusOutboxHandler,
+  w as IOutboxRepository,
+  l as MessagePriority,
   n as MessageStatus,
-  h as OutboxMessageFactory,
-  v as OutboxProcessor,
-  R as OutboxService
+  d as OutboxMessageFactory,
+  P as OutboxProcessor,
+  S as OutboxService,
+  R as comparePriority
 };

package/dist/outbox/outbox-interfaces.d.ts

@@ -48,3 +48,22 @@ export interface IOutboxMessageHandler<T = unknown> {
     handle(message: IOutboxMessage<T>): Promise<void>;
 }
 export type OutboxMiddleware = (next: (message: IOutboxMessage) => Promise<void>) => (message: IOutboxMessage) => Promise<void>;
+/**
+ * Compares two MessagePriority values for sorting purposes.
+ *
+ * Returns a negative number if `a` should be processed before `b`,
+ * positive if `b` before `a`, 0 if equal.
+ *
+ * @param order - Processing order array (first element = highest priority).
+ *   Defaults to [CRITICAL, HIGH, NORMAL, LOW].
+ *   Values absent from the array sort LAST (treated as lowest priority).
+ *   Passing a partial array is safe — missing values are not promoted.
+ *
+ * @example
+ * // Sort messages by priority (highest first):
+ * messages.sort((a, b) => comparePriority(a.priority, b.priority));
+ *
+ * // Custom order:
+ * messages.sort((a, b) => comparePriority(a.priority, b.priority, ['high', 'critical', 'normal', 'low']));
+ */
+export declare function comparePriority(a: MessagePriority, b: MessagePriority, order?: MessagePriority[]): number;