aws-local-stepfunctions 1.0.0 → 1.1.0

package/build/main.d.ts

@@ -122,10 +122,6 @@ type Catcher = {
 interface CatchableState {
     Catch?: Catcher[];
 }
-type ErrorOutput = {
-    Error: string;
-    Cause?: string;
-};
 
 interface NextableState extends BaseState {
     Type: Exclude<StateType, 'Choice' | 'Succeed' | 'Fail'>;
@@ -183,22 +179,70 @@ interface StateMachineDefinition {
     TimeoutSeconds?: number;
 }
 
+type Context = Record<string, unknown>;
+
+declare class ErrorWithCause extends Error {
+    #private;
+    constructor(message: string, options?: {
+        cause: unknown;
+    });
+    get cause(): unknown;
+}
+
+/**
+ * Base class for all internal errors that can be thrown during the state machine execution.
+ */
+declare abstract class RuntimeError extends ErrorWithCause {
+    /**
+     * Whether this runtime error can be matched in a `Retry` field
+     */
+    protected retryable: boolean;
+    /**
+     * Whether this runtime error can be caught in a `Catch` field
+     */
+    protected catchable: boolean;
+    constructor(message: string, cause?: unknown);
+    get isRetryable(): boolean;
+    get isCatchable(): boolean;
+}
+
 type ExecutionStartedEventType = 'ExecutionStarted';
 type ExecutionSucceededEventType = 'ExecutionSucceeded';
 type ExecutionFailedEventType = 'ExecutionFailed';
 type ExecutionTerminatedEventType = 'ExecutionAborted' | 'ExecutionTimeout';
-type MapIterationEventType = 'MapIterationStarted' | 'MapIterationSucceeded';
+type ExecutionEventType = ExecutionStartedEventType | ExecutionSucceededEventType | ExecutionFailedEventType | ExecutionTerminatedEventType;
+type MapIterationStartedEventType = 'MapIterationStarted';
+type MapIterationSucceededEventType = 'MapIterationSucceeded';
 type MapIterationFailedEventType = 'MapIterationFailed';
-type ParallelBranchEventType = 'ParallelBranchStarted' | 'ParallelBranchSucceeded';
+type MapIterationEventType = MapIterationStartedEventType | MapIterationSucceededEventType | MapIterationFailedEventType;
+type ParallelBranchStartedEventType = 'ParallelBranchStarted';
+type ParallelBranchSucceededEventType = 'ParallelBranchSucceeded';
 type ParallelBranchFailedEventType = 'ParallelBranchFailed';
-type StateEventType = 'StateEntered' | 'StateExited';
-type AllEventTypes = ExecutionStartedEventType | ExecutionSucceededEventType | ExecutionFailedEventType | ExecutionTerminatedEventType | MapIterationEventType | MapIterationFailedEventType | ParallelBranchEventType | ParallelBranchFailedEventType | StateEventType;
+type ParallelBranchEventType = ParallelBranchStartedEventType | ParallelBranchSucceededEventType | ParallelBranchFailedEventType;
+type StateEnteredEventType = 'StateEntered';
+type StateExitedEventType = 'StateExited';
+type StateFailedEventType = 'StateFailed';
+type StateRetriedEventType = 'StateRetried';
+type StateCaughtEventType = 'StateCaught';
+type StateEventType = StateEnteredEventType | StateExitedEventType | StateFailedEventType | StateRetriedEventType | StateCaughtEventType;
+type AllEventTypes = ExecutionEventType | MapIterationEventType | ParallelBranchEventType | StateEventType;
 interface StateData {
     name: string;
     type: StateType;
     input: JSONValue;
     output?: JSONValue;
 }
+interface RetryData {
+    retrier: Retrier;
+    attempt: number;
+}
+interface CatchData {
+    catcher: Catcher;
+}
+interface ErrorInfo {
+    Error: string;
+    Cause: unknown;
+}
 interface BaseEvent {
     type: AllEventTypes;
     timestamp: number;
@@ -211,87 +255,138 @@ interface ExecutionSucceededEvent extends BaseEvent {
     type: ExecutionSucceededEventType;
     output: JSONValue;
 }
-interface ExecutionFailedEvent extends BaseEvent, ErrorOutput {
+interface ExecutionFailedEvent extends BaseEvent, ErrorInfo {
     type: ExecutionFailedEventType;
 }
 interface ExecutionTerminatedEvent extends BaseEvent {
     type: ExecutionTerminatedEventType;
 }
 interface BaseMapIterationEvent extends BaseEvent {
-    type: MapIterationEventType | MapIterationFailedEventType;
+    type: MapIterationEventType;
     parentState: StateData;
     index: number;
 }
-interface MapIterationEvent extends BaseMapIterationEvent {
-    type: MapIterationEventType;
+interface MapIterationStartedEvent extends BaseMapIterationEvent {
+    type: MapIterationStartedEventType;
+}
+interface MapIterationSucceededEvent extends BaseMapIterationEvent {
+    type: MapIterationSucceededEventType;
 }
-interface MapIterationFailedEvent extends BaseMapIterationEvent, ErrorOutput {
+interface MapIterationFailedEvent extends BaseMapIterationEvent, ErrorInfo {
     type: MapIterationFailedEventType;
 }
 interface BaseParallelBranchEvent extends BaseEvent {
-    type: ParallelBranchEventType | ParallelBranchFailedEventType;
+    type: ParallelBranchEventType;
     parentState: StateData;
 }
-interface ParallelBranchEvent extends BaseParallelBranchEvent {
-    type: ParallelBranchEventType;
+interface ParallelBranchStartedEvent extends BaseParallelBranchEvent {
+    type: ParallelBranchStartedEventType;
+}
+interface ParallelBranchSucceededEvent extends BaseParallelBranchEvent {
+    type: ParallelBranchSucceededEventType;
 }
-interface ParallelBranchFailedEvent extends BaseParallelBranchEvent, ErrorOutput {
+interface ParallelBranchFailedEvent extends BaseParallelBranchEvent, ErrorInfo {
     type: ParallelBranchFailedEventType;
 }
-interface StateEvent extends BaseEvent {
+interface BaseStateEvent extends BaseEvent {
     type: StateEventType;
     state: StateData;
     index?: number;
 }
-type EventLog = ExecutionStartedEvent | ExecutionSucceededEvent | ExecutionFailedEvent | ExecutionTerminatedEvent | MapIterationEvent | MapIterationFailedEvent | ParallelBranchEvent | ParallelBranchFailedEvent | StateEvent;
-
-type Context = Record<string, unknown>;
-
-/**
- * Base class for all internal errors that can be thrown during the state machine execution.
- */
-declare abstract class RuntimeError extends Error {
-    /**
-     * Whether this runtime error can be matched in a `Retry` field
-     */
-    protected retryable: boolean;
-    /**
-     * Whether this runtime error can be caught in a `Catch` field
-     */
-    protected catchable: boolean;
-    constructor(message: string);
-    get isRetryable(): boolean;
-    get isCatchable(): boolean;
+interface StateEnteredEvent extends BaseStateEvent {
+    type: StateEnteredEventType;
+}
+interface StateExitedEvent extends BaseStateEvent {
+    type: StateExitedEventType;
 }
+interface StateFailedEvent extends BaseStateEvent, ErrorInfo {
+    type: StateFailedEventType;
+}
+interface StateRetriedEvent extends BaseStateEvent {
+    type: StateRetriedEventType;
+    retry: RetryData;
+}
+interface StateRetriedEvent extends BaseStateEvent {
+    type: StateRetriedEventType;
+    retry: RetryData;
+}
+interface StateCaughtEvent extends BaseStateEvent {
+    type: StateCaughtEventType;
+    catch: CatchData;
+}
+type EventLog = ExecutionStartedEvent | ExecutionSucceededEvent | ExecutionFailedEvent | ExecutionTerminatedEvent | MapIterationStartedEvent | MapIterationSucceededEvent | MapIterationFailedEvent | ParallelBranchStartedEvent | ParallelBranchSucceededEvent | ParallelBranchFailedEvent | StateEnteredEvent | StateExitedEvent | StateFailedEvent | StateRetriedEvent | StateCaughtEvent;
 
 type TaskStateResourceLocalHandler = {
-    [taskStateName: string]: (input: JSONValue) => Promise<JSONValue>;
+    [taskStateName: string]: (input: JSONValue) => Promise<JSONValue> | JSONValue;
 };
 type WaitStateTimeOverride = {
     [waitStateName: string]: number;
 };
 interface Overrides {
+    /**
+     * Pass an object to this option to override a `Task` state to run a local function,
+     * instead of calling the service specified in the `Resource` field.
+     */
     taskResourceLocalHandlers?: TaskStateResourceLocalHandler;
+    /**
+     * Pass an object to this option to override a `Wait` state to pause for the specified number of milliseconds,
+     * instead of pausing for the duration specified by the `Seconds`, `Timestamp`, `SecondsPath`, or `TimestampPath` fields.
+     */
     waitTimeOverrides?: WaitStateTimeOverride;
 }
 interface ValidationOptions {
+    /**
+     * Disables validation of the state machine definition entirely.
+     *
+     * Use this option at your own risk, there are no guarantees when passing an invalid or non-standard definition to the state machine.
+     * Running it might result in undefined/unsupported behavior.
+     */
+    readonly noValidate?: boolean;
+    /**
+     * Disables validation of JSONPath expressions in the state machine definition.
+     */
     readonly checkPaths?: boolean;
+    /**
+     * Disables validation of ARNs in the state machine definition.
+     */
     readonly checkArn?: boolean;
 }
 interface AWSConfig {
+    /**
+     * AWS Region where your Task resources are located.
+     */
     region: string;
+    /**
+     * AWS credentials needed to be able to call Task resources.
+     */
     credentials?: {
         cognitoIdentityPool?: FromCognitoIdentityPoolParameters;
-        accessKeys?: Omit<AwsCredentialIdentity, 'expiration'>;
+        accessKeys?: AwsCredentialIdentity;
     };
 }
 interface StateMachineOptions {
+    /**
+     * Options that allow changing certain rules when validating the state machine definition.
+     */
     validationOptions?: ValidationOptions;
+    /**
+     * Config options related to AWS resources.
+     */
     awsConfig?: AWSConfig;
 }
 interface RunOptions {
+    /**
+     * This option allows overriding the behavior of certain states.
+     */
     overrides?: Overrides;
+    /**
+     * If set to `true`, aborting the execution will simply return `null` as result instead of throwing
+     */
     noThrowOnAbort?: boolean;
+    /**
+     * Pass an object to this option to mock the [Context Object](https://states-language.net/#context-object) that will be used in the execution.
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/input-output-contextobject.html
+     */
     context?: Context;
 }
 
@@ -339,14 +434,12 @@ declare class StateMachine {
 /**
  * Represents the failure of a state machine execution.
  */
-declare class ExecutionError extends Error {
-    #private;
+declare class ExecutionError extends ErrorWithCause {
     constructor(caughtError: RuntimeError);
-    get getWrappedError(): RuntimeError;
 }
 
 /**
- * Represents the abortion of a state machine execution.
+ * Represents the abort of a state machine execution.
  */
 declare class ExecutionAbortedError extends Error {
     constructor();
@@ -359,4 +452,4 @@ declare class ExecutionTimeoutError extends Error {
     constructor();
 }
 
-export { ExecutionAbortedError, ExecutionError, ExecutionTimeoutError, StateMachine };
+export { ExecutionAbortedError, ExecutionError, ExecutionTimeoutError, RunOptions, StateMachine, StateMachineDefinition, StateMachineOptions };