Refactor durableMode to isReplay

Author: ConnorKirk

packages/idempotency/src/IdempotencyHandler.ts

@@ -17,7 +17,6 @@ import type { BasePersistenceLayer } from './persistence/BasePersistenceLayer.js
 import type { IdempotencyRecord } from './persistence/IdempotencyRecord.js';
 import type {
   AnyFunction,
-  DurableMode,
   IdempotencyHandlerOptions,
 } from './types/IdempotencyOptions.js';
 
@@ -179,9 +178,9 @@ export class IdempotencyHandler<Func extends AnyFunction> {
    * cases we can safely retry the handling a few times.
    */
   public async handle({
-    durableMode,
+    isReplay,
   }: {
-    durableMode?: DurableMode;
+    isReplay?: boolean;
   } = {}): Promise<ReturnType<Func>> {
     // early return if we should skip idempotency completely
     if (this.shouldSkipIdempotency()) {
@@ -195,7 +194,7 @@ export class IdempotencyHandler<Func extends AnyFunction> {
     for (let retryNo = 0; retryNo <= MAX_RETRIES; retryNo++) {
       try {
         const { isIdempotent, result } =
-          await this.#saveInProgressOrReturnExistingResult({ durableMode });
+          await this.#saveInProgressOrReturnExistingResult({ isReplay });
         if (isIdempotent) return result as ReturnType<Func>;
 
         return await this.getFunctionResult();
@@ -362,9 +361,9 @@ export class IdempotencyHandler<Func extends AnyFunction> {
    * and validate it to ensure that it is consistent with the payload to be hashed.
    */
   readonly #saveInProgressOrReturnExistingResult = async ({
-    durableMode,
+    isReplay,
   }: {
-    durableMode?: DurableMode;
+    isReplay?: boolean;
   } = {}): Promise<{
     isIdempotent: boolean;
     result: JSONValue;
@@ -390,7 +389,7 @@ export class IdempotencyHandler<Func extends AnyFunction> {
           { cause: error }
         );
       if (error.name === 'IdempotencyItemAlreadyExistsError') {
-        if (durableMode === 'ReplayMode') {
+        if (isReplay) {
           return returnValue;
         }
 

packages/idempotency/src/makeIdempotent.ts

@@ -146,7 +146,7 @@ function makeIdempotent<Func extends AnyFunction>(
       }
     }
 
-    const durableMode = args[1]?.durableExecutionMode;
+    const isReplay = args[1]?.durableExecutionMode === "REPLAY_MODE"
 
     return new IdempotencyHandler({
       functionToMakeIdempotent: fn,
@@ -156,7 +156,7 @@ function makeIdempotent<Func extends AnyFunction>(
       functionArguments: args,
       functionPayloadToBeHashed,
       thisArg: this,
-    }).handle({ durableMode }) as ReturnType<Func>;
+    }).handle({ isReplay }) as ReturnType<Func>
   };
 }
 

packages/idempotency/src/types/IdempotencyOptions.ts

@@ -206,14 +206,11 @@ type IdempotencyConfigOptions = {
   responseHook?: ResponseHook;
 };
 
-type DurableMode = 'ExecutionMode' | 'ReplayMode';
-
 export type {
   AnyFunction,
   IdempotencyConfigOptions,
   ItempotentFunctionOptions,
   IdempotencyLambdaHandlerOptions,
   IdempotencyHandlerOptions,
   ResponseHook,
-  DurableMode,
 };

packages/idempotency/src/types/index.ts

@@ -15,7 +15,6 @@ export type {
 } from './DynamoDBPersistence.js';
 export type {
   AnyFunction,
-  DurableMode,
   IdempotencyConfigOptions,
   IdempotencyHandlerOptions,
   IdempotencyLambdaHandlerOptions,

packages/idempotency/tests/unit/IdempotencyHandler.test.ts

@@ -240,7 +240,7 @@ describe('Class IdempotencyHandler', () => {
       expect(mockProcessIdempotency).toHaveBeenCalledTimes(MAX_RETRIES + 1);
     });
 
-    it("allows execution when the DurableMode is Replay and there is IN PROGRESS record", async ()=> {
+    it("allows execution when isReplay is true and there is IN PROGRESS record", async ()=> {
       // Arrange
       // Mock saveInProgress to simulate an existing IN_PROGRESS record
       vi.spyOn(persistenceStore, 'saveInProgress')
@@ -256,15 +256,15 @@ describe('Class IdempotencyHandler', () => {
         );
 
       // Act
-      await idempotentHandler.handle({durableMode: "ReplayMode"})
+      await idempotentHandler.handle({isReplay: true})
 
       // Assess
       expect(mockFunctionToMakeIdempotent).toBeCalled()
 
 
     })
 
-    it("raises an IdempotencyAlreadyInProgressError error when the DurableMode is Execution and there is an IN PROGRESS record", async ()=> {
+    it("raises an IdempotencyAlreadyInProgressError error when isReplay is false and there is an IN PROGRESS record", async ()=> {
         // Arrange
         // Mock saveInProgress to simulate an existing IN_PROGRESS record
         vi.spyOn(persistenceStore, 'saveInProgress')
@@ -280,7 +280,7 @@ describe('Class IdempotencyHandler', () => {
           );
 
         // Act & Assess
-        await expect(idempotentHandler.handle({ durableMode: "ExecutionMode" })).rejects.toThrow(IdempotencyAlreadyInProgressError);
+        await expect(idempotentHandler.handle({ isReplay: false })).rejects.toThrow(IdempotencyAlreadyInProgressError);
     })
 
     it("returns the result of the original durable execution when another durable execution with the same payload is invoked", async () => {
@@ -304,7 +304,7 @@ describe('Class IdempotencyHandler', () => {
         .mockResolvedValue(stubRecord);
 
       // Act
-      const result = await idempotentHandler.handle({durableMode: "ExecutionMode"})
+      const result = await idempotentHandler.handle({isReplay: false})
 
       // Assess
       expect(result).toStrictEqual({ response: false });