cloudstructs 0.12.8 → 0.12.10

package/assets/ssl-server-test/analyze.lambda/index.js

@@ -6923,6 +6923,8 @@ var StepInterruptedError = class extends Error {
     this.name = "StepInterruptedError";
   }
 };
+var CHECKPOINT_TERMINATION_COOLDOWN_MS = 20;
+var MAX_POLL_DURATION_MS = 15 * 60 * 1e3;
 var DurableOperationError = class extends Error {
   cause;
   errorData;
@@ -7433,7 +7435,8 @@ var createInvokeHandler = (context, checkpoint, createStepId, parentId, checkAnd
           Name: name,
           Payload: serializedPayload,
           ChainedInvokeOptions: {
-            FunctionName: funcId
+            FunctionName: funcId,
+            ...config?.tenantId && { TenantId: config.tenantId }
           }
         });
       }
@@ -8401,6 +8404,9 @@ var BatchResultImpl = class {
   }
 };
 function restoreBatchResult(data) {
+  if (data instanceof BatchResultImpl) {
+    return data;
+  }
   if (data && typeof data === "object" && "all" in data && Array.isArray(data.all)) {
     const serializedData = data;
     const restoredItems = serializedData.all.map((item) => ({
@@ -8661,7 +8667,12 @@ var ConcurrencyController = class {
           tryStartNext();
         }
       };
-      tryStartNext();
+      if (items.length === 0) {
+        log("\u{1F389}", `${this.operationName} completed with no items`);
+        resolve(new BatchResultImpl([], getCompletionReason(0)));
+      } else {
+        tryStartNext();
+      }
     });
   }
 };
@@ -8779,7 +8790,7 @@ var getStepData = (stepData, stepId) => {
   return stepData[hashedId];
 };
 var DurableContextImpl = class {
-  executionContext;
+  _executionContext;
   lambdaContext;
   _stepPrefix;
   _stepCounter = 0;
@@ -8791,8 +8802,9 @@ var DurableContextImpl = class {
   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;
@@ -8800,6 +8812,9 @@ var DurableContextImpl = class {
     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) => {
@@ -8811,9 +8826,9 @@ var DurableContextImpl = class {
       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" ? void 0 : hashId(activeContext.contextId)
         };
         if (activeContext?.attempt !== void 0) {
@@ -8884,7 +8899,7 @@ var DurableContextImpl = class {
   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;
       }
@@ -8893,14 +8908,14 @@ var DurableContextImpl = class {
   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 !== import_client_lambda.OperationStatus.SUCCEEDED && stepData.Status !== import_client_lambda.OperationStatus.FAILED);
     return wasInReplayMode && wasNotFinished;
   }
   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 !== import_client_lambda.OperationStatus.SUCCEEDED && nextStepData.Status !== import_client_lambda.OperationStatus.FAILED) {
         return new Promise(() => {
         });
@@ -8915,16 +8930,16 @@ var DurableContextImpl = class {
     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,
@@ -8934,10 +8949,10 @@ var DurableContextImpl = class {
     });
   }
   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._executionContext,
         this.checkpoint,
         this.lambdaContext,
         this.createStepId.bind(this),
@@ -8950,9 +8965,9 @@ var DurableContextImpl = class {
     });
   }
   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);
     });
   }
@@ -8982,44 +8997,44 @@ var DurableContextImpl = class {
     }
   }
   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 === void 0 ? waitForConditionHandler(nameOrCheckFunc, checkFuncOrConfig, maybeConfig) : waitForConditionHandler(nameOrCheckFunc, checkFuncOrConfig);
     });
   }
   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);
       promise?.catch(() => {
       });
@@ -9046,6 +9061,13 @@ var CheckpointUnrecoverableExecutionError = class extends UnrecoverableExecution
   }
 };
 var STEP_DATA_UPDATED_EVENT = "stepDataUpdated";
