addressed PR review comments

Author: anusha-amz

lambda-durable-eventbridge-cron-nodejs-sam/README.md

@@ -1,14 +1,14 @@
-# EventBridge Cron to Durable Lambda Function
+# Amazon EventBridge cron to AWS Lambda durable function
 
-This pattern demonstrates how to trigger a durable Lambda function using EventBridge on a cron schedule. The Lambda function uses the AWS durable execution SDK to implement a multi-step workflow with checkpointing and automatic replay capabilities.
+This pattern demonstrates how to trigger a Lambda durable function using Amazon EventBridge on a cron schedule. The Lambda function uses the AWS durable execution SDK to implement a multi-step workflow with checkpointing and automatic replay capabilities.
 
-Learn more about this pattern at Serverless Land Patterns: https://serverlessland.com/patterns/lambda-durable-eventbrdige-cron-nodejs-sam
+Learn more about this pattern at Serverless Land Patterns: https://serverlessland.com/patterns/lambda-durable-eventbridge-cron-nodejs-sam
 
 Important: this application uses various AWS services and there are costs associated with these services after the Free Tier usage - please see the [AWS Pricing page](https://aws.amazon.com/pricing/) for details. You are responsible for any AWS costs incurred. No warranty is implied in this example.
 
 ## Architecture
 
-This architecture consists of a serverless cron job implementation using EventBridge and durable Lambda functions. An EventBridge rule configured with a cron expression triggers the durable Lambda function every 5-minutes. The Lambda function uses the AWS durable execution SDK to implement a multi-step workflow that can span multiple invocations through checkpointing - when `context.wait()` is called, the function suspends execution and creates a checkpoint, then resumes from that point in a subsequent invocation without re-executing previous steps. 
+This architecture consists of a serverless cron job implementation using Amazon EventBridge and Lambda durable functions. An Amazon EventBridge rule configured with a cron expression triggers the Lambda durable function every 5-minutes. The Lambda function uses the AWS durable execution SDK to implement a multi-step workflow that can span multiple invocations through checkpointing - when `context.wait()` is called, the function suspends execution and creates a checkpoint, then resumes from that point in a subsequent invocation without re-executing previous steps. 
 
 ## Requirements
 
@@ -45,29 +45,29 @@ This architecture consists of a serverless cron job implementation using EventBr
 
 This pattern creates:
 
-1. **Durable Orchestrator Lambda Function**: A Nodejs 24.x Lambda function that uses the AWS durable execution SDK to implement a multi-step workflow (invoking 2 Lmabda functions) with automatic checkpointing and replay capabilities.
+1. **Durable Orchestrator Lambda Function**: A Node.js 24.x Lambda function that uses the AWS durable execution SDK to implement a multi-step workflow (invoking 2 Lambda functions) with automatic checkpointing and replay capabilities.
 
 2. **Data Processor Lambda Function**: An activity function that simulates processing records.
 
 3. **Notification Service Lambda Function**: A final step that simulates sending a summary once processing is complete.
 
-4. **EventBridge Cron Rule**: An EventBridge rule configured with `rate(5 minutes)` that triggers the Lambda function every 5-minutes.
+4. **Amazon EventBridge Cron Rule**: An Amazon EventBridge rule configured with `rate(5 minutes)` that triggers the Lambda function every 5-minutes.
 
 5. **Function Versioning**: The Lambda function uses `AutoPublishAlias: prod` to automatically publish a new version on each deployment and point the `prod` alias to it.
 
-6. **Targeted Invocation**: The EventBridge rule specifically targets the published version via the alias as it is a best practice to use numbered versions or aliases for production durable functions rather than $LATEST.
+6. **Targeted Invocation**: The Amazon EventBridge rule specifically targets the published version via the alias as it is a best practice to use numbered versions or aliases for production durable functions rather than $LATEST.
 
 ### Durable Execution Flow
 
 The Lambda function implements a durable workflow with three steps:
 
-1. **Data Processing Step**: Invokes DataProcessor Lambda function with business logic simulating processing data (checkpointed)
+1. **Data Processing Step**: Uses `context.invoke()` to call DataProcessor Lambda function with automatic checkpointing
 2. **Wait Period**: Suspends execution for 10 seconds using `context.wait()` - no compute costs during wait
-3. **Notification Service Processing**: Invokes NotificationService Lambda function with business logic simulating sending notifications and returns results
+3. **Notification Service Processing**: Uses `context.invoke()` to call NotificationService Lambda function and returns results
 
 **Execution Pattern**:
-- **Invocation 1**: `invoke-data-processor()` runs → checkpoint created → `context.wait()` suspends execution
-- **Invocation 2**: `invoke-data-processor()` replays from checkpoint (no re-execution) → wait completes → `invoke-notification-service()` runs → workflow completes
+- **Invocation 1**: `context.invoke("DataProcessorFunction", ...)` runs → checkpoint created → `context.wait()` suspends execution
+- **Invocation 2**: DataProcessor replays from checkpoint (no re-execution) → wait completes → `context.invoke("NotificationServiceFunction", ...)` runs → workflow completes
 
 This demonstrates how durable functions can span multiple Lambda invocations while maintaining state and avoiding redundant work through checkpointing.
 

lambda-durable-eventbridge-cron-nodejs-sam/durable-orchestrator/index.js

@@ -1,10 +1,6 @@
 // Main durable function that orchestrates two Lambda functions in sequence
 
-import * as durableSDK from "@aws/durable-execution-sdk-js";
-const {withDurableExecution, Duration } = durableSDK;
-
-import { LambdaClient, InvokeCommand } from "@aws-sdk/client-lambda";
-const lambdaClient = new LambdaClient({});
+import { withDurableExecution } from "@aws/durable-execution-sdk-js";
 
 export const handler = withDurableExecution(
   async (event, context) => {
@@ -13,51 +9,26 @@ export const handler = withDurableExecution(
     const triggerTime = event.time || new Date().toISOString();
 
     // Step 1: Invoke first Lambda function (data processing)
-    const step1Result = await context.step("invoke-data-processor", async () => {
-      console.log('DataProcessorStep...');
-      
-      const command = new InvokeCommand({
-        FunctionName: "DataProcessorFunction",
-        InvocationType: "RequestResponse",
-        Payload: JSON.stringify({
-          executionId,
-          triggerTime,
-          task: "process_data_5minutes"
-        })
-      });
-      
-      const response = await lambdaClient.send(command);
-      const payload = JSON.parse(new TextDecoder().decode(response.Payload));
-      
-      return payload;
+    const step1Result = await context.invoke("DataProcessorFunction", {
+      executionId,
+      triggerTime,
+      task: "process_data_5minutes"
     });
+    console.log(`[${executionId}] DataProcessorStep completed`);
 
     //Lambda will stop executing here and restart in 10 seconds
     await context.wait({seconds: 10});
 
     // Step 2: Invoke second Lambda function (notification service)
-    const step2Result = await context.step("invoke-notification-service", async () => {
-      
-      console.log('NotificationServiceStep...');
-      
-      const command = new InvokeCommand({
-        FunctionName: "NotificationServiceFunction",
-        InvocationType: "RequestResponse",
-        Payload: JSON.stringify({
-          executionId,
-          triggerTime,
-          previousStepResult: step1Result,
-          task: "send_completion_notification",
-        })
-      });
-      
-      const response = await lambdaClient.send(command);
-      const payload = JSON.parse(new TextDecoder().decode(response.Payload));
-    
-      return payload;
+    const step2Result = await context.invoke("NotificationServiceFunction", {
+      executionId,
+      triggerTime,
+      previousStepResult: step1Result,
+      task: "send_completion_notification",
     });
+    console.log(`[${executionId}] NotificationServiceStep completed`);
 
-    console.log('DurableFunctionExecutionCompleted...');
+    console.log(`[${executionId}] DurableFunctionExecutionCompleted`);
 
     // Return final result
     return {
@@ -72,4 +43,4 @@ export const handler = withDurableExecution(
     };
 
   }
-);
+);

lambda-durable-eventbridge-cron-nodejs-sam/durable-orchestrator/package.json

@@ -16,7 +16,6 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@aws-sdk/client-lambda": "^3.700.0",
     "@aws/durable-execution-sdk-js": "^1.0.2"
   }
 }

lambda-durable-eventbridge-cron-nodejs-sam/example-pattern.json

@@ -1,15 +1,15 @@
 {
-  "title": "EventBridge Cron to durable Lambda function",
-  "description": "Create a durable Lambda function triggered by EventBridge on a cron schedule using AWS SAM.",
-  "language": "Nodejs",
+  "title": "Amazon EventBridge Cron to Lambda durable function",
+  "description": "Create a Lambda durable function triggered by Amazon EventBridge on a cron schedule using AWS SAM.",
+  "language": "Node.js",
   "level": "200",
   "framework": "AWS SAM",
   "introBox": {
     "headline": "How it works",
     "text": [
-      "This sample project demonstrates how to create a durable Lambda function that is triggered by EventBridge on a cron schedule. The Lambda function uses the AWS durable execution SDK to implement a multi-step workflow with automatic checkpointing and replay capabilities.",
+      "This sample project demonstrates how to create a Lambda durable function that is triggered by Amazon EventBridge on a cron schedule. The Lambda function uses the AWS durable execution SDK to implement a multi-step workflow with automatic checkpointing and replay capabilities.",
       "The durable execution pattern allows Lambda functions to span multiple invocations while maintaining state. When the function calls context.wait(), it suspends execution and creates a checkpoint. A subsequent invocation resumes from the checkpoint without re-executing previous steps.",
-      "This pattern deploys a durable Lambda function with Nodejs 24 runtime, an EventBridge rule with cron schedule, and uses function versioning to ensure the cron trigger targets a published version rather than $LATEST."
+      "This pattern deploys a Lambda durable function with Node.js 24 runtime, an Amazon EventBridge rule with cron schedule, and uses function versioning to ensure the cron trigger targets a published version rather than $LATEST."
     ]
   },
   "gitHub": {
@@ -31,7 +31,7 @@
         "link": "https://docs.aws.amazon.com/lambda/latest/dg/durable-invoking.html"
       },
       {
-        "text": "AWS durable execution SDK for Nodejs",
+        "text": "AWS durable execution SDK for Node.js",
         "link": "https://github.com/aws/aws-durable-execution-sdk-js"
       }
     ]

lambda-durable-eventbridge-cron-nodejs-sam/template.yaml

@@ -1,7 +1,7 @@
-#AWS SAM template to deploy the durable function with EventBridge schedule
+#AWS SAM template to deploy the Lambda durable function with Amazon EventBridge schedule
 AWSTemplateFormatVersion: "2010-09-09"
 Transform: AWS::Serverless-2016-10-31
-Description: Durable Function with EventBridge Hourly Schedule
+Description: Lambda Durable Function with Amazon EventBridge 5-Minute Schedule
 
 Resources:
   # Main Durable Orchestrator Function
@@ -32,7 +32,7 @@ Resources:
           Type: Schedule
           Properties:
             Schedule: "rate(5 minutes)"
-            Description: Trigger durable function every 5 minutes
+            Description: Trigger Lambda durable function every 5 minutes
             Enabled: true
 
   # Data Processor Function