aws-local-stepfunctions 0.7.0 → 1.1.0

package/build/main.d.ts

@@ -179,34 +179,215 @@ 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 ExecutionEventType = ExecutionStartedEventType | ExecutionSucceededEventType | ExecutionFailedEventType | ExecutionTerminatedEventType;
+type MapIterationStartedEventType = 'MapIterationStarted';
+type MapIterationSucceededEventType = 'MapIterationSucceeded';
+type MapIterationFailedEventType = 'MapIterationFailed';
+type MapIterationEventType = MapIterationStartedEventType | MapIterationSucceededEventType | MapIterationFailedEventType;
+type ParallelBranchStartedEventType = 'ParallelBranchStarted';
+type ParallelBranchSucceededEventType = 'ParallelBranchSucceeded';
+type ParallelBranchFailedEventType = 'ParallelBranchFailed';
+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;
+}
+interface ExecutionStartedEvent extends BaseEvent {
+    type: ExecutionStartedEventType;
+    input: JSONValue;
+}
+interface ExecutionSucceededEvent extends BaseEvent {
+    type: ExecutionSucceededEventType;
+    output: JSONValue;
+}
+interface ExecutionFailedEvent extends BaseEvent, ErrorInfo {
+    type: ExecutionFailedEventType;
+}
+interface ExecutionTerminatedEvent extends BaseEvent {
+    type: ExecutionTerminatedEventType;
+}
+interface BaseMapIterationEvent extends BaseEvent {
+    type: MapIterationEventType;
+    parentState: StateData;
+    index: number;
+}
+interface MapIterationStartedEvent extends BaseMapIterationEvent {
+    type: MapIterationStartedEventType;
+}
+interface MapIterationSucceededEvent extends BaseMapIterationEvent {
+    type: MapIterationSucceededEventType;
+}
+interface MapIterationFailedEvent extends BaseMapIterationEvent, ErrorInfo {
+    type: MapIterationFailedEventType;
+}
+interface BaseParallelBranchEvent extends BaseEvent {
+    type: ParallelBranchEventType;
+    parentState: StateData;
+}
+interface ParallelBranchStartedEvent extends BaseParallelBranchEvent {
+    type: ParallelBranchStartedEventType;
+}
+interface ParallelBranchSucceededEvent extends BaseParallelBranchEvent {
+    type: ParallelBranchSucceededEventType;
+}
+interface ParallelBranchFailedEvent extends BaseParallelBranchEvent, ErrorInfo {
+    type: ParallelBranchFailedEventType;
+}
+interface BaseStateEvent extends BaseEvent {
+    type: StateEventType;
+    state: StateData;
+    index?: number;
+}
+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;
 }
 
 declare class StateMachine {
@@ -230,6 +411,9 @@ declare class StateMachine {
      * If the execution fails, the result will throw an `ExecutionError` explaining why the
      * execution failed.
      *
+     * If the execution times out because the number of seconds specified in
+     * the `TimeoutSeconds` top-level field has elapsed, the result will throw an `ExecutionTimeoutError`.
+     *
      * 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`.
      *
@@ -239,6 +423,7 @@ declare class StateMachine {
     run(input: JSONValue, options?: RunOptions): {
         abort: () => void;
         result: Promise<JSONValue>;
+        eventLogs: AsyncGenerator<EventLog>;
     };
     /**
      * Helper method that handles the execution of the machine states and the transitions between them.
@@ -249,38 +434,22 @@ declare class StateMachine {
 /**
  * Represents the failure of a state machine execution.
  */
-declare class ExecutionError extends Error {
-    #private;
-    constructor(caughtError: Error);
-    get getWrappedError(): Error;
+declare class ExecutionError extends ErrorWithCause {
+    constructor(caughtError: RuntimeError);
 }
 
 /**
- * Represents the abortion of a state machine execution.
+ * Represents the abort of a state machine execution.
  */
 declare class ExecutionAbortedError extends Error {
     constructor();
 }
 
 /**
- * Base class for all internal errors that can be thrown during the state machine execution.
+ * Represents the timeout of a state machine execution.
  */
-declare 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;
-}
-
-declare class StatesTimeoutError extends RuntimeError {
+declare class ExecutionTimeoutError extends Error {
     constructor();
 }
 
-export { ExecutionAbortedError, ExecutionError, StatesTimeoutError as ExecutionTimeoutError, StateMachine };
+export { ExecutionAbortedError, ExecutionError, ExecutionTimeoutError, RunOptions, StateMachine, StateMachineDefinition, StateMachineOptions };