@zdavison/matador 4.1.0 → 4.2.0

package/dist/pipeline/pipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/pipeline/pipeline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE1E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAM/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,KAAK,EAEV,UAAU,EACV,QAAQ,EAER,oBAAoB,EACrB,MAAM,mBAAmB,CAAC;AAG3B;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,0DAA0D;IAC1D,QAAQ,CAAC,eAAe,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC;IACvD,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IACzC,QAAQ,CAAC,UAAU,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAC;IACvD,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;IACnC,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC9C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;GAUG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAC9B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;IAC1C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;IAClC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;IAClD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;gBAE5B,MAAM,EAAE,cAAc;IAUlC;;OAEG;IACG,OAAO,CACX,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,aAAa,CAAC;IAoNzB;;;;;;;;;;;OAWG;YACW,mBAAmB;IAiCjC;;;;;;;;;;;OAWG;YACW,aAAa;YA4Cb,mBAAmB;YAqCnB,gBAAgB;IAkB9B;;;OAGG;IACH,OAAO,CAAC,yBAAyB;CA+BlC"}
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/pipeline/pipeline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE1E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAM/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,KAAK,EAEV,UAAU,EACV,QAAQ,EAER,oBAAoB,EACrB,MAAM,mBAAmB,CAAC;AAG3B;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,0DAA0D;IAC1D,QAAQ,CAAC,eAAe,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC;IACvD,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IACzC,QAAQ,CAAC,UAAU,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAC;IACvD,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;IACnC,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC9C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;GAUG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAC9B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;IAC1C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;IAClC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;IAClD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;gBAE5B,MAAM,EAAE,cAAc;IAUlC;;OAEG;IACG,OAAO,CACX,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,aAAa,CAAC;IAoNzB;;;;;;;;;;;OAWG;YACW,mBAAmB;IAqCjC;;;;;;;;;;;OAWG;YACW,aAAa;YA4Cb,mBAAmB;YAqCnB,gBAAgB;IAkB9B;;;OAGG;IACH,OAAO,CAAC,yBAAyB;CA+BlC"}

package/dist/pipeline/pipeline.js

