aws-local-stepfunctions 1.1.0 → 1.3.0

package/build/main.node.esm.js

@@ -97,6 +97,8 @@ function isPlainObj(value) {
   return !!value && Object.getPrototypeOf(value) === Object.prototype;
 }
 function sleep(ms, abortSignal) {
+  if (ms === 0)
+    return;
   return new Promise((resolve) => {
     if (abortSignal?.aborted) {
       return resolve();
@@ -122,6 +124,13 @@ function isRFC3339Timestamp(date) {
 function stringifyJSONValue(value) {
   return JSON.stringify(value);
 }
+function clamp(value, min, max) {
+  if (min && value < min)
+    return min;
+  if (max && value > max)
+    return max;
+  return value;
+}
 
 // src/stateMachine/jsonPath/JsonPath.ts
 import { JSONPath as jp } from "jsonpath-plus";
@@ -868,9 +877,18 @@ function processInputPath(path, input, context) {
   return jsonPathQuery(path, input, context);
 }
 function processPayloadTemplate(payloadTemplate, json, context) {
+  if (typeof payloadTemplate !== "object" || payloadTemplate === null) {
+    return payloadTemplate;
+  }
+  if (Array.isArray(payloadTemplate)) {
+    return payloadTemplate.map((value) => processPayloadTemplate(value, json, context));
+  }
   const resolvedProperties = Object.entries(payloadTemplate).map(([key, value]) => {
     let sanitizedKey = key;
     let resolvedValue = value;
+    if (Array.isArray(value)) {
+      resolvedValue = value.map((innerValue) => processPayloadTemplate(innerValue, json, context));
+    }
     if (isPlainObj(value)) {
       resolvedValue = processPayloadTemplate(value, json, context);
     }
@@ -1255,7 +1273,20 @@ var FailStateAction = class extends BaseStateAction {
     super(stateDefinition, stateName);
   }
   async execute(input, context, options) {
-    throw new FailStateError(this.stateDefinition.Error, this.stateDefinition.Cause);
+    const state = this.stateDefinition;
+    let error = state.Error;
+    let cause = state.Cause;
+    if (state.ErrorPath) {
+      error = jsonPathQuery(state.ErrorPath, input, context, {
+        constraints: [StringConstraint]
+      });
+    }
+    if (state.CausePath) {
+      cause = jsonPathQuery(state.CausePath, input, context, {
+        constraints: [StringConstraint]
+      });
+    }
+    throw new FailStateError(error, cause);
   }
 };
 
@@ -1270,6 +1301,31 @@ var ArrayConstraint = class extends BaseJSONPathConstraint {
   }
 };
 
+// src/stateMachine/jsonPath/constraints/IntegerConstraint.ts
+var IntegerConstraint = class extends BaseJSONPathConstraint {
+  test(value) {
+    if (!Number.isInteger(value)) {
+      throw new StatesRuntimeError(
+        `Path expression '${this.pathExpression}' evaluated to ${stringifyJSONValue(value)}, but expected an integer`
+      );
+    }
+  }
+  static greaterThanOrEqual(n) {
+    return class extends this {
+      test(value) {
+        super.test(value);
+        if (value < n) {
+          throw new StatesRuntimeError(
+            `Path expression '${this.pathExpression}' evaluated to ${stringifyJSONValue(
+              value
+            )}, but expected an integer >= ${n}`
+          );
+        }
+      }
+    };
+  }
+};
+
 // src/stateMachine/stateActions/MapStateAction.ts
 import pLimit from "p-limit";
 var DEFAULT_MAX_CONCURRENCY = 40;
@@ -1294,8 +1350,9 @@ var MapStateAction = class extends BaseStateAction {
         Value: item
       }
     };
-    if (state.Parameters) {
-      paramValue = processPayloadTemplate(state.Parameters, input, context);
+    if (state.Parameters || state.ItemSelector) {
+      const parameters = state.ItemSelector ?? state.Parameters;
+      paramValue = processPayloadTemplate(parameters, input, context);
     }
     const execution = stateMachine.run(paramValue ?? item, options.runOptions);
     this.executionAbortFuncs.push(execution.abort);
@@ -1313,11 +1370,19 @@ var MapStateAction = class extends BaseStateAction {
     if (!Array.isArray(items)) {
       throw new StatesRuntimeError("Input of Map state must be an array or ItemsPath property must point to an array");
     }
-    const iteratorStateMachine = new StateMachine(state.Iterator, {
+    const iteratorDefinition = state.ItemProcessor ?? state.Iterator;
+    const iteratorStateMachine = new StateMachine(iteratorDefinition, {
       ...options.stateMachineOptions,
       validationOptions: { noValidate: true }
     });
-    const limit = pLimit(state.MaxConcurrency || DEFAULT_MAX_CONCURRENCY);
+    let maxConcurrency = state.MaxConcurrency;
+    if (state.MaxConcurrencyPath) {
+      maxConcurrency = jsonPathQuery(state.MaxConcurrencyPath, input, context, {
+        constraints: [IntegerConstraint.greaterThanOrEqual(0)],
+        ignoreDefinedValueConstraint: true
+      });
+    }
+    const limit = pLimit(maxConcurrency || DEFAULT_MAX_CONCURRENCY);
     const processedItemsPromise = items.map(
       (item, i) => limit(() => this.processItem(iteratorStateMachine, item, input, context, i, options))
     );
@@ -1403,6 +1468,14 @@ var SucceedStateAction = class extends BaseStateAction {
   }
 };
 
+// src/error/predefined/StatesTimeoutError.ts
+var StatesTimeoutError = class extends RuntimeError {
+  constructor() {
+    super("States.Timeout");
+    this.name = "States.Timeout";
+  }
+};
+
 // src/aws/LambdaClient.ts
 import { LambdaClient as AWSLambdaClient, InvokeCommand } from "@aws-sdk/client-lambda";
 import { fromCognitoIdentityPool } from "@aws-sdk/credential-providers";
@@ -1486,41 +1559,47 @@ var LambdaClient = class {
 var TaskStateAction = class extends BaseStateAction {
   constructor(stateDefinition, stateName) {
     super(stateDefinition, stateName);
+    this.timeoutAbortController = new AbortController();
+  }
+  createTimeoutPromise(input, context) {
+    const state = this.stateDefinition;
+    if (!state.TimeoutSeconds && !state.TimeoutSecondsPath)
+      return;
+    let timeout;
+    if (state.TimeoutSeconds) {
+      timeout = state.TimeoutSeconds;
+    } else if (state.TimeoutSecondsPath) {
+      timeout = jsonPathQuery(state.TimeoutSecondsPath, input, context, {
+        constraints: [IntegerConstraint.greaterThanOrEqual(1)]
+      });
+    }
+    return new Promise((_, reject) => {
+      const handleTimeoutAbort = () => clearTimeout(timeoutId);
+      const timeoutId = setTimeout(() => {
+        this.timeoutAbortController.signal.removeEventListener("abort", handleTimeoutAbort);
+        reject(new StatesTimeoutError());
+      }, timeout * 1e3);
+      this.timeoutAbortController.signal.addEventListener("abort", handleTimeoutAbort, { once: true });
+    });
   }
   async execute(input, context, options) {
     const state = this.stateDefinition;
+    const racingPromises = [];
+    const timeoutPromise = this.createTimeoutPromise(input, context);
     if (options.overrideFn) {
-      const result2 = await options.overrideFn(input);
-      return this.buildExecutionResult(result2);
+      const resultPromise = options.overrideFn(input);
+      racingPromises.push(resultPromise);
+    } else {
+      const lambdaClient = new LambdaClient(options.awsConfig);
+      const resultPromise = lambdaClient.invokeFunction(state.Resource, input);
+      racingPromises.push(resultPromise);
     }
-    const lambdaClient = new LambdaClient(options.awsConfig);
-    const result = await lambdaClient.invokeFunction(state.Resource, input);
-    return this.buildExecutionResult(result);
-  }
-};
-
-// src/stateMachine/jsonPath/constraints/IntegerConstraint.ts
-var IntegerConstraint = class extends BaseJSONPathConstraint {
-  test(value) {
-    if (!Number.isInteger(value)) {
-      throw new StatesRuntimeError(
-        `Path expression '${this.pathExpression}' evaluated to ${stringifyJSONValue(value)}, but expected an integer`
-      );
+    if (timeoutPromise) {
+      racingPromises.push(timeoutPromise);
     }
-  }
-  static greaterThanOrEqual(n) {
-    return class extends this {
-      test(value) {
-        super.test(value);
-        if (value < n) {
-          throw new StatesRuntimeError(
-            `Path expression '${this.pathExpression}' evaluated to ${stringifyJSONValue(
-              value
-            )}, but expected an integer >= ${n}`
-          );
-        }
-      }
-    };
+    const result = await Promise.race(racingPromises);
+    this.timeoutAbortController.abort();
+    return this.buildExecutionResult(result);
   }
 };
 
@@ -1560,19 +1639,12 @@ var WaitStateAction = class extends BaseStateAction {
   }
 };
 
-// src/error/predefined/StatesTimeoutError.ts
-var StatesTimeoutError = class extends RuntimeError {
-  constructor() {
-    super("States.Timeout");
-    this.name = "States.Timeout";
-  }
-};
-
 // src/stateMachine/StateExecutor.ts
 import cloneDeep2 from "lodash/cloneDeep.js";
 var DEFAULT_MAX_ATTEMPTS = 3;
 var DEFAULT_INTERVAL_SECONDS = 1;
 var DEFAULT_BACKOFF_RATE = 2;
+var DEFAULT_JITTER_STRATEGY = "NONE";
 var WILDCARD_ERROR = "States.ALL";
 var TASK_STATE_WILDCARD_ERROR = "States.TaskFailed";
 var StateExecutor = class {
@@ -1620,7 +1692,10 @@ var StateExecutor = class {
         input,
         error
       );
-      const { shouldRetry, waitTimeBeforeRetry, retrierIndex } = this.shouldRetry(error);
+      const { shouldRetry, waitTimeBeforeRetry, retrierIndex } = this.shouldRetry(
+        error,
+        options.runOptions?.overrides?.retryIntervalOverrides
+      );
       if (shouldRetry) {
         const stateDefinition = this.stateDefinition;
         await sleep(waitTimeBeforeRetry, options.abortSignal);
@@ -1679,17 +1754,31 @@ var StateExecutor = class {
   /**
    * Decide whether this state should be retried, according to the `Retry` field.
    */
-  shouldRetry(error) {
+  shouldRetry(error, retryIntervalOverrides) {
     if (!("Retry" in this.stateDefinition)) {
       return { shouldRetry: false };
     }
     for (let i = 0; i < this.stateDefinition.Retry.length; i++) {
       const retrier = this.stateDefinition.Retry[i];
+      let intervalOverride = null;
+      if (retryIntervalOverrides?.[this.stateName] !== void 0) {
+        const override = retryIntervalOverrides[this.stateName];
+        if (typeof override === "number") {
+          intervalOverride = override / 1e3;
+        } else if (override[i] !== void 0 && override[i] >= 0) {
+          intervalOverride = override[i] / 1e3;
+        }
+      }
+      const jitterStrategy = retrier.JitterStrategy ?? DEFAULT_JITTER_STRATEGY;
       const maxAttempts = retrier.MaxAttempts ?? DEFAULT_MAX_ATTEMPTS;
       const intervalSeconds = retrier.IntervalSeconds ?? DEFAULT_INTERVAL_SECONDS;
       const backoffRate = retrier.BackoffRate ?? DEFAULT_BACKOFF_RATE;
-      const waitTimeBeforeRetry = intervalSeconds * Math.pow(backoffRate, this.retrierAttempts[i]) * 1e3;
+      const waitInterval = intervalOverride ?? intervalSeconds * Math.pow(backoffRate, this.retrierAttempts[i]);
       const retryable = error.isRetryable ?? true;
+      let waitTimeBeforeRetry = clamp(waitInterval, 0, retrier.MaxDelaySeconds) * 1e3;
+      if (jitterStrategy === "FULL" && intervalOverride === null) {
+        waitTimeBeforeRetry = getRandomNumber(0, waitTimeBeforeRetry);
+      }
       for (const retrierError of retrier.ErrorEquals) {
         const isErrorMatch = retrierError === error.name;
         const isErrorWildcard = retrierError === WILDCARD_ERROR;
@@ -2160,7 +2249,14 @@ var StateMachine = class {
    */
   async execute(input, options, cleanupFn) {
     options.eventLogger.dispatchExecutionStartedEvent(input);
-    const context = options.runOptions?.context ?? {};
+    const context = {
+      ...options.runOptions?.context,
+      Execution: {
+        ...options.runOptions?.context?.Execution,
+        Input: input,
+        StartTime: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
     let currState = this.definition.States[this.definition.StartAt];
     let currStateName = this.definition.StartAt;
     let currInput = cloneDeep3(input);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aws-local-stepfunctions",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Execute an AWS Step Function state machine locally",
   "keywords": [
     "aws",
@@ -53,14 +53,14 @@
   },
   "devDependencies": {
     "@tsconfig/node16-strictest": "^1.0.4",
-    "@types/crypto-js": "^4.1.2",
-    "@types/jest": "^29.5.4",
-    "@types/lodash": "^4.14.198",
-    "@types/node": "^18.17.15",
-    "@types/picomatch": "^2.3.0",
+    "@types/crypto-js": "^4.2.1",
+    "@types/jest": "^29.5.11",
+    "@types/lodash": "^4.14.202",
+    "@types/node": "^18.19.3",
+    "@types/picomatch": "^2.3.3",
     "@typescript-eslint/eslint-plugin": "^5.62.0",
     "@typescript-eslint/parser": "^5.62.0",
-    "eslint": "^8.49.0",
+    "eslint": "^8.55.0",
     "eslint-config-prettier": "^8.10.0",
     "eslint-plugin-prettier": "^4.2.1",
     "prettier": "^2.8.8",
@@ -69,11 +69,11 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "@aws-sdk/client-lambda": "^3.409.0",
-    "@aws-sdk/credential-providers": "^3.409.0",
-    "asl-validator": "^3.8.1",
-    "commander": "^11.0.0",
-    "crypto-js": "^4.1.1",
+    "@aws-sdk/client-lambda": "^3.470.0",
+    "@aws-sdk/credential-providers": "^3.470.0",
+    "asl-validator": "^3.8.2",
+    "commander": "^11.1.0",
+    "crypto-js": "^4.2.0",
     "jsonpath-plus": "^7.2.0",
     "lodash": "^4.17.21",
     "p-limit": "^3.1.0",