aws-local-stepfunctions 0.6.0 → 1.0.0

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';
 
@@ -122,6 +122,10 @@ type Catcher = {
 interface CatchableState {
     Catch?: Catcher[];
 }
+type ErrorOutput = {
+    Error: string;
+    Cause?: string;
+};
 
 interface NextableState extends BaseState {
     Type: Exclude<StateType, 'Choice' | 'Succeed' | 'Fail'>;
@@ -179,6 +183,87 @@ interface StateMachineDefinition {
     TimeoutSeconds?: number;
 }
 
+type ExecutionStartedEventType = 'ExecutionStarted';
+type ExecutionSucceededEventType = 'ExecutionSucceeded';
+type ExecutionFailedEventType = 'ExecutionFailed';
+type ExecutionTerminatedEventType = 'ExecutionAborted' | 'ExecutionTimeout';
+type MapIterationEventType = 'MapIterationStarted' | 'MapIterationSucceeded';
+type MapIterationFailedEventType = 'MapIterationFailed';
+type ParallelBranchEventType = 'ParallelBranchStarted' | 'ParallelBranchSucceeded';
+type ParallelBranchFailedEventType = 'ParallelBranchFailed';
+type StateEventType = 'StateEntered' | 'StateExited';
+type AllEventTypes = ExecutionStartedEventType | ExecutionSucceededEventType | ExecutionFailedEventType | ExecutionTerminatedEventType | MapIterationEventType | MapIterationFailedEventType | ParallelBranchEventType | ParallelBranchFailedEventType | StateEventType;
+interface StateData {
+    name: string;
+    type: StateType;
+    input: JSONValue;
+    output?: JSONValue;
+}
+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, ErrorOutput {
+    type: ExecutionFailedEventType;
+}
+interface ExecutionTerminatedEvent extends BaseEvent {
+    type: ExecutionTerminatedEventType;
+}
+interface BaseMapIterationEvent extends BaseEvent {
+    type: MapIterationEventType | MapIterationFailedEventType;
+    parentState: StateData;
+    index: number;
+}
+interface MapIterationEvent extends BaseMapIterationEvent {
+    type: MapIterationEventType;
+}
+interface MapIterationFailedEvent extends BaseMapIterationEvent, ErrorOutput {
+    type: MapIterationFailedEventType;
+}
+interface BaseParallelBranchEvent extends BaseEvent {
+    type: ParallelBranchEventType | ParallelBranchFailedEventType;
+    parentState: StateData;
+}
+interface ParallelBranchEvent extends BaseParallelBranchEvent {
+    type: ParallelBranchEventType;
+}
+interface ParallelBranchFailedEvent extends BaseParallelBranchEvent, ErrorOutput {
+    type: ParallelBranchFailedEventType;
+}
+interface StateEvent 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;
+}
+
 type TaskStateResourceLocalHandler = {
     [taskStateName: string]: (input: JSONValue) => Promise<JSONValue>;
 };
@@ -197,7 +282,7 @@ interface AWSConfig {
     region: string;
     credentials?: {
         cognitoIdentityPool?: FromCognitoIdentityPoolParameters;
-        accessKeys?: Omit<Credentials, 'expiration'>;
+        accessKeys?: Omit<AwsCredentialIdentity, 'expiration'>;
     };
 }
 interface StateMachineOptions {
@@ -207,6 +292,7 @@ interface StateMachineOptions {
 interface RunOptions {
     overrides?: Overrides;
     noThrowOnAbort?: boolean;
+    context?: Context;
 }
 
 declare class StateMachine {
@@ -230,6 +316,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 +328,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.
@@ -251,8 +341,8 @@ declare class StateMachine {
  */
 declare class ExecutionError extends Error {
     #private;
-    constructor(caughtError: Error);
-    get getWrappedError(): Error;
+    constructor(caughtError: RuntimeError);
+    get getWrappedError(): RuntimeError;
 }
 
 /**
@@ -263,24 +353,10 @@ declare class ExecutionAbortedError extends Error {
 }
 
 /**
- * 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, StateMachine };