chore(sdk): simplify ExecutionState interface (#329)

*Issue #, if available:*

*Description of changes:*

The ExecutionState interface has multiple duplicated parameters.
Combining them into just the API parameters that are required for the
interface.


By submitting this pull request, I confirm that you can use, modify,
copy, and redistribute this contribution, under the terms of your
choice.

Author: anthonyting

packages/aws-durable-execution-sdk-js-testing/src/test-runner/local/local-runner-storage.ts

@@ -3,6 +3,7 @@ import {
   CheckpointDurableExecutionRequest,
   CheckpointDurableExecutionResponse,
   GetDurableExecutionStateCommand,
+  GetDurableExecutionStateRequest,
   GetDurableExecutionStateResponse,
   LambdaClient,
 } from "@aws-sdk/client-lambda";
@@ -31,33 +32,20 @@ export class LocalRunnerStorage implements ExecutionState {
   }
 
   async getStepData(
-    checkpointToken: string,
-    durableExecutionArn: string,
-    nextMarker: string,
+    params: GetDurableExecutionStateRequest,
   ): Promise<GetDurableExecutionStateResponse> {
     const response = await this.client.send(
-      new GetDurableExecutionStateCommand({
-        DurableExecutionArn: durableExecutionArn,
-        CheckpointToken: checkpointToken,
-        Marker: nextMarker,
-        MaxItems: 1000,
-      }),
+      new GetDurableExecutionStateCommand(params),
     );
 
     return response;
   }
 
   async checkpoint(
-    checkpointToken: string,
-    data: CheckpointDurableExecutionRequest,
+    params: CheckpointDurableExecutionRequest,
   ): Promise<CheckpointDurableExecutionResponse> {
     const response = await this.client.send(
-      new CheckpointDurableExecutionCommand({
-        DurableExecutionArn: data.DurableExecutionArn,
-        CheckpointToken: checkpointToken,
-        ClientToken: data.ClientToken,
-        Updates: data.Updates,
-      }),
+      new CheckpointDurableExecutionCommand(params),
     );
 
     return response;

packages/aws-durable-execution-sdk-js/src/context/execution-context/execution-context.test.ts

@@ -246,9 +246,12 @@ describe("initializeExecutionContext", () => {
 
     // Verify
     expect(mockExecutionState.getStepData).toHaveBeenCalledWith(
-      mockCheckpointToken,
-      "test-durable-execution-arn",
-      "token1",
+      {
+        CheckpointToken: mockCheckpointToken,
+        DurableExecutionArn: "test-durable-execution-arn",
+        Marker: "token1",
+        MaxItems: 1000,
+      },
       expectLogger,
     );
     expect(result.executionContext._stepData).toEqual({
@@ -305,15 +308,21 @@ describe("initializeExecutionContext", () => {
 
     // Verify
     expect(mockExecutionState.getStepData).toHaveBeenCalledWith(
-      mockCheckpointToken,
-      "test-durable-execution-arn",
-      "token1",
+      {
+        CheckpointToken: mockCheckpointToken,
+        DurableExecutionArn: "test-durable-execution-arn",
+        Marker: "token1",
+        MaxItems: 1000,
+      },
       expectLogger,
     );
     expect(mockExecutionState.getStepData).toHaveBeenCalledWith(
-      mockCheckpointToken,
-      "test-durable-execution-arn",
-      "token2",
+      {
+        CheckpointToken: mockCheckpointToken,
+        DurableExecutionArn: "test-durable-execution-arn",
+        Marker: "token2",
+        MaxItems: 1000,
+      },
       expectLogger,
     );
     expect(result.executionContext._stepData).toEqual({
@@ -358,16 +367,22 @@ describe("initializeExecutionContext", () => {
 
     // Verify
     expect(mockExecutionState.getStepData).toHaveBeenCalledWith(
-      mockCheckpointToken,
-      "test-durable-execution-arn",
-      "token1",
+      {
+        CheckpointToken: mockCheckpointToken,
+        DurableExecutionArn: "test-durable-execution-arn",
+        Marker: "token1",
+        MaxItems: 1000,
+      },
       expectLogger,
     );
 
     expect(mockExecutionState.getStepData).toHaveBeenCalledWith(
-      mockCheckpointToken,
-      "test-durable-execution-arn",
-      "token2",
+      {
+        CheckpointToken: mockCheckpointToken,
+        DurableExecutionArn: "test-durable-execution-arn",
+        Marker: "token2",
+        MaxItems: 1000,
+      },
       expectLogger,
     );
 
@@ -400,9 +415,12 @@ describe("initializeExecutionContext", () => {
 
     // Verify
     expect(mockExecutionState.getStepData).toHaveBeenCalledWith(
-      mockCheckpointToken,
-      "test-durable-execution-arn",
-      "token1",
+      {
+        CheckpointToken: mockCheckpointToken,
+        DurableExecutionArn: "test-durable-execution-arn",
+        Marker: "token1",
+        MaxItems: 1000,
+      },
       expectLogger,
     );
     expect(mockExecutionState.getStepData).toHaveBeenCalledTimes(1); // Should only be called once
@@ -437,9 +455,12 @@ describe("initializeExecutionContext", () => {
 
     // Verify - should handle undefined operations gracefully and get execution event from pagination
     expect(mockExecutionState.getStepData).toHaveBeenCalledWith(
-      mockCheckpointToken,
-      "test-durable-execution-arn",
-      "token1",
+      {
+        CheckpointToken: mockCheckpointToken,
+        DurableExecutionArn: "test-durable-execution-arn",
+        Marker: "token1",
+        MaxItems: 1000,
+      },
       expectLogger,
     );
     expect(result.executionContext._stepData).toEqual({});
@@ -482,9 +503,12 @@ describe("initializeExecutionContext", () => {
 
     // Verify
     expect(mockExecutionState.getStepData).toHaveBeenCalledWith(
-      mockCheckpointToken,
-      "test-durable-execution-arn",
-      "token1",
+      {
+        CheckpointToken: mockCheckpointToken,
+        DurableExecutionArn: "test-durable-execution-arn",
+        Marker: "token1",
+        MaxItems: 1000,
+      },
       expectLogger,
     );
     expect(result.executionContext._stepData).toEqual({

packages/aws-durable-execution-sdk-js/src/context/execution-context/execution-context.ts

@@ -40,9 +40,12 @@ export const initializeExecutionContext = async (
 
   while (nextMarker) {
     const response = await state.getStepData(
-      checkpointToken,
-      durableExecutionArn,
-      nextMarker,
+      {
+        CheckpointToken: checkpointToken,
+        Marker: nextMarker,
+        DurableExecutionArn: durableExecutionArn,
+        MaxItems: 1000,
+      },
       initLogger,
     );
     operationsArray.push(...(response.Operations || []));

packages/aws-durable-execution-sdk-js/src/handlers/run-in-child-context-handler/run-in-child-context-integration.test.ts

@@ -72,13 +72,11 @@ describe("Run In Child Context Integration Tests", () => {
         getStepData: jest.fn().mockResolvedValue({}),
         checkpoint: jest
           .fn()
-          .mockImplementation(
-            (taskToken: string, data: CheckpointDurableExecutionRequest) => {
-              const checkpointToken = data.CheckpointToken;
-              checkpointCalls.push({ checkpointToken, data });
-              return Promise.resolve({ CheckpointToken: "mock-token" });
-            },
-          ),
+          .mockImplementation((data: CheckpointDurableExecutionRequest) => {
+            const checkpointToken = data.CheckpointToken;
+            checkpointCalls.push({ checkpointToken, data });
+            return Promise.resolve({ CheckpointToken: "mock-token" });
+          }),
       },
       _stepData: {},
       terminationManager: mockTerminationManager,

packages/aws-durable-execution-sdk-js/src/storage/api-storage.test.ts

@@ -72,11 +72,12 @@ describe("ApiStorage", () => {
     mockLambdaClient.send.mockResolvedValue(mockResponse);
 
     // Call getStepData
-    const result = await apiStorage.getStepData(
-      "checkpoint-token",
-      "durable-execution-arn",
-      "next-marker",
-    );
+    const result = await apiStorage.getStepData({
+      CheckpointToken: "checkpoint-token",
+      DurableExecutionArn: "durable-execution-arn",
+      Marker: "next-marker",
+      MaxItems: 1000,
+    });
 
     // Verify that GetDurableExecutionStateCommand was constructed with the correct parameters
     expect(GetDurableExecutionStateCommand).toHaveBeenCalledWith({
@@ -103,7 +104,7 @@ describe("ApiStorage", () => {
     // Create checkpoint data
     const checkpointData: CheckpointDurableExecutionRequest = {
       DurableExecutionArn: "test-durable-execution-arn",
-      CheckpointToken: "",
+      CheckpointToken: "task-token",
       Updates: [
         {
           Id: "test-step-1",
@@ -115,7 +116,7 @@ describe("ApiStorage", () => {
     };
 
     // Call checkpoint
-    const result = await apiStorage.checkpoint("task-token", checkpointData);
+    const result = await apiStorage.checkpoint(checkpointData);
 
     // Verify that CheckpointDurableExecutionCommand was constructed with the correct parameters
     expect(CheckpointDurableExecutionCommand).toHaveBeenCalledWith({
@@ -140,18 +141,18 @@ describe("ApiStorage", () => {
 
     // Call getStepData and expect it to throw
     await expect(
-      apiStorage.getStepData(
-        "task-token",
-        "durable-execution-arn",
-        "next-token",
-      ),
+      apiStorage.getStepData({
+        CheckpointToken: "task-token",
+        DurableExecutionArn: "durable-execution-arn",
+        Marker: "next-token",
+      }),
     ).rejects.toThrow("Lambda client error");
 
     // Call checkpoint and expect it to throw
     await expect(
-      apiStorage.checkpoint("task-token", {
+      apiStorage.checkpoint({
         DurableExecutionArn: "",
-        CheckpointToken: "",
+        CheckpointToken: "task-token",
         Updates: [
           {
             Id: "test-step-2",
@@ -174,11 +175,11 @@ describe("ApiStorage", () => {
 
     // Call getStepData and expect it to throw
     try {
-      await apiStorage.getStepData(
-        "checkpoint-token",
-        "test-execution-arn",
-        "next-marker",
-      );
+      await apiStorage.getStepData({
+        CheckpointToken: "checkpoint-token",
+        DurableExecutionArn: "test-execution-arn",
+        Marker: "next-marker",
+      });
     } catch (_error) {
       // Expected to throw
     }
@@ -204,13 +205,13 @@ describe("ApiStorage", () => {
 
     const checkpointData: CheckpointDurableExecutionRequest = {
       DurableExecutionArn: "test-execution-arn-2",
-      CheckpointToken: "",
+      CheckpointToken: "checkpoint-token",
       Updates: [],
     };
 
     // Call checkpoint and expect it to throw
     try {
-      await apiStorage.checkpoint("checkpoint-token", checkpointData);
+      await apiStorage.checkpoint(checkpointData);
     } catch (_error) {
       // Expected to throw
     }
@@ -233,11 +234,11 @@ describe("ApiStorage", () => {
 
     // Call getStepData and expect it to throw
     await expect(
-      apiStorage.getStepData(
-        "checkpoint-token",
-        "test-execution-arn",
-        "next-marker",
-      ),
+      apiStorage.getStepData({
+        CheckpointToken: "checkpoint-token",
+        DurableExecutionArn: "test-execution-arn",
+        Marker: "next-marker",
+      }),
     ).rejects.toThrow("Network error");
 
     // Verify error was logged
@@ -269,9 +270,11 @@ describe("ApiStorage", () => {
 
     try {
       await apiStorage.getStepData(
-        "checkpoint-token",
-        "test-execution-arn",
-        "next-marker",
+        {
+          CheckpointToken: "checkpoint-token",
+          DurableExecutionArn: "test-execution-arn",
+          Marker: "next-marker",
+        },
         mockLogger,
       );
     } catch (_error) {
@@ -303,16 +306,12 @@ describe("ApiStorage", () => {
 
     const checkpointData: CheckpointDurableExecutionRequest = {
       DurableExecutionArn: "test-execution-arn",
-      CheckpointToken: "",
+      CheckpointToken: "checkpoint-token",
       Updates: [],
     };
 
     try {
-      await apiStorage.checkpoint(
-        "checkpoint-token",
-        checkpointData,
-        mockLogger,
-      );
+      await apiStorage.checkpoint(checkpointData, mockLogger);
     } catch (_error) {
       // Expected to throw
     }