@@ -204,7 +204,11 @@ export class ProcessingPipeline {
      * @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 shouldProcess passes, we can proceed with normal processing
         if (decision.action === 'process') {
             return {

package/dist/retry/policy.d.ts

@@ -42,6 +42,8 @@ export type ProcessDecision = {
 export interface ProcessContext {
     /** The message envelope */
     readonly envelope: Envelope;
+    /** The subscriber definition */
+    readonly subscriber: SubscriberDefinition;
     /** Message receipt with delivery information */
     readonly receipt: MessageReceipt;
 }

package/dist/retry/policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../src/retry/policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,2BAA2B;IAC3B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAE5B,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IAEtB,gCAAgC;IAChC,QAAQ,CAAC,UAAU,EAAE,oBAAoB,CAAC;IAE1C,gDAAgD;IAChD,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACpD;IACE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,GACD;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5D;;GAEG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB,OAAO,CAAC,aAAa,EAAE;IAAE,MAAM,EAAE,aAAa,GAAG,SAAS,CAAA;CAAE,CAAC,CAAC;AAElE;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,2BAA2B;IAC3B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAE5B,gDAAgD;IAChD,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,eAAe,CAAC;IAExD;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,aAAa,CAAC;IAElD;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAAC;CACzC"}
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../src/retry/policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,2BAA2B;IAC3B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAE5B,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IAEtB,gCAAgC;IAChC,QAAQ,CAAC,UAAU,EAAE,oBAAoB,CAAC;IAE1C,gDAAgD;IAChD,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACpD;IACE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,GACD;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5D;;GAEG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB,OAAO,CAAC,aAAa,EAAE;IAAE,MAAM,EAAE,aAAa,GAAG,SAAS,CAAA;CAAE,CAAC,CAAC;AAElE;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,2BAA2B;IAC3B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAE5B,gCAAgC;IAChC,QAAQ,CAAC,UAAU,EAAE,oBAAoB,CAAC;IAE1C,gDAAgD;IAChD,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,eAAe,CAAC;IAExD;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,aAAa,CAAC;IAElD;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAAC;CACzC"}

package/dist/retry/standard-policy.d.ts

@@ -32,20 +32,23 @@ export declare const defaultRetryConfig: StandardRetryPolicyConfig;
  * 3. DontRetry → dead-letter (explicit no-retry)
  * 4. DoRetry → retry if under max attempts
  * 5. Max attempts exceeded → dead-letter
- * 6. Non-idempotent subscriber on redelivery → dead-letter
+ * 6. Non-idempotent subscriber → dead-letter
  * 7. Default → retry with exponential backoff
  */
 export declare class StandardRetryPolicy implements RetryPolicy {
     private readonly config;
     constructor(config?: Partial<StandardRetryPolicyConfig>);
     /**
-     * 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: ProcessContext): ProcessDecision;
     shouldRetry(context: RetryContext): RetryDecision;
@@ -58,5 +61,15 @@ export declare class StandardRetryPolicy implements RetryPolicy {
      * @returns A MessageMaybePoisonedError if the message is poisoned; null otherwise
      */
     private checkPoisoned;
+    /**
+     * 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
+     */
+    private checkIdempotency;
 }
 //# sourceMappingURL=standard-policy.d.ts.map

package/dist/retry/standard-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"standard-policy.d.ts","sourceRoot":"","sources":["../../src/retry/standard-policy.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,YAAY,EACZ,aAAa,EACb,WAAW,EACZ,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,uDAAuD;IACvD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAE7B,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,yCAAyC;IACzC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IAEnC;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,yBAMhC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IACrD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4B;gBAEvC,MAAM,GAAE,OAAO,CAAC,yBAAyB,CAAM;IAI3D;;;;;;;;OAQG;IACH,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,eAAe;IAiBvD,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,aAAa;IAkFjD,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM;IAOvC;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;CAatB"}
+{"version":3,"file":"standard-policy.d.ts","sourceRoot":"","sources":["../../src/retry/standard-policy.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,YAAY,EACZ,aAAa,EACb,WAAW,EACZ,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,uDAAuD;IACvD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAE7B,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,yCAAyC;IACzC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IAEnC;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,yBAMhC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IACrD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4B;gBAEvC,MAAM,GAAE,OAAO,CAAC,yBAAyB,CAAM;IAI3D;;;;;;;;;;;OAWG;IACH,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,eAAe;IAgCvD,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,aAAa;IAiFjD,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM;IAOvC;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAcrB;;;;;;;;OAQG;IACH,OAAO,CAAC,gBAAgB;CAkBzB"}

package/dist/retry/standard-policy.js

@@ -18,7 +18,7 @@ export const defaultRetryConfig = {
  * 3. DontRetry → dead-letter (explicit no-retry)
  * 4. DoRetry → retry if under max attempts
  * 5. Max attempts exceeded → dead-letter
- * 6. Non-idempotent subscriber on redelivery → dead-letter
+ * 6. Non-idempotent subscriber → dead-letter
  * 7. Default → retry with exponential backoff
  */
 export class StandardRetryPolicy {
@@ -27,13 +27,16 @@ export class StandardRetryPolicy {
         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) {
         // Poison message detection - prevent crash loops
@@ -46,6 +49,15 @@ export class StandardRetryPolicy {
                 reason: poisonError.message,
             };
         }
+        // Non-idempotent subscriber on redelivery
+        const idempotencyError = this.checkIdempotency(context.envelope, context.receipt, context.subscriber);
+        if (idempotencyError) {
+            return {
+                action: 'dead-letter',
+                queue: 'undeliverable',
+                reason: idempotencyError.message,
+            };
+        }
         // Allow processing to continue
         return { action: 'process' };
     }
@@ -100,15 +112,13 @@ export class StandardRetryPolicy {
                 reason: `max attempts exceeded (${this.config.maxAttempts})`,
             };
         }
-        // 6. Non-idempotent subscriber on redelivery
-        // 'no' and 'unknown' are treated the same (safer default)
-        if (receipt.redelivered &&
-            (subscriber.idempotent === 'no' || subscriber.idempotent === 'unknown')) {
-            const idempotentError = new IdempotentMessageCannotRetryError(envelope.id, subscriber.name);
+        // 6. Non-idempotent subscriber
+        const idempotencyError = this.checkIdempotency(envelope, receipt, subscriber, error);
+        if (idempotencyError) {
             return {
                 action: 'dead-letter',
                 queue: 'undeliverable',
-                reason: idempotentError.message,
+                reason: idempotencyError.message,
             };
         }
         // 7. Default: retry with backoff
@@ -135,4 +145,21 @@ export class StandardRetryPolicy {
         }
         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) {
+        // 'no' and 'unknown' are treated the same (safer default)
+        if ((error || receipt.redelivered) &&
+            (subscriber.idempotent === 'no' || subscriber.idempotent === 'unknown')) {
+            return new IdempotentMessageCannotRetryError(envelope.id, subscriber.name);
+        }
+        return null;
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zdavison/matador",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "description": "A batteries-included event system.",
   "type": "module",
   "main": "./dist/index.cjs",

package/dist/checkpoint/context.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=context.test.d.ts.map

package/dist/checkpoint/context.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.test.d.ts","sourceRoot":"","sources":["../../src/checkpoint/context.test.ts"],"names":[],"mappings":""}

package/dist/checkpoint/context.test.js

@@ -1,428 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'bun:test';
-import { DuplicateIoKeyError } from '../errors/index.js';
-import { ResumableContext } from './context.js';
-import { MemoryCheckpointStore } from './stores/memory.js';
-function createTestEnvelope(id = 'test-envelope-id', attempts = 1) {
-    return {
-        id,
-        data: { userId: '123' },
-        docket: {
-            eventKey: 'test.event',
-            targetSubscriber: 'test-subscriber',
-            importance: 'should-investigate',
-            attempts,
-            createdAt: new Date().toISOString(),
-        },
-    };
-}
-function createTestSubscriber(name = 'test-subscriber') {
-    return {
-        name,
-        description: 'Test subscriber',
-        idempotent: 'resumable',
-        importance: 'should-investigate',
-    };
-}
-describe('ResumableContext', () => {
-    let store;
-    let envelope;
-    let subscriber;
-    beforeEach(() => {
-        store = new MemoryCheckpointStore();
-        envelope = createTestEnvelope();
-        subscriber = createTestSubscriber();
-    });
-    describe('io()', () => {
-        it('should execute function and cache result on first call', async () => {
-            const context = new ResumableContext({
-                store,
-                envelope,
-                subscriber,
-            });
-            let executeCount = 0;
-            const result = await context.io('step-1', () => {
-                executeCount++;
-                return 'result-1';
-            });
-            expect(result).toBe('result-1');
-            expect(executeCount).toBe(1);
-            expect(store.size).toBe(1);
-        });
-        it('should return cached result on retry without re-executing', async () => {
-            // First execution - cache the result
-            const firstContext = new ResumableContext({
-                store,
-                envelope,
-                subscriber,
-            });
-            let executeCount = 0;
-            await firstContext.io('step-1', () => {
-                executeCount++;
-                return 'result-1';
-            });
-            expect(executeCount).toBe(1);
-            // Simulate retry - load existing checkpoint
-            const checkpoint = await store.get(envelope.id);
-            const retryContext = new ResumableContext({
-                store,
-                envelope: createTestEnvelope(envelope.id, 2),
-                subscriber,
-                existingCheckpoint: checkpoint,
-            });
-            const result = await retryContext.io('step-1', () => {
-                executeCount++;
-                return 'should-not-be-used';
-            });
-            expect(result).toBe('result-1');
-            expect(executeCount).toBe(1); // Still 1, not re-executed
-        });
-        it('should throw DuplicateIoKeyError on duplicate key within same execution', async () => {
-            const context = new ResumableContext({
-                store,
-                envelope,
-                subscriber,
-            });
-            await context.io('same-key', () => 'first');
-            await expect(context.io('same-key', () => 'second')).rejects.toThrow(DuplicateIoKeyError);
-        });
-        it('should handle async functions', async () => {
-            const context = new ResumableContext({
-                store,
-                envelope,
-                subscriber,
-            });
-            const result = await context.io('async-step', async () => {
-                await new Promise((resolve) => setTimeout(resolve, 10));
-                return { value: 42 };
-            });
-            expect(result).toEqual({ value: 42 });
-        });
-        it('should not cache failed operations', async () => {
-            const context = new ResumableContext({
-                store,
-                envelope,
-                subscriber,
-            });
-            // First attempt - fails
-            await expect(context.io('failing-step', () => {
-                throw new Error('Operation failed');
-            })).rejects.toThrow('Operation failed');
-            // Checkpoint should not contain the failed step
-            const checkpoint = await store.get(envelope.id);
-            expect(checkpoint?.completedSteps['failing-step']).toBeUndefined();
-        });
-        it('should persist checkpoint after each io() call', async () => {
-            const context = new ResumableContext({
-                store,
-                envelope,
-                subscriber,
-            });
-            await context.io('step-1', () => 'result-1');
-            let checkpoint = await store.get(envelope.id);
-            if (!checkpoint)
-                throw new Error('expected checkpoint after step-1');
-            expect(Object.keys(checkpoint.completedSteps)).toHaveLength(1);
-            await context.io('step-2', () => 'result-2');
-            checkpoint = await store.get(envelope.id);
-            if (!checkpoint)
-                throw new Error('expected checkpoint after step-2');
-            expect(Object.keys(checkpoint.completedSteps)).toHaveLength(2);
-        });
-        it('should support various JSON-serializable return types', async () => {
-            const context = new ResumableContext({
-                store,
-                envelope,
-                subscriber,
-            });
-            expect(await context.io('string', () => 'hello')).toBe('hello');
-            expect(await context.io('number', () => 42)).toBe(42);
-            expect(await context.io('boolean', () => true)).toBe(true);
-            expect(await context.io('null', () => null)).toBe(null);
-            expect(await context.io('array', () => [1, 2, 3])).toEqual([1, 2, 3]);
-            expect(await context.io('object', () => ({ foo: 'bar' }))).toEqual({
-                foo: 'bar',
-            });
-        });
-    });
-    describe('all()', () => {
-        it('should execute multiple operations in parallel', async () => {
-            const context = new ResumableContext({
-                store,
-                envelope,
-                subscriber,
-            });
-            const executionOrder = [];
-            const [a, b, c] = await context.all([
-                [
-                    'fetch-a',
-                    () => {
-                        executionOrder.push('a');
-                        return 'result-a';
-                    },
-                ],
-                [
-                    'fetch-b',
-                    () => {
-                        executionOrder.push('b');
-                        return 'result-b';
-                    },
-                ],
-                [
-                    'fetch-c',
-                    () => {
-                        executionOrder.push('c');
-                        return 'result-c';
-                    },
-                ],
-            ]);
-            expect(a).toBe('result-a');
-            expect(b).toBe('result-b');
-            expect(c).toBe('result-c');
-            expect(executionOrder).toHaveLength(3);
-        });
-        it('should cache all results on retry', async () => {
-            // First execution
-            const firstContext = new ResumableContext({
-                store,
-                envelope,
-                subscriber,
-            });
-            let executeCount = 0;
-            await firstContext.all([
-                [
-                    'fetch-a',
-                    () => {
-                        executeCount++;
-                        return 'result-a';
-                    },
-                ],
-                [
-                    'fetch-b',
-                    () => {
-                        executeCount++;
-                        return 'result-b';
-                    },
-                ],
-            ]);
-            expect(executeCount).toBe(2);
-            // Retry with cached checkpoint
-            const checkpoint = await store.get(envelope.id);
-            const retryContext = new ResumableContext({
-                store,
-                envelope: createTestEnvelope(envelope.id, 2),
-                subscriber,
-                existingCheckpoint: checkpoint,
-            });
-            const [a, b] = await retryContext.all([
-                [
-                    'fetch-a',
-                    () => {
-                        executeCount++;
-                        return 'new-a';
-                    },
-                ],
-                [
-                    'fetch-b',
-                    () => {
-                        executeCount++;
-                        return 'new-b';
-                    },
-                ],
-            ]);
-            expect(a).toBe('result-a'); // Cached
-            expect(b).toBe('result-b'); // Cached
-            expect(executeCount).toBe(2); // Still 2, not re-executed
-        });
-        it('should throw on duplicate key in all()', async () => {
-            const context = new ResumableContext({
-                store,
-                envelope,
-                subscriber,
-            });
-            await expect(context.all([
-                ['same-key', () => 'first'],
-                ['same-key', () => 'second'],
-            ])).rejects.toThrow(DuplicateIoKeyError);
-        });
-        it('should throw if all() key conflicts with previous io() key', async () => {
-            const context = new ResumableContext({
-                store,
-                envelope,
-                subscriber,
-            });
-            await context.io('used-key', () => 'first');
-            await expect(context.all([
-                ['used-key', () => 'second'],
-                ['new-key', () => 'third'],
-            ])).rejects.toThrow(DuplicateIoKeyError);
-        });
-    });
-    describe('attempt and isRetry', () => {
-        it('should report attempt number from envelope', async () => {
-            const context = new ResumableContext({
-                store,
-                envelope: createTestEnvelope('test', 3),
-                subscriber,
-            });
-            expect(context.attempt).toBe(3);
-        });
-        it('should report isRetry as false for first attempt', async () => {
-            const context = new ResumableContext({
-                store,
-                envelope: createTestEnvelope('test', 1),
-                subscriber,
-            });
-            expect(context.isRetry).toBe(false);
-        });
-        it('should report isRetry as true for subsequent attempts', async () => {
-            const context = new ResumableContext({
-                store,
-                envelope: createTestEnvelope('test', 2),
-                subscriber,
-            });
-            expect(context.isRetry).toBe(true);
-        });
-    });
-    describe('clear()', () => {
-        it('should delete checkpoint from store', async () => {
-            const context = new ResumableContext({
-                store,
-                envelope,
-                subscriber,
-            });
-            await context.io('step-1', () => 'result');
-            expect(store.size).toBe(1);
-            await context.clear();
-            expect(store.size).toBe(0);
-        });
-    });
-    describe('hooks', () => {
-        it('should call onCheckpointHit when using cached value', async () => {
-            const onCheckpointHit = vi.fn();
-            // First execution - populate cache
-            const firstContext = new ResumableContext({
-                store,
-                envelope,
-                subscriber,
-            });
-            await firstContext.io('cached-step', () => 'cached-result');
-            // Retry with hooks
-            const checkpoint = await store.get(envelope.id);
-            const retryContext = new ResumableContext({
-                store,
-                envelope: createTestEnvelope(envelope.id, 2),
-                subscriber,
-                existingCheckpoint: checkpoint,
-                hooks: { onCheckpointHit },
-            });
-            await retryContext.io('cached-step', () => 'new-result');
-            expect(onCheckpointHit).toHaveBeenCalledWith({
-                envelope: expect.anything(),
-                subscriber,
-                stepKey: 'cached-step',
-            });
-        });
-        it('should call onCheckpointMiss when executing fresh', async () => {
-            const onCheckpointMiss = vi.fn();
-            const context = new ResumableContext({
-                store,
-                envelope,
-                subscriber,
-                hooks: { onCheckpointMiss },
-            });
-            await context.io('fresh-step', () => 'result');
-            expect(onCheckpointMiss).toHaveBeenCalledWith({
-                envelope,
-                subscriber,
-                stepKey: 'fresh-step',
-            });
-        });
-    });
-    describe('real-world scenarios', () => {
-        it('should replay cached steps and execute new ones on retry', async () => {
-            const executionLog = [];
-            let shouldFail = true;
-            // First attempt - fails after step-1
-            const firstContext = new ResumableContext({
-                store,
-                envelope,
-                subscriber,
-            });
-            try {
-                await firstContext.io('step-0', () => {
-                    executionLog.push('step-0');
-                    return 'result-0';
-                });
-                await firstContext.io('step-1', () => {
-                    executionLog.push('step-1');
-                    return 'result-1';
-                });
-                if (shouldFail) {
-                    shouldFail = false;
-                    throw new Error('Simulated failure');
-                }
-                await firstContext.io('step-2', () => {
-                    executionLog.push('step-2');
-                    return 'result-2';
-                });
-            }
-            catch {
-                // Expected failure
-            }
-            expect(executionLog).toEqual(['step-0', 'step-1']);
-            // Retry - step-0 and step-1 use cache, step-2 executes
-            executionLog.length = 0;
-            const checkpoint = await store.get(envelope.id);
-            const retryContext = new ResumableContext({
-                store,
-                envelope: createTestEnvelope(envelope.id, 2),
-                subscriber,
-                existingCheckpoint: checkpoint,
-            });
-            await retryContext.io('step-0', () => {
-                executionLog.push('step-0');
-                return 'should-not-use';
-            });
-            await retryContext.io('step-1', () => {
-                executionLog.push('step-1');
-                return 'should-not-use';
-            });
-            await retryContext.io('step-2', () => {
-                executionLog.push('step-2');
-                return 'result-2';
-            });
-            expect(executionLog).toEqual(['step-2']); // Only step-2 executed!
-        });
-        it('should handle conditional io() calls correctly', async () => {
-            const context = new ResumableContext({
-                store,
-                envelope: { ...envelope, data: { sendEmail: true } },
-                subscriber,
-            });
-            const result = await context.io('send-email', () => ({
-                messageId: 'msg-123',
-            }));
-            expect(result).toEqual({ messageId: 'msg-123' });
-        });
-        it('should handle dynamic loop with unique keys', async () => {
-            const context = new ResumableContext({
-                store,
-                envelope,
-                subscriber,
-            });
-            const items = [
-                { id: 'item-1', value: 10 },
-                { id: 'item-2', value: 20 },
-                { id: 'item-3', value: 30 },
-            ];
-            const results = [];
-            for (const item of items) {
-                const processed = await context.io(`process-${item.id}`, () => {
-                    return item.value * 2;
-                });
-                results.push(processed);
-            }
-            expect(results).toEqual([20, 40, 60]);
-        });
-    });
-});

package/dist/checkpoint/stores/stores.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=stores.test.d.ts.map

package/dist/checkpoint/stores/stores.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stores.test.d.ts","sourceRoot":"","sources":["../../../src/checkpoint/stores/stores.test.ts"],"names":[],"mappings":""}