test: add basic step serde example (#371)

*Issue #, if available:* n/a

*Description of changes:*
Add a basic step example explaining why and how to use custom SerDe via
`createClassSerdes`.

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

Signed-off-by: Michael Gasch <15986659+embano1@users.noreply.github.com>

Author: embano1

packages/aws-durable-execution-sdk-js-examples/src/examples/serde/basic/serde-basic.test.ts

@@ -0,0 +1,89 @@
+import {
+  OperationStatus,
+  OperationType,
+} from "@aws/durable-execution-sdk-js-testing";
+import { createTests } from "../../../utils/test-helper";
+import { handler } from "./serde-basic";
+
+createTests({
+  name: "serde-basic test",
+  functionName: "serde-basic",
+  handler,
+  tests: (runner) => {
+    it("should preserve User class methods across replay with createClassSerdes", async () => {
+      const execution = await runner.run({
+        payload: {
+          firstName: "John",
+          lastName: "Doe",
+          email: "john.doe@example.com",
+        },
+      });
+
+      // Verify at least 2 invocations (initial + replay after wait)
+      expect(execution.getInvocations().length).toBe(2);
+
+      // Verify we have 3 operations: create-user step, wait, greet-user step
+      expect(execution.getOperations().length).toBe(3);
+
+      // Verify first step (create-user) succeeded
+      const createUserStep = runner.getOperation("create-user");
+      expect(createUserStep).toBeDefined();
+      expect(createUserStep.getType()).toBe(OperationType.STEP);
+      expect(createUserStep.getStatus()).toBe(OperationStatus.SUCCEEDED);
+
+      const stepResult = createUserStep.getStepDetails()?.result as any;
+      expect(stepResult.firstName).toBe("John");
+      expect(stepResult.lastName).toBe("Doe");
+      expect(stepResult.email).toBe("john.doe@example.com");
+
+      // Verify wait operation exists
+      const waitOp = runner.getOperationByIndex(1);
+      expect(waitOp.getType()).toBe(OperationType.WAIT);
+      expect(waitOp.getStatus()).toBe(OperationStatus.SUCCEEDED);
+
+      // Verify second step (greet-user) succeeded
+      const greetUserStep = runner.getOperation("greet-user");
+      expect(greetUserStep).toBeDefined();
+      expect(greetUserStep.getType()).toBe(OperationType.STEP);
+      expect(greetUserStep.getStatus()).toBe(OperationStatus.SUCCEEDED);
+      expect(greetUserStep.getStepDetails()?.error).toBeUndefined();
+      expect(greetUserStep.getStepDetails()?.result).toBe(
+        "Hello, I'm John Doe. My email is john.doe@example.com",
+      );
+
+      // Verify final result
+      const result = execution.getResult() as any;
+      expect(result.user.firstName).toBe("John");
+      expect(result.user.lastName).toBe("Doe");
+      expect(result.user.email).toBe("john.doe@example.com");
+      expect(result.greeting).toBe(
+        "Hello, I'm John Doe. My email is john.doe@example.com",
+      );
+    });
+
+    it("should work with different user data", async () => {
+      const execution = await runner.run({
+        payload: {
+          firstName: "Alice",
+          lastName: "Smith",
+          email: "alice@example.com",
+        },
+      });
+
+      // Verify the greeting was generated correctly using class methods
+      const result = execution.getResult() as any;
+      expect(result.greeting).toBe(
+        "Hello, I'm Alice Smith. My email is alice@example.com",
+      );
+
+      // Verify all operations succeeded
+      const createUserStep = runner.getOperation("create-user");
+      const greetUserStep = runner.getOperation("greet-user");
+      expect(createUserStep.getStepDetails()?.error).toBeUndefined();
+      expect(greetUserStep.getStepDetails()?.error).toBeUndefined();
+
+      // This proves createClassSerdes successfully preserved the User class methods
+      // during deserialization after the wait/replay
+    });
+  },
+});

packages/aws-durable-execution-sdk-js-examples/src/examples/serde/basic/serde-basic.ts

@@ -0,0 +1,90 @@
+import {
+  DurableContext,
+  withDurableExecution,
+  createClassSerdes,
+} from "@aws/durable-execution-sdk-js";
+import { ExampleConfig } from "../../../types";
+
+export const config: ExampleConfig = {
+  name: "Basic Serdes with createClassSerdes",
+  description:
+    "Demonstrates using createClassSerdes to preserve class methods across replay. " +
+    "Shows how default serdes would lose methods, but createClassSerdes maintains them.",
+};
+
+/**
+ * User class demonstrating the need for createClassSerdes.
+ *
+ * IMPORTANT: For createClassSerdes to work, the class must have a
+ * no-argument constructor (or all parameters must be optional).
+ * This is because createClassSerdes calls `new User()` during deserialization,
+ * then uses Object.assign to copy the properties.
+ */
+class User {
+  firstName: string = "";
+  lastName: string = "";
+  email: string = "";
+
+  constructor(firstName?: string, lastName?: string, email?: string) {
+    if (firstName) this.firstName = firstName;
+    if (lastName) this.lastName = lastName;
+    if (email) this.email = email;
+  }
+
+  /**
+   * Method that would be lost with default serdes, but preserved with createClassSerdes
+   */
+  getFullName(): string {
+    return `${this.firstName} ${this.lastName}`;
+  }
+
+  /**
+   * Method that would be lost with default serdes, but preserved with createClassSerdes
+   */
+  greet(): string {
+    return `Hello, I'm ${this.getFullName()}. My email is ${this.email}`;
+  }
+}
+
+export const handler = withDurableExecution(
+  async (
+    event: { firstName: string; lastName: string; email: string },
+    context: DurableContext,
+  ) => {
+    // Create custom serdes for User class
+    const userSerdes = createClassSerdes(User);
+
+    // Step 1: Create user with createClassSerdes to preserve methods
+    // Without this custom serdes, methods would be lost after replay
+    const user = await context.step(
+      "create-user",
+      async () => {
+        const newUser = new User(event.firstName, event.lastName, event.email);
+        context.logger.info("Created user:", {
+          fullName: newUser.getFullName(),
+        });
+        return newUser;
+      },
+      { serdes: userSerdes },
+    );
+
+    // Wait for 1 second - this forces a replay when resumed
+    // On replay, the step above will deserialize using createClassSerdes
+    await context.wait({ seconds: 1 });
+
+    // Step 2: Use user methods - works because createClassSerdes preserved them
+    // If we had used default serdes, user.greet() would throw "is not a function"
+    const greeting = await context.step("greet-user", async () => {
+      return user.greet();
+    });
+
+    return {
+      user: {
+        firstName: user.firstName,
+        lastName: user.lastName,
+        email: user.email,
+      },
+      greeting,
+    };
+  },
+);

packages/aws-durable-execution-sdk-js-examples/template.yml

@@ -1500,6 +1500,31 @@ Resources:
           DURABLE_EXAMPLES_VERBOSE: "true"
     Metadata:
       SkipBuild: "True"
+  SerdeBasic:
+    Type: AWS::Serverless::Function
+    Properties:
+      FunctionName: SerdeBasic-TypeScript
+      CodeUri: ./dist
+      Handler: serde-basic.handler
+      Runtime: nodejs22.x
+      Architectures:
+        - x86_64
+      MemorySize: 128
+      Timeout: 60
+      Role:
+        Fn::GetAtt:
+          - DurableFunctionRole
+          - Arn
+      DurableConfig:
+        ExecutionTimeout: 3600
+        RetentionPeriodInDays: 7
+      Environment:
+        Variables:
+          AWS_ENDPOINT_URL_LAMBDA: http://host.docker.internal:5000
+          DURABLE_VERBOSE_MODE: "false"
+          DURABLE_EXAMPLES_VERBOSE: "true"
+    Metadata:
+      SkipBuild: "True"
   SimpleExecution:
     Type: AWS::Serverless::Function
     Properties: