Lambda Destinations: Async Failure Routing Beyond Plain SQS DLQs

// cdk/destinations.ts
import * as lambda from "aws-cdk-lib/aws-lambda";
import * as destinations from "aws-cdk-lib/aws-lambda-destinations";
import * as sqs from "aws-cdk-lib/aws-sqs";
import * as events from "aws-cdk-lib/aws-events";

const failQ = new sqs.Queue(this, "FnOnFailure", {
  retentionPeriod: Duration.days(14),
});
const bus = events.EventBus.fromEventBusName(this, "Bus", "platform");

const fn = new lambda.Function(this, "AsyncWorker", {
  runtime: lambda.Runtime.NODEJS_20_X,
  handler: "index.handler",
  code: lambda.Code.fromAsset("dist"),
  retryAttempts: 2,
  onFailure: new destinations.SqsDestination(failQ),
  // alternatively: new destinations.EventBridgeDestination(bus)
});

// types/failureEnvelope.ts
export type FailureEnvelopeV1 = {
  schema: "lambda.failure/v1";
  functionArn: string;
  requestId: string;
  timestamp: string;
  idempotencyKey: string; // from original event or hash
  payload: unknown;       // original async event
  error?: { type: string; message: string };
};

export function fromDestinationRecord(rec: any): FailureEnvelopeV1 {
  const req = rec.requestContext ?? rec.requestPayload ?? {};
  const payload = rec.requestPayload ?? rec;
  const key =
    payload?.idempotencyKey ??
    hashStable(payload);
  return {
    schema: "lambda.failure/v1",
    functionArn: rec.functionArn ?? req.functionArn,
    requestId: rec.requestContext?.requestId ?? "unknown",
    timestamp: new Date().toISOString(),
    idempotencyKey: key,
    payload,
    error: rec.responsePayload?.errorMessage
      ? { type: rec.responsePayload.errorType, message: rec.responsePayload.errorMessage }
      : undefined,
  };
}

// remediator.ts
export async function replay(env: FailureEnvelopeV1, mode: "dry-run" | "live") {
  if (await alreadySucceeded(env.idempotencyKey)) return { status: "skip" };
  if (mode === "dry-run") return { status: "would_replay", env };
  // ✅ Invoke updated alias deliberately — not the broken $LATEST by accident
  await lambda.send(new InvokeCommand({
    FunctionName: `${env.functionArn}:live`,
    InvocationType: "RequestResponse",
    Payload: Buffer.from(JSON.stringify(env.payload)),
  }));
  await markSucceeded(env.idempotencyKey);
  return { status: "replayed" };
}