@zdavison/matador 4.1.0 → 4.2.0

package/dist/index.cjs

@@ -2005,7 +2005,11 @@ var ProcessingPipeline = class {
    * @returns A `ProcessResult` indicating if we should continue with processing the message, or fail it preemptively
    */
   async handleShouldProcess(envelope, subscriberDef, isResumable, receipt, startTime) {
-    const decision = this.retryPolicy.shouldProcess({ envelope, receipt });
+    const decision = this.retryPolicy.shouldProcess({
+      envelope,
+      subscriber: subscriberDef,
+      receipt
+    });
     if (decision.action === "process") {
       return {
         success: true,
@@ -2147,13 +2151,16 @@ var StandardRetryPolicy = class {
     this.config = { ...defaultRetryConfig, ...config };
   }
   /**
-   * Check if the message should be dead-lettered before the subscriber callback is invoked
+   * Check if the message should be dead-lettered before the subscriber callback is invoked.
+   * This is needed when a subscriber crashes and the `shouldRetry` policy is never executed.
    *
    * Uses the same delivery-count threshold as `shouldRetry` poison check, so an
    * already-poisoned message is dead-lettered without ever running the callback again.
    *
+   * Checks the subscriber idempotency setting to prevent processing when a previous attempt crashed.
+   *
    * @param context - The shouldProcess context.
-   * @returns A 'process' decision if the message is not poisoned; a dead-letter decision otherwise.
+   * @returns A 'process' decision if subscriber processing should be attempted; a dead-letter decision otherwise.
    */
   shouldProcess(context) {
     const poisonError = this.checkPoisoned(context.envelope, context.receipt);
@@ -2164,6 +2171,18 @@ var StandardRetryPolicy = class {
         reason: poisonError.message
       };
     }
+    const idempotencyError = this.checkIdempotency(
+      context.envelope,
+      context.receipt,
+      context.subscriber
+    );
+    if (idempotencyError) {
+      return {
+        action: "dead-letter",
+        queue: "undeliverable",
+        reason: idempotencyError.message
+      };
+    }
     return { action: "process" };
   }
   shouldRetry(context) {
@@ -2211,15 +2230,17 @@ var StandardRetryPolicy = class {
         reason: `max attempts exceeded (${this.config.maxAttempts})`
       };
     }
-    if (receipt.redelivered && (subscriber.idempotent === "no" || subscriber.idempotent === "unknown")) {
-      const idempotentError = new IdempotentMessageCannotRetryError(
-        envelope.id,
-        subscriber.name
-      );
+    const idempotencyError = this.checkIdempotency(
+      envelope,
+      receipt,
+      subscriber,
+      error
+    );
+    if (idempotencyError) {
       return {
         action: "dead-letter",
         queue: "undeliverable",
-        reason: idempotentError.message
+        reason: idempotencyError.message
       };
     }
     return {
@@ -2249,6 +2270,24 @@ var StandardRetryPolicy = class {
     }
     return null;
   }
+  /**
+   * Checks whether the subscriber allows retries based on its idempotency setting
+   *
+   * @param envelope - The message envelope.
+   * @param receipt - The message receipt.
+   * @param subscriber - The subscriber definition
+   * @param error - The processing error, if it exists
+   * @returns A IdempotentMessageCannotRetryError if the message is poisoned; null otherwise
+   */
+  checkIdempotency(envelope, receipt, subscriber, error) {
+    if ((error || receipt.redelivered) && (subscriber.idempotent === "no" || subscriber.idempotent === "unknown")) {
+      return new IdempotentMessageCannotRetryError(
+        envelope.id,
+        subscriber.name
+      );
+    }
+    return null;
+  }
 };
 
 // src/schema/types.ts