aws-local-stepfunctions 0.3.2 → 0.5.0

package/build/main.d.ts

@@ -1,11 +1,21 @@
-declare type StateType = 'Task' | 'Map' | 'Pass' | 'Wait' | 'Choice' | 'Succeed' | 'Fail';
+import { FromCognitoIdentityPoolParameters } from '@aws-sdk/credential-provider-cognito-identity/dist-types/fromCognitoIdentityPool';
+import { Credentials } from '@aws-sdk/types/dist-types/credentials';
+
+type StateType = 'Task' | 'Parallel' | 'Map' | 'Pass' | 'Wait' | 'Choice' | 'Succeed' | 'Fail';
 
 interface BaseState {
     Type: StateType;
     Comment?: string;
 }
 
-declare type PayloadTemplate = object;
+type JSONPrimitiveValue = null | boolean | number | string;
+type JSONArray = (JSONPrimitiveValue | JSONArray | JSONObject)[];
+type JSONObject = {
+    [key: string]: JSONPrimitiveValue | JSONObject | JSONArray;
+};
+type JSONValue = JSONPrimitiveValue | JSONObject | JSONArray;
+
+type PayloadTemplate = JSONObject;
 interface CanHaveInputPath {
     InputPath?: string | null;
 }
@@ -22,54 +32,54 @@ interface CanHaveOutputPath {
     OutputPath?: string | null;
 }
 