+var TERMINAL_STATUSES = [
+  import_client_lambda.OperationStatus.SUCCEEDED,
+  import_client_lambda.OperationStatus.CANCELLED,
+  import_client_lambda.OperationStatus.FAILED,
+  import_client_lambda.OperationStatus.STOPPED,
+  import_client_lambda.OperationStatus.TIMED_OUT
+];
 var CheckpointManager = class _CheckpointManager {
   durableExecutionArn;
   stepData;
@@ -9061,6 +9083,7 @@ var CheckpointManager = class _CheckpointManager {
   queueCompletionResolver = null;
   MAX_PAYLOAD_SIZE = 750 * 1024;
   // 750KB in bytes
+  MAX_ITEMS_IN_BATCH = 250;
   isTerminating = false;
   static textEncoder = new TextEncoder();
   // Operation lifecycle tracking
@@ -9068,7 +9091,6 @@ var CheckpointManager = 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;
@@ -9212,7 +9234,7 @@ var CheckpointManager = class _CheckpointManager {
     while (this.queue.length > 0) {
       const nextItem = this.queue[0];
       const itemSize = _CheckpointManager.textEncoder.encode(JSON.stringify(nextItem)).length;
-      if (currentSize + itemSize > this.MAX_PAYLOAD_SIZE && batch.length > 0) {
+      if ((currentSize + itemSize > this.MAX_PAYLOAD_SIZE || batch.length >= this.MAX_ITEMS_IN_BATCH) && batch.length > 0) {
         break;
       }
       this.queue.shift();
@@ -9380,6 +9402,10 @@ var CheckpointManager = class _CheckpointManager {
     if (op.state !== OperationLifecycleState.RETRY_WAITING) {
       throw new Error(`Operation ${stepId} must be in RETRY_WAITING state, got ${op.state}`);
     }
+    const stepData = this.stepData[hashId(stepId)];
+    if (stepData?.Status && TERMINAL_STATUSES.includes(stepData.Status)) {
+      return Promise.resolve();
+    }
     this.startTimerWithPolling(stepId, op.endTimestamp);
     return new Promise((resolve) => {
       op.resolver = resolve;
@@ -9393,6 +9419,10 @@ var CheckpointManager = class _CheckpointManager {
     if (op.state !== OperationLifecycleState.IDLE_AWAITED) {
       throw new Error(`Operation ${stepId} must be in IDLE_AWAITED state, got ${op.state}`);
     }
+    const stepData = this.stepData[hashId(stepId)];
+    if (stepData?.Status && TERMINAL_STATUSES.includes(stepData.Status)) {
+      return Promise.resolve();
+    }
     this.startTimerWithPolling(stepId, op.endTimestamp);
     return new Promise((resolve) => {
       op.resolver = resolve;
@@ -9436,24 +9466,24 @@ var CheckpointManager = class _CheckpointManager {
       op.resolver = void 0;
     }
   }
-  checkAndTerminate() {
+  /**
+   * Determines if the function should terminate.
+   * @returns TerminationReason if the function should terminate, or undefined if the function should not terminate
+   */
+  shouldTerminate() {
     if (this.queue.length > 0) {
-      this.abortTermination();
-      return;
+      return void 0;
     }
     if (this.isProcessing) {
-      this.abortTermination();
-      return;
+      return void 0;
     }
     if (this.forceCheckpointPromises.length > 0) {
-      this.abortTermination();
-      return;
+      return void 0;
     }
     const allOps = Array.from(this.operations.values());
     const hasExecuting = allOps.some((op) => op.state === OperationLifecycleState.EXECUTING);
     if (hasExecuting) {
-      this.abortTermination();
-      return;
+      return void 0;
     }
     for (const op of allOps) {
       if (op.state === OperationLifecycleState.RETRY_WAITING || op.state === OperationLifecycleState.IDLE_NOT_AWAITED || op.state === OperationLifecycleState.IDLE_AWAITED) {
@@ -9468,11 +9498,17 @@ var CheckpointManager = class _CheckpointManager {
     const remainingOps = Array.from(this.operations.values());
     const hasWaiting = remainingOps.some((op) => op.state === OperationLifecycleState.RETRY_WAITING || op.state === OperationLifecycleState.IDLE_NOT_AWAITED || op.state === OperationLifecycleState.IDLE_AWAITED);
     if (hasWaiting) {
-      const reason = this.determineTerminationReason(remainingOps);
-      this.scheduleTermination(reason);
-    } else {
-      this.abortTermination();
+      return this.determineTerminationReason(remainingOps);
     }
+    return void 0;
+  }
+  checkAndTerminate() {
+    const terminationReason = this.shouldTerminate();
+    if (terminationReason) {
+      this.scheduleTermination(terminationReason);
+      return;
+    }
+    this.abortTermination();
   }
   abortTermination() {
     if (this.terminationTimer) {
@@ -9490,11 +9526,16 @@ var CheckpointManager = class _CheckpointManager {
     this.terminationReason = reason;
     log("\u23F1\uFE0F", "Scheduling termination", {
       reason,
-      cooldownMs: this.TERMINATION_COOLDOWN_MS
+      cooldownMs: CHECKPOINT_TERMINATION_COOLDOWN_MS
     });
     this.terminationTimer = setTimeout(() => {
+      if (!this.shouldTerminate()) {
+        log("\u{1F504}", "Termination conditions no longer valid after cooldown, aborting termination");
+        this.abortTermination();
+        return;
+      }
       this.executeTermination(reason);
-    }, this.TERMINATION_COOLDOWN_MS);
+    }, CHECKPOINT_TERMINATION_COOLDOWN_MS);
   }
   executeTermination(reason) {
     log("\u{1F6D1}", "Executing termination after cooldown", { reason });
@@ -9520,6 +9561,9 @@ var CheckpointManager = class _CheckpointManager {
     if (endTimestamp) {
       const timestamp = endTimestamp instanceof Date ? endTimestamp : new Date(endTimestamp);
       delay = Math.max(0, timestamp.getTime() - Date.now());
+      if (delay > MAX_POLL_DURATION_MS) {
+        return;
+      }
     } else {
       delay = 1e3;
     }
@@ -9535,7 +9579,6 @@ var CheckpointManager = class _CheckpointManager {
     const op = this.operations.get(stepId);
     if (!op)
       return;
-    const MAX_POLL_DURATION_MS = 15 * 60 * 1e3;
     if (op.pollStartTime && Date.now() - op.pollStartTime > MAX_POLL_DURATION_MS) {
       log("\u23F1\uFE0F", `Max polling duration (15 min) exceeded for ${stepId}, stopping poll`);
       if (op.timer) {
@@ -9612,6 +9655,7 @@ var TerminationManager = class extends import_events.EventEmitter {
     };
   }
 };
+var FORMAT_OPTIONS = { breakLength: Infinity };
 function jsonErrorReplacer(_key, value) {
   if (value instanceof Error) {
     return Object.assign({
@@ -9644,11 +9688,11 @@ function formatDurableLogData(level, logData, ...messageParams) {
     try {
       return JSON.stringify(result, jsonErrorReplacer);
     } catch (_) {
-      result.message = import_node_util.default.format(result.message);
+      result.message = import_node_util.default.formatWithOptions(FORMAT_OPTIONS, result.message);
       return JSON.stringify(result);
     }
   }
-  result.message = import_node_util.default.format(...messageParams);
+  result.message = import_node_util.default.formatWithOptions(FORMAT_OPTIONS, ...messageParams);
   for (const param of messageParams) {
     if (param instanceof Error) {
       result.errorType = param?.constructor?.name ?? "UnknownError";
@@ -9770,6 +9814,8 @@ var DefaultLogger = class {
 var createDefaultLogger = (executionContext) => {
   return new DefaultLogger(executionContext);
 };
+var SDK_NAME = "@aws/durable-execution-sdk-js";
+var SDK_VERSION = "1.1.0";
 var defaultLambdaClient;
 var DurableExecutionApiClient = class {
   client;
@@ -9777,6 +9823,7 @@ var DurableExecutionApiClient = class {
     if (!client) {
       if (!defaultLambdaClient) {
         defaultLambdaClient = new import_client_lambda.LambdaClient({
+          customUserAgent: [[SDK_NAME, SDK_VERSION]],
           requestHandler: {
             connectionTimeout: 5e3,
             socketTimeout: 5e4,
@@ -9947,7 +9994,7 @@ async function runHandler(event, context, executionContext, durableExecutionMode
     void 0,
     durableExecution
   );
-  const initialExecutionEvent = event.InitialExecutionState.Operations?.[0];
+  const initialExecutionEvent = executionContext._stepData[Object.keys(executionContext._stepData)[0]];
   const customerHandlerEvent = JSON.parse(initialExecutionEvent?.ExecutionDetails?.InputPayload ?? "{}");
   try {
     log("\u{1F3AF}", `Starting handler execution, handler event: ${customerHandlerEvent}`);
@@ -10060,28 +10107,16 @@ async function runHandler(event, context, executionContext, durableExecutionMode
   }
 }
 function validateDurableExecutionEvent(event) {
-  try {
-    const eventObj = event;
-    if (!eventObj?.DurableExecutionArn || !eventObj?.CheckpointToken) {
-      throw new Error("Missing required durable execution fields");
-    }
-  } catch {
-    const msg = `Unexpected payload provided to start the durable execution. 
-Check your resource configurations to confirm the durability is set.`;
-    throw new Error(msg);
+  const eventObj = event;
+  if (!eventObj?.DurableExecutionArn || !eventObj?.CheckpointToken) {
+    throw new Error("Unexpected payload provided to start the durable execution.\nCheck your resource configurations to confirm the durability is set.");
   }
 }
 var withDurableExecution = (handler2, config) => {
   return async (event, context) => {
     validateDurableExecutionEvent(event);
     const { executionContext, durableExecutionMode, checkpointToken } = await initializeExecutionContext(event, context, config?.client);
-    let response = null;
-    try {
-      response = await runHandler(event, context, executionContext, durableExecutionMode, checkpointToken, handler2);
-      return response;
-    } catch (err) {
-      throw err;
-    }
+    return runHandler(event, context, executionContext, durableExecutionMode, checkpointToken, handler2);
   };
 };
 var DEFAULT_CONFIG = {