aws-local-stepfunctions 0.6.0 → 0.7.0

package/README.md

@@ -16,6 +16,14 @@ This package lets you run AWS Step Functions completely locally, both in Node.js
 - [API](#api)
   - [Constructor](#constructor-new-statemachinedefinition-statemachineoptions)
   - [StateMachine.run](#statemachineruninput-options)
+- [CLI](#cli)
+  - [Basic usage](#basic-usage)
+  - [Passing input from stdin](#passing-input-from-stdin)
+  - [Overriding Task and Wait states](#overriding-task-and-wait-states)
+    - [Task state override](#task-state-override)
+    - [Wait state override](#wait-state-override)
+  - [Disabling ASL validations](#disabling-asl-validations)
+  - [Exit codes](#exit-codes)
 - [Examples](#examples)
 - [License](#license)
 
@@ -49,7 +57,7 @@ import { StateMachine } from 'aws-local-stepfunctions';
 
 You can import the bundled package directly into a browser script as an ES module, from one of the following CDNs:
 
-> NOTE: The following examples will import the latest package version. Refer to the CDNs websites to know about other ways in which you can specify the package URL (for example, to import a specific version).
+> NOTE: The following examples will import the latest package version. Refer to the CDNs websites to know about other ways in which you can specify the package URL (for example, to import a specific version or a minified version).
 
 #### [unpkg](https://unpkg.com/)
 
@@ -122,7 +130,7 @@ Each execution is independent of all others, meaning that you can concurrently c
 - `options?`:
   - `overrides?`: An object to override the behavior of certain states:
     - `taskResourceLocalHandlers?`: An [object that overrides](/docs/feature-support.md#task-state-resource-override) the resource of the specified `Task` states to run a local function.
-    - `waitTimeOverrides?`: An [object that overrides](/docs/feature-support.md#wait-state-duration-override) the wait duration of the specified `Wait` states. The specifed override duration should be in milliseconds.
+    - `waitTimeOverrides?`: An [object that overrides](/docs/feature-support.md#wait-state-duration-override) the wait duration of the specified `Wait` states. The specified override duration should be in milliseconds.
   - `noThrowOnAbort?`: If this option is set to `true`, aborting the execution will simply return `null` as result instead of throwing.
 
 #### Basic example:
@@ -149,6 +157,167 @@ const result = await execution.result; // wait until the execution finishes to g
 console.log(result); // log the result of the execution
 ```
 
+## CLI
+
+In addition to the JavaScript API, `aws-local-stepfunctions` also provides a command-line interface. The CLI allows you to run one or several executions without having to create a Node.js script.
+
+To use the CLI as a global shell command, you need to install the package globally:
+
+```sh
+npm install -g aws-local-stepfunctions
+```
+
+After installing the package, the command `local-sfn` will be available in your shell.
+
+### Basic usage
+
+The simplest way to use the CLI is by passing either the `-d, --definition` or the `-f, --definition-file` option, along with the input(s) for the state machine. For example:
+
+```sh
+local-sfn \
+  -f state-machine.json \
+  '{ "num1": 1, "num2": 2 }' \
+  '{ "num1": 3, "num2": 4 }' \
+  '{ "num1": 5, "num2": 6 }'
+```
+
+This command would execute the state machine defined in file `state-machine.json` with `'{ "num1": 1, "num2": 2 }'`, `'{ "num1": 3, "num2": 4 }'`, and `'{ "num1": 5, "num2": 6 }'` as inputs. Each input corresponds to a state machine execution, and each execution is run independently, so the failure of one execution doesn't mean the failure of all of the other executions.
+
+Now, suppose the state machine in file `state-machine.json` is defined as a single `Task` state that calls a Lambda function that adds `num1` and `num2`:
+
+<a id="cli-state-machine"></a>
+
+```json
+{
+  "StartAt": "AddNumbers",
+  "States": {
+    "AddNumbers": {
+      "Type": "Task",
+      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:AddNumbers",
+      "End": true
+    }
+  }
+}
+```
+
+Then, the output of the `local-sfn` command above may look something like this:
+
+```sh
+3
+7
+11
+```
+
+Note that each line of the output corresponds to the result of each input, in the same order that the inputs were given to the command.
+
+### Passing input from stdin
+
+`local-sfn` can also read the execution input from the standard input. For example, assume you have the following text file, called `inputs.txt`, and you want to pass the contents of the file as inputs to `local-sfn`:
+
+```txt
+{ "num1": 1, "num2": 2 }
+{ "num1": 3, "num2": 4 }
+{ "num1": 5, "num2": 6 }
+```
+
+You can then run the following command to pass the inputs of the text file to `local-sfn`:
+
+```sh
+cat inputs.txt | local-sfn -f state-machine.json
+```
+
+Alternatively, using input redirection:
+
+```sh
+local-sfn -f state-machine.json < inputs.txt
+```
+
+When reading from stdin, `local-sfn` will take each line and use it as an input. Hence, to avoid any parsing errors, make sure the output of the command you're piping into `local-sfn` prints each input in a new line.
+
+### Overriding Task and Wait states
+
+As explained in the Feature support document, it's possible to override the default actions of [`Task` states](/docs/feature-support.md#task-state-resource-override) and [`Wait` states](/docs/feature-support.md#wait-state-duration-override).
+
+#### Task state override
+
+To override a `Task` state, pass the `-t, --override-task` option. This option takes as value the name of the `Task` state you want to override, and a path to a script or program that will be executed instead of the resource specified in the state definition. The state name and the path must be separated by a colon `:`.
+
+Using the same [state machine definition](#cli-state-machine) as before, if you wanted to override the `AddNumbers` state to run a custom script, you can do it like this:
+
+```sh
+local-sfn -f state-machine.json -t AddNumbers:./override.sh '{ "num1": 1, "num2": 2 }'
+```
+
+This command would run the state machine, but instead of invoking the Lambda function specified in the `Resource` field of the `AddNumbers` state, the `override.sh` script would be executed.
+
+Now, suppose the `override.sh` script is defined like this:
+
+```sh
+#!/bin/sh
+
+TASK_INPUT=$1 # First argument is the input to the overridden Task state
+echo "$TASK_INPUT" | jq '.num1 + .num2' # Use jq to add "num1" and "num2", and print result to stdout
+```
+
+When overriding a `Task` state, the overriding executable will be passed the input to the `Task` state as first argument, which can then be used to compute the task result. Similarly, the executable must print the task result as a JSON value to the standard output, so `local-sfn` can then read stdout and use the value as the result of the `Task` state. If the executable terminates with an exit code different from `0`, its standard error will be printed and the execution will be marked as a failure.
+
+Additionally, you can pass the `-t, --override-task` option multiple times, to override more than one `Task` state. For example:
+
+```sh
+local-sfn
+  -f state-machine.json \
+  -t AddNumbers:./override.sh \
+  -t SendRequest:./request.py \
+  -t ProcessImage:./proc_image \
+  '{ "num1": 1, "num2": 2 }'
+```
+
+This command would execute the state machine, and override `Task` states `AddNumbers`, `SendRequest`, and `ProcessImage` to run the `override.sh` shell script, the `request.py` Python script, and the `proc_image` program, respectively.
+
+#### Wait state override
+
+To override the duration of a `Wait` state, pass the `-w, --override-wait` option. This option takes as value the name of the `Wait` state you want to override, and a number that represents the amount in milliseconds that you want to pause the execution for. The state name and the milliseconds amount must be separated by a colon `:`.
+
+For example:
+
+```sh
+local-sfn -f state-machine.json -w WaitResponse:1500 '{ "num1": 1, "num2": 2 }'
+```
+
+This command would execute the state machine, and when entering the `WaitResponse` `Wait` state, the execution would be paused for 1500 milliseconds (1.5 seconds), disregarding the `Seconds`, `Timestamp`, `SecondsPath`, or `TimestampPath` fields that could've been specified in the definition of `WaitResponse`.
+
+In the same way as the `-t, --override-task` option, you can pass the `-w, --override-wait` option multiple times, to override more than one `Wait` state. For example:
+
+```sh
+local-sfn \
+  -f state-machine.json \
+  -w WaitResponse:1500 \
+  -w PauseUntilSignal:250 \
+  -w Delay:0 \
+  '{ "num1": 1, "num2": 2 }'
+```
+
+This command would execute the state machine, and override `Wait` states `WaitResponse` and `PauseUntilSignal` to pause the execution for 1500 and 250 milliseconds, respectively. The `Delay` state wouldn't be paused at all, since the override value is set to 0.
+
+### Disabling ASL validations
+
+Before attempting to run the state machine with the given inputs, the state machine definition itself is validated to check that:
+
+- JSONPath strings are valid.
+- ARNs in the `Resource` field of `Task` states are valid.
+
+If any of these two checks fail, `local-sfn` will print the validation error and exit. To suppress this behavior, you can pass the `--no-jsonpath-validation` option, to suppress JSONPath validation; and the `--no-arn-validation` option, to suppress ARN validation.
+
+### Exit codes
+
+`local-sfn` can terminate with the following exit codes:
+
+| Exit code | Explanation                                                                          |
+| :-------: | ------------------------------------------------------------------------------------ |
+|     0     | The state machine was executed, and all executions ran successfully.                 |
+|     1     | An error occurred before the state machine could be executed (e.g. a parsing error). |
+|     2     | The state machine was executed, but at least one execution had an error.             |
+
 ## Examples
 
 You can check more examples and options usage in the [examples](/examples) directory.

package/build/CLI.cjs

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli/CLI.ts
+var CLI_exports = {};
+__export(CLI_exports, {
+  makeProgram: () => makeProgram
+});
+module.exports = __toCommonJS(CLI_exports);
+var import_readline = __toESM(require("readline"), 1);
+var import_commander = require("commander");
+
+// package.json
+var version = "0.7.0";
+
+// src/cli/ArgumentParsers.ts
+var import_fs = require("fs");
+var import_child_process = require("child_process");
+
+// src/util/index.ts
+function tryJSONParse(jsonStr) {
+  try {
+    return JSON.parse(jsonStr);
+  } catch (error) {
+    return error;
+  }
+}
+
+// src/cli/ArgumentParsers.ts
+function parseDefinitionOption(command, definition) {
+  const jsonOrError = tryJSONParse(definition);
+  if (jsonOrError instanceof Error) {
+    command.error(
+      `error: parsing of state machine definition passed in option '-d, --definition <definition>' failed: ${jsonOrError.message}`,
+      {
+        exitCode: 1 /* PreExecutionFailure */
+      }
+    );
+  }
+  return jsonOrError;
+}
+function parseDefinitionFileOption(command, definitionFile) {
+  let file;
+  try {
+    file = (0, import_fs.readFileSync)(definitionFile).toString();
+  } catch (error) {
+    command.error(`error: ${error.message}`, { exitCode: 1 /* PreExecutionFailure */ });
+  }
+  const jsonOrError = tryJSONParse(file);
+  if (jsonOrError instanceof Error) {
+    command.error(
+      `error: parsing of state machine definition in file '${definitionFile}' failed: ${jsonOrError.message}`,
+      { exitCode: 1 /* PreExecutionFailure */ }
+    );
+  }
+  return jsonOrError;
+}
+function parseOverrideTaskOption(value, previous = {}) {
+  const [taskStateName, scriptPath] = value.split(":");
+  previous[taskStateName] = (input) => {
+    const spawnResult = (0, import_child_process.spawnSync)(scriptPath, [JSON.stringify(input)]);
+    if (spawnResult.error) {
+      throw new Error(
+        `Attempt to run task override '${scriptPath}' for state '${taskStateName}' failed: ${spawnResult.error.message}`
+      );
+    }
+    if (spawnResult.status !== 0) {
+      throw new Error(`${scriptPath} ('${taskStateName}'): ${spawnResult.stderr.toString()}`);
+    }
+    const overrideResult = spawnResult.stdout.toString();
+    const jsonOrError = tryJSONParse(overrideResult);
+    if (jsonOrError instanceof Error) {
+      throw new Error(
+        `Parsing of output '${overrideResult}' from task override '${scriptPath}' for state '${taskStateName}' failed: ${jsonOrError.message}`
+      );
+    }
+    return Promise.resolve(jsonOrError);
+  };
+  return previous;
+}
+function parseOverrideWaitOption(value, previous = {}) {
+  const [waitStateName, duration] = value.split(":");
+  previous[waitStateName] = Number(duration);
+  return previous;
+}
+function parseInputArguments(command, value, previous = []) {
+  const jsonOrError = tryJSONParse(value);
+  if (jsonOrError instanceof Error) {
+    command.error(`error: parsing of input value '${value}' failed: ${jsonOrError.message}`, {
+      exitCode: 1 /* PreExecutionFailure */
+    });
+  }
+  return previous.concat(jsonOrError);
+}
+
+// src/cli/CommandHandler.ts
+var import_main = require("./main.node.cjs");
+async function commandAction(inputs, options, command) {
+  let stateMachine;
+  try {
+    stateMachine = new import_main.StateMachine(options.definition ?? options.definitionFile, {
+      validationOptions: {
+        checkPaths: options.jsonpathValidation,
+        checkArn: options.arnValidation
+      }
+    });
+  } catch (error) {
+    command.error(`error: ${error.message}`);
+  }
+  const resultsPromises = inputs.map((input) => {
+    const { result } = stateMachine.run(input, {
+      overrides: {
+        taskResourceLocalHandlers: options.overrideTask,
+        waitTimeOverrides: options.overrideWait
+      }
+    });
+    return result;
+  });
+  const results = await Promise.allSettled(resultsPromises);
+  let exitCode = 0 /* Success */;
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      console.log(result.value);
+    } else {
+      exitCode = 2 /* StateMachineExecutionFailure */;
+      let msg = result.reason.message;
+      if (result.reason instanceof import_main.ExecutionTimeoutError) {
+        msg = "Execution timed out";
+      }
+      console.log(msg.trim());
+    }
+  }
+  process.exitCode = exitCode;
+}
+function preActionHook(thisCommand) {
+  const options = thisCommand.opts();
+  if (thisCommand.args.length === 0) {
+    thisCommand.help();
+  }
+  if (!options["definition"] && !options["definitionFile"]) {
+    thisCommand.error(
+      "error: missing either option '-d, --definition <definition>' or option '-f, --definition-file <path>'",
+      { exitCode: 1 /* PreExecutionFailure */ }
+    );
+  }
+}
+
+// src/cli/CLI.ts
+function makeProgram() {
+  const command = new import_commander.Command();
+  command.name("local-sfn").description(
+    `Execute an Amazon States Language state machine with the given inputs.
+The result of each execution will be output in a new line and in the same order as its corresponding input.`
+  ).helpOption("-h, --help", "Print help for command and exit.").configureHelp({ helpWidth: 80 }).addHelpText(
+    "after",
+    `
+Exit codes:
+  0	All executions ran successfully.
+  1	An error occurred before the state machine could be executed.
+  2	At least one execution had an error.
+
+Example calls:
+  $ local-sfn -f state-machine.json '{ "num1": 2, "num2": 2 }'
+  $ local-sfn -f state-machine.json -t SendRequest:./override.sh -w WaitResponse:2000 '{ "num1": 2, "num2": 2 }'
+  $ cat inputs.txt | local-sfn -f state-machine.json`
+  ).version(version, "-V, --version", "Print the version number and exit.").addOption(
+    new import_commander.Option("-d, --definition <definition>", "A JSON definition of a state machine.").conflicts("definition-file").argParser((value) => parseDefinitionOption(command, value))
+  ).addOption(
+    new import_commander.Option("-f, --definition-file <path>", "Path to a file containing a JSON state machine definition.").conflicts("definition").argParser((value) => parseDefinitionFileOption(command, value))
+  ).addOption(
+    new import_commander.Option(
+      "-t, --override-task <mapping>",
+      "Override a Task state to run an executable file or script, instead of calling the service specified in the 'Resource' field of the state definition. The mapping value has to be provided in the format [TaskStateToOverride]:[path/to/override/script]. The override script will be passed the input of the Task state as first argument, which can then be used to compute the task result. The script must print the task result as a JSON value to the standard output."
+    ).argParser(parseOverrideTaskOption)
+  ).addOption(
+    new import_commander.Option(
+      "-w, --override-wait <mapping>",
+      "Override a Wait state to pause for the specified amount of milliseconds, instead of pausing for the duration specified in the state definition. The mapping value has to be provided in the format [WaitStateToOverride]:[number]."
+    ).argParser(parseOverrideWaitOption)
+  ).addOption(
+    new import_commander.Option("--no-jsonpath-validation", "Disable validation of JSONPath strings in the state machine definition.")
+  ).addOption(new import_commander.Option("--no-arn-validation", "Disable validation of ARNs in the state machine definition.")).argument(
+    "[inputs...]",
+    "Input data for the state machine, can be any valid JSON value. Each input represents a state machine execution. If reading from the standard input, each line will be considered as an input.",
+    (value, previous) => parseInputArguments(command, value, previous)
+  ).hook("preAction", preActionHook).action(commandAction);
+  return command;
+}
+if (require.main === module) {
+  (async function() {
+    const program = makeProgram();
+    if (process.stdin.isTTY) {
+      await program.parseAsync();
+    } else {
+      const rl = import_readline.default.createInterface({
+        input: process.stdin
+      });
+      const stdin = [];
+      for await (const line of rl) {
+        stdin.push(line);
+      }
+      await program.parseAsync([...process.argv, ...stdin.filter((line) => line)]);
+    }
+  })();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  makeProgram
+});

package/build/main.browser.esm.js

@@ -19950,7 +19950,7 @@ function validateArgumentType(allowedTypes, argPosition, funcArg, funcName) {
     if (matchesAllowedType)
       break;
   }
-  const expectedType = allowedTypes.map((type) => `"${type}"`).join(" | ");
+  const expectedType = allowedTypes.map((type) => `'${type}'`).join(" | ");
   if (!matchesAllowedType) {
     throw new StatesRuntimeError(
       `Intrinsic function ${funcName} expected argument ${argPosition} to be of type ${expectedType}, but received ${typeof funcArg}`
@@ -19978,7 +19978,7 @@ function validateArgumentConstraints(argConstraints, argPosition, funcArg, funcN
       if (matchesAllConstraints)
         break;
     }
-    const expectedConstraints = argConstraints.map((constraint) => `"${constraint}"`).join(" | ");
+    const expectedConstraints = argConstraints.map((constraint) => `'${constraint}'`).join(" | ");
     if (!matchesAllConstraints) {
       throw new StatesRuntimeError(
         `Intrinsic function ${funcName} expected argument ${argPosition} to satisfy the following constraints: ${expectedConstraints}`
@@ -20600,7 +20600,7 @@ function processPayloadTemplate(payloadTemplate, json, context) {
     let sanitizedKey = key;
     let resolvedValue = value;
     if (isPlainObj(value)) {
-      resolvedValue = processPayloadTemplate(value, json);
+      resolvedValue = processPayloadTemplate(value, json, context);
     }
     if (key.endsWith(".$") && typeof value === "string") {
       sanitizedKey = key.replace(".$", "");
@@ -21048,7 +21048,10 @@ 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, options?.stateMachineOptions);
+    const iteratorStateMachine = new StateMachine(state.Iterator, {
+      ...options?.stateMachineOptions,
+      validationOptions: { _noValidate: true }
+    });
     const limit = (0, import_p_limit.default)(state.MaxConcurrency || DEFAULT_MAX_CONCURRENCY);
     const processedItemsPromise = items.map(
       (item, i3) => limit(() => this.processItem(iteratorStateMachine, item, input, context, i3, options))
@@ -21077,7 +21080,10 @@ var ParallelStateAction = class extends BaseStateAction {
     this.executionAbortFuncs = [];
   }
   processBranch(branch, input, context, options) {
-    const stateMachine = new StateMachine(branch, options?.stateMachineOptions);
+    const stateMachine = new StateMachine(branch, {
+      ...options?.stateMachineOptions,
+      validationOptions: { _noValidate: true }
+    });
     const execution = stateMachine.run(input, options?.runOptions);
     this.executionAbortFuncs.push(execution.abort);
     return execution.result;
@@ -27039,12 +27045,12 @@ var LambdaClient2 = class {
     if (config) {
       if (!config.region) {
         throw new StatesRuntimeError(
-          "`awsConfig` option was specified for state machine, but `region` property is not set"
+          "'awsConfig' option was specified for state machine, but 'region' property is not set"
         );
       }
       if (config.credentials) {
         const credentialsTypes = Object.keys(config.credentials);
-        const credentialsNames = credentialsTypes.map((name) => `\`${name}\``).join(", ");
+        const credentialsNames = credentialsTypes.map((name) => `'${name}'`).join(", ");
         if (credentialsTypes.length > 1) {
           throw new StatesRuntimeError(
             `More than one type of AWS credentials were specified: ${credentialsNames}. Only one type may be specified`
@@ -27078,7 +27084,7 @@ var LambdaClient2 = class {
     }
     if (invocationResult.FunctionError) {
       const errorResult = resultValue;
-      throw new FailStateError(errorResult.errorType, `Execution of Lambda function "${funcNameOrArn}" failed`);
+      throw new FailStateError(errorResult.errorType, `Execution of Lambda function '${funcNameOrArn}' failed`);
     }
     return resultValue;
   }
@@ -27389,6 +27395,7 @@ var StateExecutor = class {
 // src/stateMachine/StateMachine.ts
 var import_asl_validator = __toESM(require_validator(), 1);
 var import_cloneDeep3 = __toESM(require_cloneDeep(), 1);
+var DEFAULT_MAX_EXECUTION_TIMEOUT = 2147483647e-3;
 var StateMachine = class {
   /**
    * Constructs a new state machine.
@@ -27397,14 +27404,16 @@ var StateMachine = class {
    * These options also apply to state machines defined in the `Iterator` field of `Map` states and in the `Branches` field of `Parallel` states.
    */
   constructor(definition, stateMachineOptions) {
-    const { isValid, errorsText } = (0, import_asl_validator.default)(definition, {
-      checkArn: true,
-      checkPaths: true,
-      ...stateMachineOptions?.validationOptions
-    });
-    if (!isValid) {
-      throw new Error(`State machine definition is invalid, see error(s) below:
+    if (!stateMachineOptions?.validationOptions?._noValidate) {
+      const { isValid, errorsText } = (0, import_asl_validator.default)(definition, {
+        checkArn: true,
+        checkPaths: true,
+        ...stateMachineOptions?.validationOptions
+      });
+      if (!isValid) {
+        throw new Error(`State machine definition is invalid, see error(s) below:
  ${errorsText("\n")}`);
+      }
     }
     this.definition = definition;
     this.stateMachineOptions = stateMachineOptions;
@@ -27422,6 +27431,7 @@ var StateMachine = class {
    */
   run(input, options) {
     const abortController = new AbortController();
+    const timeoutSeconds = this.definition.TimeoutSeconds ?? DEFAULT_MAX_EXECUTION_TIMEOUT;
     let onAbortHandler;
     const settleOnAbort = new Promise((resolve, reject) => {
       if (options?.noThrowOnAbort) {
@@ -27431,25 +27441,27 @@ var StateMachine = class {
       }
       abortController.signal.addEventListener("abort", onAbortHandler);
     });
-    let rejectOnTimeout = null;
-    if (this.definition.TimeoutSeconds) {
-      rejectOnTimeout = new Promise((_, reject) => {
-        setTimeout(() => {
-          abortController.signal.removeEventListener("abort", onAbortHandler);
-          abortController.abort();
-          reject(new StatesTimeoutError());
-        }, this.definition.TimeoutSeconds * 1e3);
-      });
-    }
-    const executionResult = this.execute(input, {
-      stateMachineOptions: this.stateMachineOptions,
-      runOptions: options,
-      abortSignal: abortController.signal
+    let timeoutId;
+    const rejectOnTimeout = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        abortController.signal.removeEventListener("abort", onAbortHandler);
+        abortController.abort();
+        reject(new StatesTimeoutError());
+      }, timeoutSeconds * 1e3);
     });
-    const racingPromises = [executionResult, settleOnAbort];
-    if (rejectOnTimeout) {
-      racingPromises.push(rejectOnTimeout);
-    }
+    const executionResult = this.execute(
+      input,
+      {
+        stateMachineOptions: this.stateMachineOptions,
+        runOptions: options,
+        abortSignal: abortController.signal
+      },
+      () => {
+        abortController.signal.removeEventListener("abort", onAbortHandler);
+        clearTimeout(timeoutId);
+      }
+    );
+    const racingPromises = [executionResult, settleOnAbort, rejectOnTimeout];
     const result = Promise.race(racingPromises);
     return {
       abort: () => abortController.abort(),
@@ -27459,7 +27471,7 @@ var StateMachine = class {
   /**
    * Helper method that handles the execution of the machine states and the transitions between them.
    */
-  async execute(input, options) {
+  async execute(input, options, cleanupFn) {
     let currState = this.definition.States[this.definition.StartAt];
     let currStateName = this.definition.StartAt;
     let currInput = (0, import_cloneDeep3.default)(input);
@@ -27477,6 +27489,8 @@ var StateMachine = class {
       } while (!isEndState && !options.abortSignal.aborted);
     } catch (error) {
       throw new ExecutionError(error);
+    } finally {
+      cleanupFn();
     }
     return currResult;
   }

package/build/main.d.ts

@@ -1,5 +1,5 @@
 import { FromCognitoIdentityPoolParameters } from '@aws-sdk/credential-provider-cognito-identity/dist-types/fromCognitoIdentityPool';
-import { Credentials } from '@aws-sdk/types/dist-types/credentials';
+import { AwsCredentialIdentity } from '@aws-sdk/types/dist-types/identity/AwsCredentialIdentity';
 
 type StateType = 'Task' | 'Parallel' | 'Map' | 'Pass' | 'Wait' | 'Choice' | 'Succeed' | 'Fail';
 
@@ -197,7 +197,7 @@ interface AWSConfig {
     region: string;
     credentials?: {
         cognitoIdentityPool?: FromCognitoIdentityPoolParameters;
-        accessKeys?: Omit<Credentials, 'expiration'>;
+        accessKeys?: Omit<AwsCredentialIdentity, 'expiration'>;
     };
 }
 interface StateMachineOptions {

package/build/main.node.cjs

@@ -207,7 +207,7 @@ function validateArgumentType(allowedTypes, argPosition, funcArg, funcName) {
     if (matchesAllowedType)
       break;
   }
-  const expectedType = allowedTypes.map((type) => `"${type}"`).join(" | ");
+  const expectedType = allowedTypes.map((type) => `'${type}'`).join(" | ");
   if (!matchesAllowedType) {
     throw new StatesRuntimeError(
       `Intrinsic function ${funcName} expected argument ${argPosition} to be of type ${expectedType}, but received ${typeof funcArg}`
@@ -235,7 +235,7 @@ function validateArgumentConstraints(argConstraints, argPosition, funcArg, funcN
       if (matchesAllConstraints)
         break;
     }
-    const expectedConstraints = argConstraints.map((constraint) => `"${constraint}"`).join(" | ");
+    const expectedConstraints = argConstraints.map((constraint) => `'${constraint}'`).join(" | ");
     if (!matchesAllConstraints) {
       throw new StatesRuntimeError(
         `Intrinsic function ${funcName} expected argument ${argPosition} to satisfy the following constraints: ${expectedConstraints}`
@@ -857,7 +857,7 @@ function processPayloadTemplate(payloadTemplate, json, context) {
     let sanitizedKey = key;
     let resolvedValue = value;
     if (isPlainObj(value)) {
-      resolvedValue = processPayloadTemplate(value, json);
+      resolvedValue = processPayloadTemplate(value, json, context);
     }
     if (key.endsWith(".$") && typeof value === "string") {
       sanitizedKey = key.replace(".$", "");
@@ -1188,7 +1188,10 @@ 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, options?.stateMachineOptions);
+    const iteratorStateMachine = new StateMachine(state.Iterator, {
+      ...options?.stateMachineOptions,
+      validationOptions: { _noValidate: true }
+    });
     const limit = (0, import_p_limit.default)(state.MaxConcurrency || DEFAULT_MAX_CONCURRENCY);
     const processedItemsPromise = items.map(
       (item, i) => limit(() => this.processItem(iteratorStateMachine, item, input, context, i, options))
@@ -1217,7 +1220,10 @@ var ParallelStateAction = class extends BaseStateAction {
     this.executionAbortFuncs = [];
   }
   processBranch(branch, input, context, options) {
-    const stateMachine = new StateMachine(branch, options?.stateMachineOptions);
+    const stateMachine = new StateMachine(branch, {
+      ...options?.stateMachineOptions,
+      validationOptions: { _noValidate: true }
+    });
     const execution = stateMachine.run(input, options?.runOptions);
     this.executionAbortFuncs.push(execution.abort);
     return execution.result;
@@ -1273,12 +1279,12 @@ var LambdaClient = class {
     if (config) {
       if (!config.region) {
         throw new StatesRuntimeError(
-          "`awsConfig` option was specified for state machine, but `region` property is not set"
+          "'awsConfig' option was specified for state machine, but 'region' property is not set"
         );
       }
       if (config.credentials) {
         const credentialsTypes = Object.keys(config.credentials);
-        const credentialsNames = credentialsTypes.map((name) => `\`${name}\``).join(", ");
+        const credentialsNames = credentialsTypes.map((name) => `'${name}'`).join(", ");
         if (credentialsTypes.length > 1) {
           throw new StatesRuntimeError(
             `More than one type of AWS credentials were specified: ${credentialsNames}. Only one type may be specified`
@@ -1312,7 +1318,7 @@ var LambdaClient = class {
     }
     if (invocationResult.FunctionError) {
       const errorResult = resultValue;
-      throw new FailStateError(errorResult.errorType, `Execution of Lambda function "${funcNameOrArn}" failed`);
+      throw new FailStateError(errorResult.errorType, `Execution of Lambda function '${funcNameOrArn}' failed`);
     }
     return resultValue;
   }
@@ -1623,6 +1629,7 @@ var StateExecutor = class {
 // src/stateMachine/StateMachine.ts
 var import_asl_validator = __toESM(require("asl-validator"), 1);
 var import_cloneDeep3 = __toESM(require("lodash/cloneDeep.js"), 1);
+var DEFAULT_MAX_EXECUTION_TIMEOUT = 2147483647e-3;
 var StateMachine = class {
   /**
    * Constructs a new state machine.
@@ -1631,14 +1638,16 @@ var StateMachine = class {
    * These options also apply to state machines defined in the `Iterator` field of `Map` states and in the `Branches` field of `Parallel` states.
    */
   constructor(definition, stateMachineOptions) {
-    const { isValid, errorsText } = (0, import_asl_validator.default)(definition, {
-      checkArn: true,
-      checkPaths: true,
-      ...stateMachineOptions?.validationOptions
-    });
-    if (!isValid) {
-      throw new Error(`State machine definition is invalid, see error(s) below:
+    if (!stateMachineOptions?.validationOptions?._noValidate) {
+      const { isValid, errorsText } = (0, import_asl_validator.default)(definition, {
+        checkArn: true,
+        checkPaths: true,
+        ...stateMachineOptions?.validationOptions
+      });
+      if (!isValid) {
+        throw new Error(`State machine definition is invalid, see error(s) below:
  ${errorsText("\n")}`);
+      }
     }
     this.definition = definition;
     this.stateMachineOptions = stateMachineOptions;
@@ -1656,6 +1665,7 @@ var StateMachine = class {
    */
   run(input, options) {
     const abortController = new AbortController();
+    const timeoutSeconds = this.definition.TimeoutSeconds ?? DEFAULT_MAX_EXECUTION_TIMEOUT;
     let onAbortHandler;
     const settleOnAbort = new Promise((resolve, reject) => {
       if (options?.noThrowOnAbort) {
@@ -1665,25 +1675,27 @@ var StateMachine = class {
       }
       abortController.signal.addEventListener("abort", onAbortHandler);
     });
-    let rejectOnTimeout = null;
-    if (this.definition.TimeoutSeconds) {
-      rejectOnTimeout = new Promise((_, reject) => {
-        setTimeout(() => {
-          abortController.signal.removeEventListener("abort", onAbortHandler);
-          abortController.abort();
-          reject(new StatesTimeoutError());
-        }, this.definition.TimeoutSeconds * 1e3);
-      });
-    }
-    const executionResult = this.execute(input, {
-      stateMachineOptions: this.stateMachineOptions,
-      runOptions: options,
-      abortSignal: abortController.signal
+    let timeoutId;
+    const rejectOnTimeout = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        abortController.signal.removeEventListener("abort", onAbortHandler);
+        abortController.abort();
+        reject(new StatesTimeoutError());
+      }, timeoutSeconds * 1e3);
     });
-    const racingPromises = [executionResult, settleOnAbort];
-    if (rejectOnTimeout) {
-      racingPromises.push(rejectOnTimeout);
-    }
+    const executionResult = this.execute(
+      input,
+      {
+        stateMachineOptions: this.stateMachineOptions,
+        runOptions: options,
+        abortSignal: abortController.signal
+      },
+      () => {
+        abortController.signal.removeEventListener("abort", onAbortHandler);
+        clearTimeout(timeoutId);
+      }
+    );
+    const racingPromises = [executionResult, settleOnAbort, rejectOnTimeout];
     const result = Promise.race(racingPromises);
     return {
       abort: () => abortController.abort(),
@@ -1693,7 +1705,7 @@ var StateMachine = class {
   /**
    * Helper method that handles the execution of the machine states and the transitions between them.
    */
-  async execute(input, options) {
+  async execute(input, options, cleanupFn) {
     let currState = this.definition.States[this.definition.StartAt];
     let currStateName = this.definition.StartAt;
     let currInput = (0, import_cloneDeep3.default)(input);
@@ -1711,6 +1723,8 @@ var StateMachine = class {
       } while (!isEndState && !options.abortSignal.aborted);
     } catch (error) {
       throw new ExecutionError(error);
+    } finally {
+      cleanupFn();
     }
     return currResult;
   }

package/build/main.node.esm.js

@@ -169,7 +169,7 @@ function validateArgumentType(allowedTypes, argPosition, funcArg, funcName) {
     if (matchesAllowedType)
       break;
   }
-  const expectedType = allowedTypes.map((type) => `"${type}"`).join(" | ");
+  const expectedType = allowedTypes.map((type) => `'${type}'`).join(" | ");
   if (!matchesAllowedType) {
     throw new StatesRuntimeError(
       `Intrinsic function ${funcName} expected argument ${argPosition} to be of type ${expectedType}, but received ${typeof funcArg}`
@@ -197,7 +197,7 @@ function validateArgumentConstraints(argConstraints, argPosition, funcArg, funcN
       if (matchesAllConstraints)
         break;
     }
-    const expectedConstraints = argConstraints.map((constraint) => `"${constraint}"`).join(" | ");
+    const expectedConstraints = argConstraints.map((constraint) => `'${constraint}'`).join(" | ");
     if (!matchesAllConstraints) {
       throw new StatesRuntimeError(
         `Intrinsic function ${funcName} expected argument ${argPosition} to satisfy the following constraints: ${expectedConstraints}`
@@ -819,7 +819,7 @@ function processPayloadTemplate(payloadTemplate, json, context) {
     let sanitizedKey = key;
     let resolvedValue = value;
     if (isPlainObj(value)) {
-      resolvedValue = processPayloadTemplate(value, json);
+      resolvedValue = processPayloadTemplate(value, json, context);
     }
     if (key.endsWith(".$") && typeof value === "string") {
       sanitizedKey = key.replace(".$", "");
@@ -1150,7 +1150,10 @@ 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, options?.stateMachineOptions);
+    const iteratorStateMachine = new StateMachine(state.Iterator, {
+      ...options?.stateMachineOptions,
+      validationOptions: { _noValidate: true }
+    });
     const limit = pLimit(state.MaxConcurrency || DEFAULT_MAX_CONCURRENCY);
     const processedItemsPromise = items.map(
       (item, i) => limit(() => this.processItem(iteratorStateMachine, item, input, context, i, options))
@@ -1179,7 +1182,10 @@ var ParallelStateAction = class extends BaseStateAction {
     this.executionAbortFuncs = [];
   }
   processBranch(branch, input, context, options) {
-    const stateMachine = new StateMachine(branch, options?.stateMachineOptions);
+    const stateMachine = new StateMachine(branch, {
+      ...options?.stateMachineOptions,
+      validationOptions: { _noValidate: true }
+    });
     const execution = stateMachine.run(input, options?.runOptions);
     this.executionAbortFuncs.push(execution.abort);
     return execution.result;
@@ -1235,12 +1241,12 @@ var LambdaClient = class {
     if (config) {
       if (!config.region) {
         throw new StatesRuntimeError(
-          "`awsConfig` option was specified for state machine, but `region` property is not set"
+          "'awsConfig' option was specified for state machine, but 'region' property is not set"
         );
       }
       if (config.credentials) {
         const credentialsTypes = Object.keys(config.credentials);
-        const credentialsNames = credentialsTypes.map((name) => `\`${name}\``).join(", ");
+        const credentialsNames = credentialsTypes.map((name) => `'${name}'`).join(", ");
         if (credentialsTypes.length > 1) {
           throw new StatesRuntimeError(
             `More than one type of AWS credentials were specified: ${credentialsNames}. Only one type may be specified`
@@ -1274,7 +1280,7 @@ var LambdaClient = class {
     }
     if (invocationResult.FunctionError) {
       const errorResult = resultValue;
-      throw new FailStateError(errorResult.errorType, `Execution of Lambda function "${funcNameOrArn}" failed`);
+      throw new FailStateError(errorResult.errorType, `Execution of Lambda function '${funcNameOrArn}' failed`);
     }
     return resultValue;
   }
@@ -1585,6 +1591,7 @@ var StateExecutor = class {
 // src/stateMachine/StateMachine.ts
 import aslValidator from "asl-validator";
 import cloneDeep3 from "lodash/cloneDeep.js";
+var DEFAULT_MAX_EXECUTION_TIMEOUT = 2147483647e-3;
 var StateMachine = class {
   /**
    * Constructs a new state machine.
@@ -1593,14 +1600,16 @@ var StateMachine = class {
    * These options also apply to state machines defined in the `Iterator` field of `Map` states and in the `Branches` field of `Parallel` states.
    */
   constructor(definition, stateMachineOptions) {
-    const { isValid, errorsText } = aslValidator(definition, {
-      checkArn: true,
-      checkPaths: true,
-      ...stateMachineOptions?.validationOptions
-    });
-    if (!isValid) {
-      throw new Error(`State machine definition is invalid, see error(s) below:
+    if (!stateMachineOptions?.validationOptions?._noValidate) {
+      const { isValid, errorsText } = aslValidator(definition, {
+        checkArn: true,
+        checkPaths: true,
+        ...stateMachineOptions?.validationOptions
+      });
+      if (!isValid) {
+        throw new Error(`State machine definition is invalid, see error(s) below:
  ${errorsText("\n")}`);
+      }
     }
     this.definition = definition;
     this.stateMachineOptions = stateMachineOptions;
@@ -1618,6 +1627,7 @@ var StateMachine = class {
    */
   run(input, options) {
     const abortController = new AbortController();
+    const timeoutSeconds = this.definition.TimeoutSeconds ?? DEFAULT_MAX_EXECUTION_TIMEOUT;
     let onAbortHandler;
     const settleOnAbort = new Promise((resolve, reject) => {
       if (options?.noThrowOnAbort) {
@@ -1627,25 +1637,27 @@ var StateMachine = class {
       }
       abortController.signal.addEventListener("abort", onAbortHandler);
     });
-    let rejectOnTimeout = null;
-    if (this.definition.TimeoutSeconds) {
-      rejectOnTimeout = new Promise((_, reject) => {
-        setTimeout(() => {
-          abortController.signal.removeEventListener("abort", onAbortHandler);
-          abortController.abort();
-          reject(new StatesTimeoutError());
-        }, this.definition.TimeoutSeconds * 1e3);
-      });
-    }
-    const executionResult = this.execute(input, {
-      stateMachineOptions: this.stateMachineOptions,
-      runOptions: options,
-      abortSignal: abortController.signal
+    let timeoutId;
+    const rejectOnTimeout = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        abortController.signal.removeEventListener("abort", onAbortHandler);
+        abortController.abort();
+        reject(new StatesTimeoutError());
+      }, timeoutSeconds * 1e3);
     });
-    const racingPromises = [executionResult, settleOnAbort];
-    if (rejectOnTimeout) {
-      racingPromises.push(rejectOnTimeout);
-    }
+    const executionResult = this.execute(
+      input,
+      {
+        stateMachineOptions: this.stateMachineOptions,
+        runOptions: options,
+        abortSignal: abortController.signal
+      },
+      () => {
+        abortController.signal.removeEventListener("abort", onAbortHandler);
+        clearTimeout(timeoutId);
+      }
+    );
+    const racingPromises = [executionResult, settleOnAbort, rejectOnTimeout];
     const result = Promise.race(racingPromises);
     return {
       abort: () => abortController.abort(),
@@ -1655,7 +1667,7 @@ var StateMachine = class {
   /**
    * Helper method that handles the execution of the machine states and the transitions between them.
    */
-  async execute(input, options) {
+  async execute(input, options, cleanupFn) {
     let currState = this.definition.States[this.definition.StartAt];
     let currStateName = this.definition.StartAt;
     let currInput = cloneDeep3(input);
@@ -1673,6 +1685,8 @@ var StateMachine = class {
       } while (!isEndState && !options.abortSignal.aborted);
     } catch (error) {
       throw new ExecutionError(error);
+    } finally {
+      cleanupFn();
     }
     return currResult;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aws-local-stepfunctions",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Execute an AWS Step Function locally",
   "keywords": [
     "aws",
@@ -35,6 +35,9 @@
     "browser": "./build/main.browser.esm.js",
     "default": "./build/main.browser.esm.js"
   },
+  "bin": {
+    "local-sfn": "./build/CLI.cjs"
+  },
   "scripts": {
     "test": "jest",
     "build": "tsup",
@@ -64,6 +67,7 @@
     "@aws-sdk/client-lambda": "^3.314.0",
     "@aws-sdk/credential-providers": "^3.312.0",
     "asl-validator": "^3.5.1",
+    "commander": "^10.0.1",
     "crypto-js": "^4.1.1",
     "jsonpath-plus": "^7.2.0",
     "lodash": "^4.17.21",