-declare type StringOperatorNames = 'StringEquals' | 'StringLessThan' | 'StringGreaterThan' | 'StringLessThanEquals' | 'StringGreaterThanEquals' | 'StringMatches';
-declare type StringPathOperatorNames = 'StringEqualsPath' | 'StringLessThanPath' | 'StringGreaterThanPath' | 'StringLessThanEqualsPath' | 'StringGreaterThanEqualsPath';
-declare type NumericOperatorNames = 'NumericEquals' | 'NumericLessThan' | 'NumericGreaterThan' | 'NumericLessThanEquals' | 'NumericGreaterThanEquals';
-declare type NumericPathOperatorNames = 'NumericEqualsPath' | 'NumericLessThanPath' | 'NumericGreaterThanPath' | 'NumericLessThanEqualsPath' | 'NumericGreaterThanEqualsPath';
-declare type BooleanOperatorNames = 'BooleanEquals';
-declare type BooleanPathOperatorNames = 'BooleanEqualsPath';
-declare type TimestampOperatorNames = 'TimestampEquals' | 'TimestampLessThan' | 'TimestampGreaterThan' | 'TimestampLessThanEquals' | 'TimestampGreaterThanEquals';
-declare type TimestampPathOperatorNames = 'TimestampEqualsPath' | 'TimestampLessThanPath' | 'TimestampGreaterThanPath' | 'TimestampLessThanEqualsPath' | 'TimestampGreaterThanEqualsPath';
-declare type TypeTestOperatorNames = 'IsNull' | 'IsPresent' | 'IsNumeric' | 'IsString' | 'IsBoolean' | 'IsTimestamp';
-declare type StringComparisonOperator = {
+type StringOperatorNames = 'StringEquals' | 'StringLessThan' | 'StringGreaterThan' | 'StringLessThanEquals' | 'StringGreaterThanEquals' | 'StringMatches';
+type StringPathOperatorNames = 'StringEqualsPath' | 'StringLessThanPath' | 'StringGreaterThanPath' | 'StringLessThanEqualsPath' | 'StringGreaterThanEqualsPath';
+type NumericOperatorNames = 'NumericEquals' | 'NumericLessThan' | 'NumericGreaterThan' | 'NumericLessThanEquals' | 'NumericGreaterThanEquals';
+type NumericPathOperatorNames = 'NumericEqualsPath' | 'NumericLessThanPath' | 'NumericGreaterThanPath' | 'NumericLessThanEqualsPath' | 'NumericGreaterThanEqualsPath';
+type BooleanOperatorNames = 'BooleanEquals';
+type BooleanPathOperatorNames = 'BooleanEqualsPath';
+type TimestampOperatorNames = 'TimestampEquals' | 'TimestampLessThan' | 'TimestampGreaterThan' | 'TimestampLessThanEquals' | 'TimestampGreaterThanEquals';
+type TimestampPathOperatorNames = 'TimestampEqualsPath' | 'TimestampLessThanPath' | 'TimestampGreaterThanPath' | 'TimestampLessThanEqualsPath' | 'TimestampGreaterThanEqualsPath';
+type TypeTestOperatorNames = 'IsNull' | 'IsPresent' | 'IsNumeric' | 'IsString' | 'IsBoolean' | 'IsTimestamp';
+type StringComparisonOperator = {
     [P in StringOperatorNames]?: string;
 };
-declare type StringPathComparisonOperator = {
+type StringPathComparisonOperator = {
     [P in StringPathOperatorNames]?: string;
 };
-declare type NumericComparisonOperator = {
+type NumericComparisonOperator = {
     [P in NumericOperatorNames]?: number;
 };
-declare type NumericPathComparisonOperator = {
+type NumericPathComparisonOperator = {
     [P in NumericPathOperatorNames]?: string;
 };
-declare type BooleanComparisonOperator = {
+type BooleanComparisonOperator = {
     [P in BooleanOperatorNames]?: boolean;
 };
-declare type BooleanPathComparisonOperator = {
+type BooleanPathComparisonOperator = {
     [P in BooleanPathOperatorNames]?: string;
 };
-declare type TimestampComparisonOperator = {
+type TimestampComparisonOperator = {
     [P in TimestampOperatorNames]?: string;
 };
-declare type TimestampPathComparisonOperator = {
+type TimestampPathComparisonOperator = {
     [P in TimestampPathOperatorNames]?: string;
 };
-declare type TypeTestComparisonOperator = {
+type TypeTestComparisonOperator = {
     [P in TypeTestOperatorNames]?: true;
 };
-declare type ComparisonOperator = StringComparisonOperator | StringPathComparisonOperator | NumericComparisonOperator | NumericPathComparisonOperator | BooleanComparisonOperator | BooleanPathComparisonOperator | TimestampComparisonOperator | TimestampPathComparisonOperator | TypeTestComparisonOperator;
-declare type BaseDataTestExpression = {
+type ComparisonOperator = StringComparisonOperator | StringPathComparisonOperator | NumericComparisonOperator | NumericPathComparisonOperator | BooleanComparisonOperator | BooleanPathComparisonOperator | TimestampComparisonOperator | TimestampPathComparisonOperator | TypeTestComparisonOperator;
+type BaseDataTestExpression = {
     Variable: string;
 };
-declare type DataTestExpression = BaseDataTestExpression & ComparisonOperator;
-declare type BooleanExpression = {
+type DataTestExpression = BaseDataTestExpression & ComparisonOperator;
+type BooleanExpression = {
     And?: ChoiceRuleWithoutNext[];
     Or?: ChoiceRuleWithoutNext[];
     Not?: ChoiceRuleWithoutNext;
 };
-declare type ChoiceRuleWithoutNext = DataTestExpression | BooleanExpression;
-declare type ChoiceRule = (DataTestExpression | BooleanExpression) & {
+type ChoiceRuleWithoutNext = DataTestExpression | BooleanExpression;
+type ChoiceRule = (DataTestExpression | BooleanExpression) & {
     Next: string;
 };
 interface BaseChoiceState extends BaseState, CanHaveInputPath, CanHaveOutputPath {
@@ -77,7 +87,7 @@ interface BaseChoiceState extends BaseState, CanHaveInputPath, CanHaveOutputPath
     Choices: ChoiceRule[];
     Default?: string;
 }
-declare type ChoiceState = BaseChoiceState;
+type ChoiceState = BaseChoiceState;
 
 interface EndableState extends BaseState {
     Type: Exclude<StateType, 'Choice' | 'Succeed' | 'Fail'>;
@@ -86,47 +96,69 @@ interface EndableState extends BaseState {
 interface SucceedOrFailState extends BaseState {
     Type: Extract<StateType, 'Succeed' | 'Fail'>;
 }
-declare type TerminalState = EndableState | SucceedOrFailState;
+type TerminalState = EndableState | SucceedOrFailState;
 
 interface BaseFailState extends BaseState {
     Type: 'Fail';
     Cause?: string;
     Error?: string;
 }
-declare type FailState = TerminalState & BaseFailState;
+type FailState = TerminalState & BaseFailState;
+
+type Retrier = {
+    ErrorEquals: string[];
+    IntervalSeconds?: number;
+    MaxAttempts?: number;
+    BackoffRate?: number;
+};
+interface RetryableState {
+    Retry?: Retrier[];
+}
+type Catcher = {
+    ErrorEquals: string[];
+    Next: string;
+    ResultPath?: string;
+};
+interface CatchableState {
+    Catch?: Catcher[];
+}
 
 interface NextableState extends BaseState {
     Type: Exclude<StateType, 'Choice' | 'Succeed' | 'Fail'>;
     Next: string;
 }
-declare type IntermediateState = NextableState;
+type IntermediateState = NextableState;
 
-interface BaseMapState extends BaseState, CanHaveInputPath, CanHaveParameters, CanHaveResultSelector, CanHaveResultPath, CanHaveOutputPath {
+interface BaseMapState extends BaseState, CanHaveInputPath, CanHaveParameters, CanHaveResultSelector, CanHaveResultPath, CanHaveOutputPath, RetryableState, CatchableState {
     Type: 'Map';
     Iterator: Omit<StateMachineDefinition, 'Version' | 'TimeoutSeconds'>;
     ItemsPath?: string;
     MaxConcurrency?: number;
 }
-declare type MapState = (IntermediateState | TerminalState) & BaseMapState;
+type MapState = (IntermediateState | TerminalState) & BaseMapState;
 
-declare type JSONValue = null | boolean | number | string | object | JSONValue[];
+interface BaseParallelState extends BaseState, CanHaveInputPath, CanHaveParameters, CanHaveResultSelector, CanHaveResultPath, CanHaveOutputPath, RetryableState, CatchableState {
+    Type: 'Parallel';
+    Branches: Omit<StateMachineDefinition, 'Version' | 'TimeoutSeconds'>[];
+}
+type ParallelState = (IntermediateState | TerminalState) & BaseParallelState;
 
 interface BasePassState extends BaseState, CanHaveInputPath, CanHaveParameters, CanHaveResultPath, CanHaveOutputPath {
     Type: 'Pass';
     Result?: JSONValue;
 }
-declare type PassState = (IntermediateState | TerminalState) & BasePassState;
+type PassState = (IntermediateState | TerminalState) & BasePassState;
 
 interface BaseSucceedState extends BaseState, CanHaveInputPath, CanHaveOutputPath {
     Type: 'Succeed';
 }
-declare type SucceedState = TerminalState & BaseSucceedState;
+type SucceedState = TerminalState & BaseSucceedState;
 
-interface BaseTaskState extends BaseState, CanHaveInputPath, CanHaveParameters, CanHaveResultSelector, CanHaveResultPath, CanHaveOutputPath {
+interface BaseTaskState extends BaseState, CanHaveInputPath, CanHaveParameters, CanHaveResultSelector, CanHaveResultPath, CanHaveOutputPath, RetryableState, CatchableState {
     Type: 'Task';
     Resource: string;
 }
-declare type TaskState = (IntermediateState | TerminalState) & BaseTaskState;
+type TaskState = (IntermediateState | TerminalState) & BaseTaskState;
 
 interface BaseWaitState extends BaseState, CanHaveInputPath, CanHaveOutputPath {
     Type: 'Wait';
@@ -135,9 +167,9 @@ interface BaseWaitState extends BaseState, CanHaveInputPath, CanHaveOutputPath {
     SecondsPath?: string;
     TimestampPath?: string;
 }
-declare type WaitState = (IntermediateState | TerminalState) & BaseWaitState;
+type WaitState = (IntermediateState | TerminalState) & BaseWaitState;
 
-declare type AllStates = TaskState | MapState | PassState | WaitState | ChoiceState | SucceedState | FailState;
+type AllStates = TaskState | ParallelState | MapState | PassState | WaitState | ChoiceState | SucceedState | FailState;
 
 interface StateMachineDefinition {
     States: Record<string, AllStates>;
@@ -147,10 +179,10 @@ interface StateMachineDefinition {
     TimeoutSeconds?: number;
 }
 
-declare type TaskStateResourceLocalHandler = {
+type TaskStateResourceLocalHandler = {
     [taskStateName: string]: (input: JSONValue) => Promise<JSONValue>;
 };
-declare type WaitStateTimeOverride = {
+type WaitStateTimeOverride = {
     [waitStateName: string]: number;
 };
 interface Overrides {
@@ -161,6 +193,17 @@ interface ValidationOptions {
     readonly checkPaths?: boolean;
     readonly checkArn?: boolean;
 }
+interface AWSConfig {
+    region: string;
+    credentials?: {
+        cognitoIdentityPool?: FromCognitoIdentityPoolParameters;
+        accessKeys?: Omit<Credentials, 'expiration'>;
+    };
+}
+interface StateMachineOptions {
+    validationOptions?: ValidationOptions;
+    awsConfig?: AWSConfig;
+}
 interface RunOptions {
     overrides?: Overrides;
     noThrowOnAbort?: boolean;
@@ -172,22 +215,20 @@ declare class StateMachine {
      */
     private readonly definition;
     /**
-     * A map of functions to execute each type of state.
-     */
-    private readonly stateExecutors;
-    /**
-     * Options to control whether to apply certain validations to the state machine definition.
+     * Options to control certain settings of the state machine.
      */
-    private readonly validationOptions;
+    private readonly stateMachineOptions;
     /**
      * Constructs a new state machine.
      * @param definition The state machine definition defined using the Amazon States Language (https://states-language.net/spec.html).
-     * @param validationOptions Options to control whether to apply certain validations to the definition.
-     * These options also apply to state machines defined in  the `Iterator` field of `Map` states.
+     * @param stateMachineOptions Options to control certain settings of the state machine.
+     * 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: StateMachineDefinition, validationOptions?: ValidationOptions);
+    constructor(definition: StateMachineDefinition, stateMachineOptions?: StateMachineOptions);
     /**
      * Executes the state machine, running through the states specified in the definition.
+     * If the execution fails, the result will throw an `ExecutionError` explaining why the
+     * execution failed.
      *
      * By default, if the execution is aborted, the result will throw an `ExecutionAbortedError`. This behavior can be changed by setting
      * the `noThrowOnAbort` option to `true`, in which case the result will be `null`.
@@ -203,83 +244,22 @@ declare class StateMachine {
      * Helper method that handles the execution of the machine states and the transitions between them.
      */
     private execute;
-    /**
-     * Process the current input according to the `InputPath` and `Parameters` fields.
-     */
-    private processInput;
-    /**
-     * Process the current result according to the `ResultSelector`, `ResultPath` and `OutputPath` fields.
-     */
-    private processResult;
-    /**
-     * Handler for task states.
-     *
-     * Invokes the Lambda function specified in the `Resource` field
-     * and sets the current result of the state machine to the value returned by the Lambda.
-     */
-    private executeTaskState;
-    /**
-     * Handler for map states.
-     *
-     * Iterates over the current input items or the items of an array specified
-     * by the `ItemsPath` field, and then processes each item by passing it
-     * as the input to the state machine specified in the `Iterator` field.
-     */
-    private executeMapState;
-    /**
-     * Handler for pass states.
-     *
-     * If the `Result` field is specified, copies `Result` into the current result.
-     * Else, copies the current input into the current result.
-     */
-    private executePassState;
-    /**
-     * Handler for wait states.
-     *
-     * Pauses the state machine execution for a certain amount of time
-     * based on one of the `Seconds`, `Timestamp`, `SecondsPath` or `TimestampPath` fields.
-     */
-    private executeWaitState;
-    /**
-     * Handler for choice states.
-     *
-     * Evaluates each choice rule specified in the `Choices` field.
-     *
-     * If one of the rules matches, then the state machine transitions to the
-     * state specified in the `Next` field for that choice rule.
-     *
-     * If no rule matches but the `Default` field is specified,
-     * then the next state will be the state specified in said field.
-     *
-     * If no rule matches and the `Default` field is not specified, throws a
-     * States.NoChoiceMatched error.
-     */
-    private executeChoiceState;
-    /**
-     * Handler for succeed states.
-     *
-     * Ends the state machine execution successfully.
-     */
-    private executeSucceedState;
-    /**
-     * Handler for fail states.
-     *
-     * Ends the state machine execution and marks it as a failure.
-     */
-    private executeFailState;
 }
 
-declare abstract class CustomError extends Error {
-    constructor(message?: string);
-    abstract toString(): string;
+/**
+ * Represents the failure of a state machine execution.
+ */
+declare class ExecutionError extends Error {
+    #private;
+    constructor(caughtError: Error);
+    get getWrappedError(): Error;
 }
 
 /**
  * Represents the abortion of a state machine execution.
  */
-declare class ExecutionAbortedError extends CustomError {
+declare class ExecutionAbortedError extends Error {
     constructor();
-    toString(): string;
 }
 
-export { ExecutionAbortedError, StateMachine };
+export { ExecutionAbortedError, ExecutionError, StateMachine };