Lambda Durable Patterns: Avoid Step Functions Until Complexity Earns It

// lib/durable.ts — illustrative callback pattern
import { DynamoDBClient, PutItemCommand, GetItemCommand } from "@aws-sdk/client-dynamodb";
import { randomUUID } from "node:crypto";

const ddb = new DynamoDBClient({});
const TABLE = process.env.TASK_TABLE!;

export async function startWait(input: { orderId: string }) {
 const taskToken = randomUUID();
 await ddb.send(new PutItemCommand({
 TableName: TABLE,
 Item: {
 pk: { S: `task#${taskToken}` },
 orderId: { S: input.orderId },
 status: { S: "WAITING" },
 ttl: { N: String(Math.floor(Date.now() / 1000) + 86400) },
 },
 ConditionExpression: "attribute_not_exists(pk)",
 }));
 // call external system with taskToken as correlation id
 return { taskToken };
}

export async function resume(taskToken: string, result: unknown) {
 const got = await ddb.send(new GetItemCommand({
 TableName: TABLE,
 Key: { pk: { S: `task#${taskToken}` } },
 }));
 if (!got.Item || got.Item.status.S !== "WAITING") {
 // ✅ Idempotent: duplicate callbacks are no-ops
 return { ok: false, reason: "not_waiting" };
 }
 // continue business logic…
 return { ok: true, result };
}

// Only after complexity earns it — sketch
import * as sfn from "aws-cdk-lib/aws-stepfunctions";
import * as tasks from "aws-cdk-lib/aws-stepfunctions-tasks";

const waitForVendor = new tasks.LambdaInvoke(this, "WaitVendor", {
 lambdaFunction: vendorFn,
 integrationPattern: sfn.IntegrationPattern.WAIT_FOR_TASK_TOKEN,
 payload: sfn.TaskInput.fromObject({
 token: sfn.JsonPath.taskToken,
 orderId: sfn.JsonPath.stringAt("$.orderId"),
 }),
});

const definition = submit
 .next(waitForVendor)
 .next(new sfn.Choice(this, "VendorOk?")
 .when(sfn.Condition.stringEquals("$.status", "OK"), fulfill)
 .otherwise(compensate));