@aws/durable-execution-sdk-js 1.0.2 → 1.0.3

package/dist-cjs/index.js

@@ -614,6 +614,26 @@ class StepInterruptedError extends Error {
     }
 }
 
+/**
+ * Shared constants to avoid circular dependencies
+ */
+/**
+ * Controls whether stack traces are stored in error objects
+ * TODO: Accept this as configuration parameter in the future
+ */
+/**
+ * Checkpoint manager termination cooldown in milliseconds
+ * After the last operation completes, the checkpoint manager waits this duration
+ * before terminating to allow for any final checkpoint operations
+ */
+const CHECKPOINT_TERMINATION_COOLDOWN_MS = 20;
+/**
+ * Maximum polling duration in milliseconds (15 minutes)
+ * Used to cap setTimeout delays to prevent 32-bit signed integer overflow
+ * and limit polling duration for long-running operations
+ */
+const MAX_POLL_DURATION_MS = 15 * 60 * 1000;
+
 /**
  * Base class for all durable operation errors
  * @public
@@ -1402,6 +1422,7 @@ const createInvokeHandler = (context, checkpoint, createStepId, parentId, checkA
                     Payload: serializedPayload,
                     ChainedInvokeOptions: {
                         FunctionName: funcId,
+                        ...(config?.tenantId && { TenantId: config.tenantId }),
                     },
                 });
             }
@@ -2532,6 +2553,10 @@ class BatchResultImpl {
  * Restores methods to deserialized BatchResult data
  */
 function restoreBatchResult(data) {
+    // If data is already a BatchResultImpl instance, return it as-is
+    if (data instanceof BatchResultImpl) {
+        return data;
+    }
     if (data &&
         typeof data === "object" &&
         "all" in data &&
@@ -2999,7 +3024,7 @@ const getStepData = (stepData, stepId) => {
 };
 
 class DurableContextImpl {
-    executionContext;
+    _executionContext;
     lambdaContext;
     _stepPrefix;
     _stepCounter = 0;
@@ -3011,8 +3036,9 @@ class DurableContextImpl {
     modeManagement;
     durableExecution;
     logger;
-    constructor(executionContext, lambdaContext, durableExecutionMode, inheritedLogger, stepPrefix, durableExecution, parentId) {
-        this.executionContext = executionContext;
+    executionContext;
+    constructor(_executionContext, lambdaContext, durableExecutionMode, inheritedLogger, stepPrefix, durableExecution, parentId) {
+        this._executionContext = _executionContext;
         this.lambdaContext = lambdaContext;
         this._stepPrefix = stepPrefix;
         this._parentId = parentId;
@@ -3020,6 +3046,9 @@ class DurableContextImpl {
         this.durableLogger = inheritedLogger;
         this.durableLogger.configureDurableLoggingContext?.(this.getDurableLoggingContext());
         this.logger = this.createModeAwareLogger(inheritedLogger);
+        this.executionContext = {
+            durableExecutionArn: _executionContext.durableExecutionArn,
+        };
         this.durableExecutionMode = durableExecutionMode;
         this.checkpoint = durableExecution.checkpointManager;
         this.modeManagement = new ModeManagement(this.captureExecutionState.bind(this), this.checkAndUpdateReplayMode.bind(this), this.checkForNonResolvingPromise.bind(this), () => this.durableExecutionMode, (mode) => {
@@ -3031,9 +3060,9 @@ class DurableContextImpl {
             getDurableLogData: () => {
                 const activeContext = getActiveContext();
                 const result = {
-                    executionArn: this.executionContext.durableExecutionArn,
-                    requestId: this.executionContext.requestId,
-                    tenantId: this.executionContext.tenantId,
+                    executionArn: this._executionContext.durableExecutionArn,
+                    requestId: this._executionContext.requestId,
+                    tenantId: this._executionContext.tenantId,
                     operationId: !activeContext || activeContext?.contextId === "root"
                         ? undefined
                         : hashId(activeContext.contextId),
@@ -3110,7 +3139,7 @@ class DurableContextImpl {
     checkAndUpdateReplayMode() {
         if (this.durableExecutionMode === DurableExecutionMode.ReplayMode) {
             const nextStepId = this.getNextStepId();
-            const nextStepData = this.executionContext.getStepData(nextStepId);
+            const nextStepData = this._executionContext.getStepData(nextStepId);
             if (!nextStepData) {
                 this.durableExecutionMode = DurableExecutionMode.ExecutionMode;
             }
@@ -3119,7 +3148,7 @@ class DurableContextImpl {
     captureExecutionState() {
         const wasInReplayMode = this.durableExecutionMode === DurableExecutionMode.ReplayMode;
         const nextStepId = this.getNextStepId();
-        const stepData = this.executionContext.getStepData(nextStepId);
+        const stepData = this._executionContext.getStepData(nextStepId);
         const wasNotFinished = !!(stepData &&
             stepData.Status !== clientLambda.OperationStatus.SUCCEEDED &&
             stepData.Status !== clientLambda.OperationStatus.FAILED);
@@ -3128,7 +3157,7 @@ class DurableContextImpl {
     checkForNonResolvingPromise() {
         if (this.durableExecutionMode === DurableExecutionMode.ReplaySucceededContext) {
             const nextStepId = this.getNextStepId();
-            const nextStepData = this.executionContext.getStepData(nextStepId);
+            const nextStepData = this._executionContext.getStepData(nextStepId);
             if (nextStepData &&
                 nextStepData.Status !== clientLambda.OperationStatus.SUCCEEDED &&
                 nextStepData.Status !== clientLambda.OperationStatus.FAILED) {
@@ -3144,16 +3173,16 @@ class DurableContextImpl {
         return this.modeManagement.withDurableModeManagement(operation);
     }
     step(nameOrFn, fnOrOptions, maybeOptions) {
-        validateContextUsage(this._stepPrefix, "step", this.executionContext.terminationManager);
+        validateContextUsage(this._stepPrefix, "step", this._executionContext.terminationManager);
         return this.withDurableModeManagement(() => {
-            const stepHandler = createStepHandler(this.executionContext, this.checkpoint, this.lambdaContext, this.createStepId.bind(this), this.durableLogger, this._parentId);
+            const stepHandler = createStepHandler(this._executionContext, this.checkpoint, this.lambdaContext, this.createStepId.bind(this), this.durableLogger, this._parentId);
             return stepHandler(nameOrFn, fnOrOptions, maybeOptions);
         });
     }
     invoke(nameOrFuncId, funcIdOrInput, inputOrConfig, maybeConfig) {
-        validateContextUsage(this._stepPrefix, "invoke", this.executionContext.terminationManager);
+        validateContextUsage(this._stepPrefix, "invoke", this._executionContext.terminationManager);
         return this.withDurableModeManagement(() => {
-            const invokeHandler = createInvokeHandler(this.executionContext, this.checkpoint, this.createStepId.bind(this), this._parentId, this.checkAndUpdateReplayMode.bind(this));
+            const invokeHandler = createInvokeHandler(this._executionContext, this.checkpoint, this.createStepId.bind(this), this._parentId, this.checkAndUpdateReplayMode.bind(this));
             return invokeHandler(...[
                 nameOrFuncId,
                 funcIdOrInput,
@@ -3163,18 +3192,18 @@ class DurableContextImpl {
         });
     }
     runInChildContext(nameOrFn, fnOrOptions, maybeOptions) {
-        validateContextUsage(this._stepPrefix, "runInChildContext", this.executionContext.terminationManager);
+        validateContextUsage(this._stepPrefix, "runInChildContext", this._executionContext.terminationManager);
         return this.withDurableModeManagement(() => {
-            const blockHandler = createRunInChildContextHandler(this.executionContext, this.checkpoint, this.lambdaContext, this.createStepId.bind(this), () => this.durableLogger, 
+            const blockHandler = createRunInChildContextHandler(this._executionContext, this.checkpoint, this.lambdaContext, this.createStepId.bind(this), () => this.durableLogger, 
             // Adapter function to maintain compatibility
             (executionContext, parentContext, durableExecutionMode, inheritedLogger, stepPrefix, _checkpointToken, parentId) => createDurableContext(executionContext, parentContext, durableExecutionMode, inheritedLogger, stepPrefix, this.durableExecution, parentId), this._parentId);
             return blockHandler(nameOrFn, fnOrOptions, maybeOptions);
         });
     }
     wait(nameOrDuration, maybeDuration) {
-        validateContextUsage(this._stepPrefix, "wait", this.executionContext.terminationManager);
+        validateContextUsage(this._stepPrefix, "wait", this._executionContext.terminationManager);
         return this.withDurableModeManagement(() => {
-            const waitHandler = createWaitHandler(this.executionContext, this.checkpoint, this.createStepId.bind(this), this._parentId, this.checkAndUpdateReplayMode.bind(this));
+            const waitHandler = createWaitHandler(this._executionContext, this.checkpoint, this.createStepId.bind(this), this._parentId, this.checkAndUpdateReplayMode.bind(this));
             return typeof nameOrDuration === "string"
                 ? waitHandler(nameOrDuration, maybeDuration)
                 : waitHandler(nameOrDuration);
@@ -3206,23 +3235,23 @@ class DurableContextImpl {
         }
     }
     createCallback(nameOrConfig, maybeConfig) {
-        validateContextUsage(this._stepPrefix, "createCallback", this.executionContext.terminationManager);
+        validateContextUsage(this._stepPrefix, "createCallback", this._executionContext.terminationManager);
         return this.withDurableModeManagement(() => {
-            const callbackFactory = createCallback(this.executionContext, this.checkpoint, this.createStepId.bind(this), this.checkAndUpdateReplayMode.bind(this), this._parentId);
+            const callbackFactory = createCallback(this._executionContext, this.checkpoint, this.createStepId.bind(this), this.checkAndUpdateReplayMode.bind(this), this._parentId);
             return callbackFactory(nameOrConfig, maybeConfig);
         });
     }
     waitForCallback(nameOrSubmitter, submitterOrConfig, maybeConfig) {
-        validateContextUsage(this._stepPrefix, "waitForCallback", this.executionContext.terminationManager);
+        validateContextUsage(this._stepPrefix, "waitForCallback", this._executionContext.terminationManager);
         return this.withDurableModeManagement(() => {
-            const waitForCallbackHandler = createWaitForCallbackHandler(this.executionContext, this.getNextStepId.bind(this), this.runInChildContext.bind(this));
+            const waitForCallbackHandler = createWaitForCallbackHandler(this._executionContext, this.getNextStepId.bind(this), this.runInChildContext.bind(this));
             return waitForCallbackHandler(nameOrSubmitter, submitterOrConfig, maybeConfig);
         });
     }
     waitForCondition(nameOrCheckFunc, checkFuncOrConfig, maybeConfig) {
-        validateContextUsage(this._stepPrefix, "waitForCondition", this.executionContext.terminationManager);
+        validateContextUsage(this._stepPrefix, "waitForCondition", this._executionContext.terminationManager);
         return this.withDurableModeManagement(() => {
-            const waitForConditionHandler = createWaitForConditionHandler(this.executionContext, this.checkpoint, this.createStepId.bind(this), this.durableLogger, this._parentId);
+            const waitForConditionHandler = createWaitForConditionHandler(this._executionContext, this.checkpoint, this.createStepId.bind(this), this.durableLogger, this._parentId);
             return typeof nameOrCheckFunc === "string" ||
                 nameOrCheckFunc === undefined
                 ? waitForConditionHandler(nameOrCheckFunc, checkFuncOrConfig, maybeConfig)
@@ -3230,23 +3259,23 @@ class DurableContextImpl {
         });
     }
     map(nameOrItems, itemsOrMapFunc, mapFuncOrConfig, maybeConfig) {
-        validateContextUsage(this._stepPrefix, "map", this.executionContext.terminationManager);
+        validateContextUsage(this._stepPrefix, "map", this._executionContext.terminationManager);
         return this.withDurableModeManagement(() => {
-            const mapHandler = createMapHandler(this.executionContext, this._executeConcurrently.bind(this));
+            const mapHandler = createMapHandler(this._executionContext, this._executeConcurrently.bind(this));
             return mapHandler(nameOrItems, itemsOrMapFunc, mapFuncOrConfig, maybeConfig);
         });
     }
     parallel(nameOrBranches, branchesOrConfig, maybeConfig) {
-        validateContextUsage(this._stepPrefix, "parallel", this.executionContext.terminationManager);
+        validateContextUsage(this._stepPrefix, "parallel", this._executionContext.terminationManager);
         return this.withDurableModeManagement(() => {
-            const parallelHandler = createParallelHandler(this.executionContext, this._executeConcurrently.bind(this));
+            const parallelHandler = createParallelHandler(this._executionContext, this._executeConcurrently.bind(this));
             return parallelHandler(nameOrBranches, branchesOrConfig, maybeConfig);
         });
     }
     _executeConcurrently(nameOrItems, itemsOrExecutor, executorOrConfig, maybeConfig) {
-        validateContextUsage(this._stepPrefix, "_executeConcurrently", this.executionContext.terminationManager);
+        validateContextUsage(this._stepPrefix, "_executeConcurrently", this._executionContext.terminationManager);
         return this.withDurableModeManagement(() => {
-            const concurrentExecutionHandler = createConcurrentExecutionHandler(this.executionContext, this.runInChildContext.bind(this), this.skipNextOperation.bind(this));
+            const concurrentExecutionHandler = createConcurrentExecutionHandler(this._executionContext, this.runInChildContext.bind(this), this.skipNextOperation.bind(this));
             const promise = concurrentExecutionHandler(nameOrItems, itemsOrExecutor, executorOrConfig, maybeConfig);
             // Prevent unhandled promise rejections
             promise?.catch(() => { });
@@ -3314,7 +3343,6 @@ class CheckpointManager {
     // Termination cooldown
     terminationTimer = null;
     terminationReason = null;
-    TERMINATION_COOLDOWN_MS = 50;
     constructor(durableExecutionArn, stepData, storage, terminationManager, initialTaskToken, stepDataEmitter, logger, finishedAncestors) {
         this.durableExecutionArn = durableExecutionArn;
         this.stepData = stepData;
@@ -3801,7 +3829,7 @@ class CheckpointManager {
         this.terminationReason = reason;
         log("⏱️", "Scheduling termination", {
             reason,
-            cooldownMs: this.TERMINATION_COOLDOWN_MS,
+            cooldownMs: CHECKPOINT_TERMINATION_COOLDOWN_MS,
         });
         this.terminationTimer = setTimeout(() => {
             if (!this.shouldTerminate()) {
@@ -3810,7 +3838,7 @@ class CheckpointManager {
                 return;
             }
             this.executeTermination(reason);
-        }, this.TERMINATION_COOLDOWN_MS);
+        }, CHECKPOINT_TERMINATION_COOLDOWN_MS);
     }
     executeTermination(reason) {
         log("🛑", "Executing termination after cooldown", { reason });
@@ -3845,6 +3873,10 @@ class CheckpointManager {
             const timestamp = endTimestamp instanceof Date ? endTimestamp : new Date(endTimestamp);
             // Wait until endTimestamp
             delay = Math.max(0, timestamp.getTime() - Date.now());
+            // Skip setTimeout if delay exceeds MAX_POLL_DURATION_MS (Lambda will timeout before it fires)
+            if (delay > MAX_POLL_DURATION_MS) {
+                return;
+            }
         }
         else {
             // No timestamp, start polling immediately (1 second delay)
@@ -3864,7 +3896,6 @@ class CheckpointManager {
         if (!op)
             return;
         // Check if we've exceeded max polling duration (15 minutes)
-        const MAX_POLL_DURATION_MS = 15 * 60 * 1000; // 15 minutes
         if (op.pollStartTime &&
             Date.now() - op.pollStartTime > MAX_POLL_DURATION_MS) {
             // Stop polling after 15 minutes to prevent indefinite resource consumption.
@@ -3976,6 +4007,13 @@ class TerminationManager extends events.EventEmitter {
 // align the default behaviour of how logs are emitted to match the RIC logging behaviour for consistency.
 // For custom logic, users can implement their own logger to log data differently.
 // See: https://github.com/aws/aws-lambda-nodejs-runtime-interface-client/blob/962ed28eefbc052389c4de4366b1c0c49ee08a13/src/LogPatch.js
+/**
+ * Format options for util.formatWithOptions.
+ * Using breakLength: Infinity prevents util.inspect from inserting newlines
+ * when formatting objects, regardless of object size (fixes issue #322).
+ * Defined at module level to avoid creating a new object on every function call.
+ */
+const FORMAT_OPTIONS = { breakLength: Infinity };
 /**
  * JSON.stringify replacer function for Error objects.
  * Based on AWS Lambda Runtime Interface Client LogPatch functionality.
@@ -4041,11 +4079,11 @@ function formatDurableLogData(level, logData, ...messageParams) {
             return JSON.stringify(result, jsonErrorReplacer);
         }
         catch (_) {
-            result.message = util.format(result.message);
+            result.message = util.formatWithOptions(FORMAT_OPTIONS, result.message);
             return JSON.stringify(result);
         }
     }
-    result.message = util.format(...messageParams);
+    result.message = util.formatWithOptions(FORMAT_OPTIONS, ...messageParams);
     for (const param of messageParams) {
         if (param instanceof Error) {
             result.errorType = param?.constructor?.name ?? "UnknownError";
@@ -4200,6 +4238,20 @@ const createDefaultLogger = (executionContext) => {
     return new DefaultLogger(executionContext);
 };
 
+/**
+ * SDK metadata injected by Rollup at build time from package.json.
+ *
+ * At build time, Rollup replaces "@aws/durable-execution-sdk-js" and
+ * "1.0.3" with actual values from package.json.
+ *
+ * Defaults are provided for test environments where Rollup doesn't run
+ * and process.env values are undefined.
+ *
+ * @internal
+ */
+const SDK_NAME = "@aws/durable-execution-sdk-js";
+const SDK_VERSION = "1.0.3";
+
 let defaultLambdaClient;
 /**
  * Durable execution client which uses an API-based LambdaClient
@@ -4214,6 +4266,7 @@ class DurableExecutionApiClient {
         if (!client) {
             if (!defaultLambdaClient) {
                 defaultLambdaClient = new clientLambda.LambdaClient({
+                    customUserAgent: [[SDK_NAME, SDK_VERSION]],
                     requestHandler: {
                         connectionTimeout: 5000,
                         socketTimeout: 50000,
@@ -4412,8 +4465,9 @@ async function runHandler(event, context, executionContext, durableExecutionMode
     const durableContext = createDurableContext(executionContext, context, durableExecutionMode, 
     // Default logger may not have the same type as Logger, but we should always provide a default logger even if the user overrides it
     createDefaultLogger(), undefined, durableExecution);
-    // Extract customerHandlerEvent from the original event
-    const initialExecutionEvent = event.InitialExecutionState.Operations?.[0];
+    // Extract customerHandlerEvent from the complete operations array (after pagination)
+    // This ensures we get the full payload even for large payloads that are paginated
+    const initialExecutionEvent = executionContext._stepData[Object.keys(executionContext._stepData)[0]];
     const customerHandlerEvent = JSON.parse(initialExecutionEvent?.ExecutionDetails?.InputPayload ?? "{}");
     try {
         log("🎯", `Starting handler execution, handler event: ${customerHandlerEvent}`);