fix(sdk): fix race condition when checkpoint completion happens before waitForStatusChange is called (#395)

*Issue #, if available:*

*Description of changes:*

There is a race condition in waitForStatusChange where if the operation
completes before this is called, it will not get the status and just
terminate without updating the data correctly. This results in the error
`Cannot return PENDING status with no pending operations.`

To fix this, if the operation status is terminal in waitForStatusChange
or waitForRetryTimer, we resolve instantly instead of creating a promise
and waiting.

This can happen since waitForStatusChange is called asynchronously, so
there can be time between when the phase 2 promise starts and when the
last checkpoint data was updated. I disabled time skipping in
wait-for-callback-serdes.test.ts which consistently shows this (when
running locally). In the cloud tests it's harder to reproduce since we
poll for the callback ID every second and we don't get the data
instantly, but it could still happen in rare cases.

I also added this same safeguard for waitForRetryTimer. This could
happen if the main thread is blocked for a long time somehow and it
fails to call waitForRetryTimer in time.


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-examples/src/examples/wait-for-callback/quick-completion/wait-for-callback-quick-completion.test.ts

@@ -0,0 +1,37 @@
+import { InvocationType } from "@aws-sdk/client-lambda";
+import { handler } from "./wait-for-callback-quick-completion";
+import { createTests } from "../../../utils/test-helper";
+
+createTests({
+  handler,
+  invocationType: InvocationType.Event,
+  localRunnerConfig: {
+    skipTime: false,
+  },
+  tests: (runner, { isCloud }) => {
+    it("should handle waitForCallback when callback completes before ", async () => {
+      const callbackOp = runner.getOperationByIndex(0);
+
+      const executionPromise = runner.run({
+        payload: isCloud
+          ? {
+              submitterDelay: 5,
+            }
+          : {},
+      });
+
+      // only wait for started status
+      await callbackOp.waitForData();
+
+      await callbackOp.sendCallbackSuccess("{}");
+
+      const result = await executionPromise;
+
+      expect(result.getResult()).toEqual({
+        callbackResult: "{}",
+        success: true,
+      });
+      expect(result.getInvocations().length).toBe(1);
+    });
+  },
+});

packages/aws-durable-execution-sdk-js-examples/src/examples/wait-for-callback/quick-completion/wait-for-callback-quick-completion.ts

@@ -0,0 +1,29 @@
+import {
+  DurableContext,
+  withDurableExecution,
+} from "@aws/durable-execution-sdk-js";
+import { ExampleConfig } from "../../../types";
+
+export const config: ExampleConfig = {
+  name: "Wait for Callback - Quick Completion",
+  description:
+    "Demonstrates waitForCallback invocation-level completion scenario",
+};
+
+export const handler = withDurableExecution(
+  async (event: { submitterDelay: number }, context: DurableContext) => {
+    const result = await context.waitForCallback(async () => {
+      if (event.submitterDelay) {
+        await new Promise((resolve) =>
+          setTimeout(resolve, event.submitterDelay * 1000),
+        );
+      }
+      return Promise.resolve();
+    });
+
+    return {
+      callbackResult: result,
+      success: true,
+    };
+  },
+);