terraconstructs 0.0.8

package/lib/aws/compute/states/state.js

@@ -0,0 +1,482 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderJsonPath = exports.renderList = exports.State = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-stepfunctions/lib/states/state.ts
+const cdktf_1 = require("cdktf");
+const constructs_1 = require("constructs");
+const fields_1 = require("../fields");
+const types_1 = require("../types");
+/**
+ * Base class for all other state classes
+ */
+class State extends constructs_1.Construct {
+    /**
+     * Add a prefix to the stateId of all States found in a construct tree
+     */
+    static prefixStates(root, prefix) {
+        const queue = [root];
+        while (queue.length > 0) {
+            const el = queue.splice(0, 1)[0];
+            if (isPrefixable(el)) {
+                el.addPrefix(prefix);
+            }
+            queue.push(...el.node.children);
+        }
+    }
+    /**
+     * Find the set of states reachable through transitions from the given start state.
+     * This does not retrieve states from within sub-graphs, such as states within a Parallel state's branch.
+     */
+    static findReachableStates(start, options = {}) {
+        const visited = new Set();
+        const ret = new Set();
+        const queue = [start];
+        while (queue.length > 0) {
+            const state = queue.splice(0, 1)[0];
+            if (visited.has(state)) {
+                continue;
+            }
+            visited.add(state);
+            const outgoing = state.outgoingTransitions(options);
+            queue.push(...outgoing);
+            ret.add(state);
+        }
+        return Array.from(ret);
+    }
+    /**
+     * Find the set of end states states reachable through transitions from the given start state
+     */
+    static findReachableEndStates(start, options = {}) {
+        const visited = new Set();
+        const ret = new Set();
+        const queue = [start];
+        while (queue.length > 0) {
+            const state = queue.splice(0, 1)[0];
+            if (visited.has(state)) {
+                continue;
+            }
+            visited.add(state);
+            const outgoing = state.outgoingTransitions(options);
+            if (outgoing.length > 0) {
+                // We can continue
+                queue.push(...outgoing);
+            }
+            else {
+                // Terminal state
+                ret.add(state);
+            }
+        }
+        return Array.from(ret);
+    }
+    /**
+     * Return only the states that allow chaining from an array of states
+     */
+    static filterNextables(states) {
+        return states.filter(isNextable);
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.branches = [];
+        this.processorMode = types_1.ProcessorMode.INLINE;
+        this.retries = [];
+        this.catches = [];
+        this.choices = [];
+        this.prefixes = [];
+        /**
+         * States with references to this state.
+         *
+         * Used for finding complete connected graph that a state is part of.
+         */
+        this.incomingStates = [];
+        this.startState = this;
+        this.stateName = props.stateName;
+        this.comment = props.comment;
+        this.inputPath = props.inputPath;
+        this.parameters = props.parameters;
+        this.outputPath = props.outputPath;
+        this.resultPath = props.resultPath;
+        this.resultSelector = props.resultSelector;
+        this.node.addValidation({ validate: () => this.validateState() });
+    }
+    /**
+     * Allows the state to validate itself.
+     */
+    validateState() {
+        return [];
+    }
+    get id() {
+        return this.node.id;
+    }
+    /**
+     * Tokenized string that evaluates to the state's ID
+     */
+    get stateId() {
+        return this.prefixes
+            .concat(this.stateName ? this.stateName : this.id)
+            .join("");
+    }
+    /**
+     * Add a prefix to the stateId of this state
+     */
+    addPrefix(x) {
+        if (x !== "") {
+            this.prefixes.splice(0, 0, x);
+        }
+    }
+    /**
+     * Register this state as part of the given graph
+     *
+     * Don't call this. It will be called automatically when you work
+     * with states normally.
+     */
+    bindToGraph(graph) {
+        if (this.containingGraph === graph) {
+            return;
+        }
+        if (this.containingGraph) {
+            // eslint-disable-next-line max-len
+            throw new Error(`Trying to use state '${this.stateId}' in ${graph}, but is already in ${this.containingGraph}. Every state can only be used in one graph.`);
+        }
+        this.containingGraph = graph;
+        this.whenBoundToGraph(graph);
+        for (const incoming of this.incomingStates) {
+            incoming.bindToGraph(graph);
+        }
+        for (const outgoing of this.outgoingTransitions({
+            includeErrorHandlers: true,
+        })) {
+            outgoing.bindToGraph(graph);
+        }
+        for (const branch of this.branches) {
+            branch.registerSuperGraph(this.containingGraph);
+        }
+        if (!!this.iteration) {
+            this.iteration.registerSuperGraph(this.containingGraph);
+        }
+        if (!!this.processor) {
+            this.processor.registerSuperGraph(this.containingGraph);
+        }
+    }
+    /**
+     * Add a retrier to the retry list of this state
+     * @internal
+     */
+    _addRetry(props = {}) {
+        validateErrors(props.errors);
+        this.retries.push({
+            ...props,
+            errors: props.errors ?? [types_1.Errors.ALL],
+        });
+    }
+    /**
+     * Add an error handler to the catch list of this state
+     * @internal
+     */
+    _addCatch(handler, props = {}) {
+        validateErrors(props.errors);
+        this.catches.push({
+            next: handler,
+            props: {
+                errors: props.errors ?? [types_1.Errors.ALL],
+                resultPath: props.resultPath,
+            },
+        });
+        handler.addIncoming(this);
+        if (this.containingGraph) {
+            handler.bindToGraph(this.containingGraph);
+        }
+    }
+    /**
+     * Make the indicated state the default transition of this state
+     */
+    makeNext(next) {
+        // Can't be called 'setNext' because of JSII
+        if (this._next) {
+            throw new Error(`State '${this.id}' already has a next state`);
+        }
+        this._next = next;
+        next.addIncoming(this);
+        if (this.containingGraph) {
+            next.bindToGraph(this.containingGraph);
+        }
+    }
+    /**
+     * Add a choice branch to this state
+     */
+    addChoice(condition, next, options) {
+        this.choices.push({ condition, next, ...options });
+        next.startState.addIncoming(this);
+        if (this.containingGraph) {
+            next.startState.bindToGraph(this.containingGraph);
+        }
+    }
+    /**
+     * Add a parallel branch to this state
+     */
+    addBranch(branch) {
+        this.branches.push(branch);
+        if (this.containingGraph) {
+            branch.registerSuperGraph(this.containingGraph);
+        }
+    }
+    /**
+     * Add a map iterator to this state
+     */
+    addIterator(iteration) {
+        this.iteration = iteration;
+        if (this.containingGraph) {
+            iteration.registerSuperGraph(this.containingGraph);
+        }
+    }
+    /**
+     * Add a item processor to this state
+     */
+    addItemProcessor(processor, config = {}) {
+        this.processor = processor;
+        this.processorConfig = config;
+        if (this.containingGraph) {
+            processor.registerSuperGraph(this.containingGraph);
+        }
+    }
+    /**
+     * Make the indicated state the default choice transition of this state
+     */
+    makeDefault(def) {
+        // Can't be called 'setDefault' because of JSII
+        if (this.defaultChoice) {
+            throw new Error(`Choice '${this.id}' already has a default next state`);
+        }
+        this.defaultChoice = def;
+    }
+    /**
+     * Render the default next state in ASL JSON format
+     */
+    renderNextEnd() {
+        if (this._next) {
+            return { Next: this._next.stateId };
+        }
+        else {
+            return { End: true };
+        }
+    }
+    /**
+     * Render the choices in ASL JSON format
+     */
+    renderChoices() {
+        return {
+            Choices: renderList(this.choices, renderChoice),
+            Default: this.defaultChoice?.stateId,
+        };
+    }
+    /**
+     * Render InputPath/Parameters/OutputPath in ASL JSON format
+     */
+    renderInputOutput() {
+        return {
+            InputPath: renderJsonPath(this.inputPath),
+            Parameters: this.parameters,
+            OutputPath: renderJsonPath(this.outputPath),
+        };
+    }
+    /**
+     * Render parallel branches in ASL JSON format
+     */
+    renderBranches() {
+        return {
+            Branches: this.branches.map((b) => b.toGraphJson()),
+        };
+    }
+    /**
+     * Render map iterator in ASL JSON format
+     */
+    renderIterator() {
+        if (!this.iteration)
+            return undefined;
+        return {
+            Iterator: this.iteration.toGraphJson(),
+        };
+    }
+    /**
+     * Render error recovery options in ASL JSON format
+     */
+    renderRetryCatch() {
+        return {
+            Retry: renderList(this.retries, renderRetry, (a, b) => compareErrors(a.errors, b.errors)),
+            Catch: renderList(this.catches, renderCatch, (a, b) => compareErrors(a.props.errors, b.props.errors)),
+        };
+    }
+    /**
+     * Render ResultSelector in ASL JSON format
+     */
+    renderResultSelector() {
+        return fields_1.FieldUtils.renderObject({
+            ResultSelector: this.resultSelector,
+        });
+    }
+    /**
+     * Render ItemProcessor in ASL JSON format
+     */
+    renderItemProcessor() {
+        if (!this.processor)
+            return undefined;
+        return {
+            ItemProcessor: {
+                ...this.renderProcessorConfig(),
+                ...this.processor.toGraphJson(),
+            },
+        };
+    }
+    /**
+     * Render ProcessorConfig in ASL JSON format
+     */
+    renderProcessorConfig() {
+        const mode = this.processorConfig?.mode?.toString() ?? this.processorMode;
+        if (mode === types_1.ProcessorMode.INLINE) {
+            return {
+                ProcessorConfig: {
+                    Mode: mode,
+                },
+            };
+        }
+        const executionType = this.processorConfig?.executionType?.toString();
+        return {
+            ProcessorConfig: {
+                Mode: mode,
+                ExecutionType: executionType,
+            },
+        };
+    }
+    /**
+     * Called whenever this state is bound to a graph
+     *
+     * Can be overridden by subclasses.
+     */
+    whenBoundToGraph(graph) {
+        graph.registerState(this);
+    }
+    /**
+     * Add a state to the incoming list
+     */
+    addIncoming(source) {
+        this.incomingStates.push(source);
+    }
+    /**
+     * Return all states this state can transition to
+     */
+    outgoingTransitions(options) {
+        const ret = new Array();
+        if (this._next) {
+            ret.push(this._next);
+        }
+        if (this.defaultChoice) {
+            ret.push(this.defaultChoice);
+        }
+        for (const c of this.choices) {
+            ret.push(c.next);
+        }
+        if (options.includeErrorHandlers) {
+            for (const c of this.catches) {
+                ret.push(c.next);
+            }
+        }
+        return ret;
+    }
+}
+exports.State = State;
+_a = JSII_RTTI_SYMBOL_1;
+State[_a] = { fqn: "terraconstructs.aws.compute.State", version: "0.0.8" };
+/**
+ * Render a choice transition
+ */
+function renderChoice(c) {
+    return {
+        ...c.condition.renderCondition(),
+        Next: c.next.stateId,
+        Comment: c.comment,
+    };
+}
+/**
+ * Render a Retry object to ASL
+ */
+function renderRetry(retry) {
+    return {
+        ErrorEquals: retry.errors,
+        IntervalSeconds: retry.interval && retry.interval.toSeconds(),
+        MaxAttempts: retry.maxAttempts,
+        BackoffRate: retry.backoffRate,
+        MaxDelaySeconds: retry.maxDelay && retry.maxDelay.toSeconds(),
+        JitterStrategy: retry.jitterStrategy,
+    };
+}
+/**
+ * Render a Catch object to ASL
+ */
+function renderCatch(c) {
+    return {
+        ErrorEquals: c.props.errors,
+        ResultPath: renderJsonPath(c.props.resultPath),
+        Next: c.next.stateId,
+    };
+}
+/**
+ * Compares a list of Errors to move Errors.ALL last in a sort function
+ */
+function compareErrors(a, b) {
+    if (a?.includes(types_1.Errors.ALL)) {
+        return 1;
+    }
+    if (b?.includes(types_1.Errors.ALL)) {
+        return -1;
+    }
+    return 0;
+}
+/**
+ * Validates an errors list
+ */
+function validateErrors(errors) {
+    if (errors?.includes(types_1.Errors.ALL) && errors.length > 1) {
+        throw new Error(`${types_1.Errors.ALL} must appear alone in an error list`);
+    }
+}
+/**
+ * Render a list or return undefined for an empty list
+ */
+function renderList(xs, mapFn, sortFn) {
+    if (xs.length === 0) {
+        return undefined;
+    }
+    let list = xs;
+    if (sortFn) {
+        list = xs.sort(sortFn);
+    }
+    return list.map(mapFn);
+}
+exports.renderList = renderList;
+/**
+ * Render JSON path, respecting the special value JsonPath.DISCARD
+ */
+function renderJsonPath(jsonPath) {
+    if (jsonPath === undefined) {
+        return undefined;
+    }
+    if (!cdktf_1.Token.isUnresolved(jsonPath) && !jsonPath.startsWith("$")) {
+        throw new Error(`Expected JSON path to start with '$', got: ${jsonPath}`);
+    }
+    return jsonPath;
+}
+exports.renderJsonPath = renderJsonPath;
+/**
+ * Whether an object is a Prefixable
+ */
+function isPrefixable(x) {
+    return typeof x === "object" && x.addPrefix;
+}
+/**
+ * Whether an object is INextable
+ */
+function isNextable(x) {
+    return typeof x === "object" && x.next;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state.js","sourceRoot":"","sources":["../../../../src/aws/compute/states/state.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-stepfunctions/lib/states/state.ts\n\nimport { Token } from \"cdktf\";\nimport { IConstruct, Construct } from \"constructs\";\nimport { Condition } from \"../condition\";\nimport { FieldUtils } from \"../fields\";\nimport { StateGraph } from \"../state-graph\";\nimport {\n  CatchProps,\n  Errors,\n  IChainable,\n  INextable,\n  ProcessorConfig,\n  ProcessorMode,\n  RetryProps,\n} from \"../types\";\n\n/**\n * Properties shared by all states\n */\nexport interface StateProps {\n  /**\n   * Optional name for this state\n   *\n   * @default - The construct ID will be used as state name\n   */\n  readonly stateName?: string;\n\n  /**\n   * A comment describing this state\n   *\n   * @default No comment\n   */\n  readonly comment?: string;\n\n  /**\n   * JSONPath expression to select part of the state to be the input to this state.\n   *\n   * May also be the special value JsonPath.DISCARD, which will cause the effective\n   * input to be the empty object {}.\n   *\n   * @default $\n   */\n  readonly inputPath?: string;\n\n  /**\n   * Parameters pass a collection of key-value pairs, either static values or JSONPath expressions that select from the input.\n   *\n   * @see\n   * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-inputpath-params.html#input-output-parameters\n   *\n   * @default No parameters\n   */\n  readonly parameters?: { [name: string]: any };\n\n  /**\n   * JSONPath expression to select part of the state to be the output to this state.\n   *\n   * May also be the special value JsonPath.DISCARD, which will cause the effective\n   * output to be the empty object {}.\n   *\n   * @default $\n   */\n  readonly outputPath?: string;\n\n  /**\n   * JSONPath expression to indicate where to inject the state's output\n   *\n   * May also be the special value JsonPath.DISCARD, which will cause the state's\n   * input to become its output.\n   *\n   * @default $\n   */\n  readonly resultPath?: string;\n\n  /**\n   * The JSON that will replace the state's raw result and become the effective\n   * result before ResultPath is applied.\n   *\n   * You can use ResultSelector to create a payload with values that are static\n   * or selected from the state's raw result.\n   *\n   * @see\n   * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-inputpath-params.html#input-output-resultselector\n   *\n   * @default - None\n   */\n  readonly resultSelector?: { [key: string]: any };\n}\n\n/**\n * Base class for all other state classes\n */\nexport abstract class State extends Construct implements IChainable {\n  /**\n   * Add a prefix to the stateId of all States found in a construct tree\n   */\n  public static prefixStates(root: IConstruct, prefix: string) {\n    const queue = [root];\n    while (queue.length > 0) {\n      const el = queue.splice(0, 1)[0]!;\n      if (isPrefixable(el)) {\n        el.addPrefix(prefix);\n      }\n      queue.push(...el.node.children);\n    }\n  }\n\n  /**\n   * Find the set of states reachable through transitions from the given start state.\n   * This does not retrieve states from within sub-graphs, such as states within a Parallel state's branch.\n   */\n  public static findReachableStates(\n    start: State,\n    options: FindStateOptions = {},\n  ): State[] {\n    const visited = new Set<State>();\n    const ret = new Set<State>();\n    const queue = [start];\n    while (queue.length > 0) {\n      const state = queue.splice(0, 1)[0]!;\n      if (visited.has(state)) {\n        continue;\n      }\n      visited.add(state);\n      const outgoing = state.outgoingTransitions(options);\n      queue.push(...outgoing);\n      ret.add(state);\n    }\n    return Array.from(ret);\n  }\n\n  /**\n   * Find the set of end states states reachable through transitions from the given start state\n   */\n  public static findReachableEndStates(\n    start: State,\n    options: FindStateOptions = {},\n  ): State[] {\n    const visited = new Set<State>();\n    const ret = new Set<State>();\n    const queue = [start];\n    while (queue.length > 0) {\n      const state = queue.splice(0, 1)[0]!;\n      if (visited.has(state)) {\n        continue;\n      }\n      visited.add(state);\n\n      const outgoing = state.outgoingTransitions(options);\n\n      if (outgoing.length > 0) {\n        // We can continue\n        queue.push(...outgoing);\n      } else {\n        // Terminal state\n        ret.add(state);\n      }\n    }\n    return Array.from(ret);\n  }\n\n  /**\n   * Return only the states that allow chaining from an array of states\n   */\n  public static filterNextables(states: State[]): INextable[] {\n    return states.filter(isNextable) as any;\n  }\n\n  /**\n   * First state of this Chainable\n   */\n  public readonly startState: State;\n\n  /**\n   * Continuable states of this Chainable\n   */\n  public abstract readonly endStates: INextable[];\n\n  // This class has a superset of most of the features of the other states,\n  // and the subclasses decide which part of the features to expose. Most\n  // features are shared by a couple of states, and it becomes cumbersome to\n  // slice it out across all states. This is not great design, but it is\n  // pragmatic!\n  protected readonly stateName?: string;\n  protected readonly comment?: string;\n  protected readonly inputPath?: string;\n  protected readonly parameters?: object;\n  protected readonly outputPath?: string;\n  protected readonly resultPath?: string;\n  protected readonly resultSelector?: object;\n  protected readonly branches: StateGraph[] = [];\n  protected iteration?: StateGraph;\n  protected processorMode?: ProcessorMode = ProcessorMode.INLINE;\n  protected processor?: StateGraph;\n  protected processorConfig?: ProcessorConfig;\n  protected defaultChoice?: State;\n\n  /**\n   * @internal\n   */\n  protected _next?: State;\n\n  private readonly retries: RetryProps[] = [];\n  private readonly catches: CatchTransition[] = [];\n  private readonly choices: ChoiceTransition[] = [];\n  private readonly prefixes: string[] = [];\n\n  /**\n   * The graph that this state is part of.\n   *\n   * Used for guaranteeing consistency between graphs and graph components.\n   */\n  private containingGraph?: StateGraph;\n\n  /**\n   * States with references to this state.\n   *\n   * Used for finding complete connected graph that a state is part of.\n   */\n  private readonly incomingStates: State[] = [];\n\n  constructor(scope: Construct, id: string, props: StateProps) {\n    super(scope, id);\n\n    this.startState = this;\n\n    this.stateName = props.stateName;\n    this.comment = props.comment;\n    this.inputPath = props.inputPath;\n    this.parameters = props.parameters;\n    this.outputPath = props.outputPath;\n    this.resultPath = props.resultPath;\n    this.resultSelector = props.resultSelector;\n\n    this.node.addValidation({ validate: () => this.validateState() });\n  }\n\n  /**\n   * Allows the state to validate itself.\n   */\n  protected validateState(): string[] {\n    return [];\n  }\n\n  public get id() {\n    return this.node.id;\n  }\n\n  /**\n   * Tokenized string that evaluates to the state's ID\n   */\n  public get stateId(): string {\n    return this.prefixes\n      .concat(this.stateName ? this.stateName : this.id)\n      .join(\"\");\n  }\n\n  /**\n   * Add a prefix to the stateId of this state\n   */\n  public addPrefix(x: string) {\n    if (x !== \"\") {\n      this.prefixes.splice(0, 0, x);\n    }\n  }\n\n  /**\n   * Register this state as part of the given graph\n   *\n   * Don't call this. It will be called automatically when you work\n   * with states normally.\n   */\n  public bindToGraph(graph: StateGraph) {\n    if (this.containingGraph === graph) {\n      return;\n    }\n\n    if (this.containingGraph) {\n      // eslint-disable-next-line max-len\n      throw new Error(\n        `Trying to use state '${this.stateId}' in ${graph}, but is already in ${this.containingGraph}. Every state can only be used in one graph.`,\n      );\n    }\n\n    this.containingGraph = graph;\n    this.whenBoundToGraph(graph);\n\n    for (const incoming of this.incomingStates) {\n      incoming.bindToGraph(graph);\n    }\n    for (const outgoing of this.outgoingTransitions({\n      includeErrorHandlers: true,\n    })) {\n      outgoing.bindToGraph(graph);\n    }\n    for (const branch of this.branches) {\n      branch.registerSuperGraph(this.containingGraph);\n    }\n    if (!!this.iteration) {\n      this.iteration.registerSuperGraph(this.containingGraph);\n    }\n    if (!!this.processor) {\n      this.processor.registerSuperGraph(this.containingGraph);\n    }\n  }\n\n  /**\n   * Render the state as JSON\n   */\n  public abstract toStateJson(): object;\n\n  /**\n   * Add a retrier to the retry list of this state\n   * @internal\n   */\n  protected _addRetry(props: RetryProps = {}) {\n    validateErrors(props.errors);\n\n    this.retries.push({\n      ...props,\n      errors: props.errors ?? [Errors.ALL],\n    });\n  }\n\n  /**\n   * Add an error handler to the catch list of this state\n   * @internal\n   */\n  protected _addCatch(handler: State, props: CatchProps = {}) {\n    validateErrors(props.errors);\n\n    this.catches.push({\n      next: handler,\n      props: {\n        errors: props.errors ?? [Errors.ALL],\n        resultPath: props.resultPath,\n      },\n    });\n    handler.addIncoming(this);\n    if (this.containingGraph) {\n      handler.bindToGraph(this.containingGraph);\n    }\n  }\n\n  /**\n   * Make the indicated state the default transition of this state\n   */\n  protected makeNext(next: State) {\n    // Can't be called 'setNext' because of JSII\n    if (this._next) {\n      throw new Error(`State '${this.id}' already has a next state`);\n    }\n    this._next = next;\n    next.addIncoming(this);\n    if (this.containingGraph) {\n      next.bindToGraph(this.containingGraph);\n    }\n  }\n\n  /**\n   * Add a choice branch to this state\n   */\n  protected addChoice(\n    condition: Condition,\n    next: State,\n    options?: ChoiceTransitionOptions,\n  ) {\n    this.choices.push({ condition, next, ...options });\n    next.startState.addIncoming(this);\n    if (this.containingGraph) {\n      next.startState.bindToGraph(this.containingGraph);\n    }\n  }\n\n  /**\n   * Add a parallel branch to this state\n   */\n  protected addBranch(branch: StateGraph) {\n    this.branches.push(branch);\n    if (this.containingGraph) {\n      branch.registerSuperGraph(this.containingGraph);\n    }\n  }\n\n  /**\n   * Add a map iterator to this state\n   */\n  protected addIterator(iteration: StateGraph) {\n    this.iteration = iteration;\n    if (this.containingGraph) {\n      iteration.registerSuperGraph(this.containingGraph);\n    }\n  }\n\n  /**\n   * Add a item processor to this state\n   */\n  protected addItemProcessor(\n    processor: StateGraph,\n    config: ProcessorConfig = {},\n  ) {\n    this.processor = processor;\n    this.processorConfig = config;\n    if (this.containingGraph) {\n      processor.registerSuperGraph(this.containingGraph);\n    }\n  }\n\n  /**\n   * Make the indicated state the default choice transition of this state\n   */\n  protected makeDefault(def: State) {\n    // Can't be called 'setDefault' because of JSII\n    if (this.defaultChoice) {\n      throw new Error(`Choice '${this.id}' already has a default next state`);\n    }\n    this.defaultChoice = def;\n  }\n\n  /**\n   * Render the default next state in ASL JSON format\n   */\n  protected renderNextEnd(): any {\n    if (this._next) {\n      return { Next: this._next.stateId };\n    } else {\n      return { End: true };\n    }\n  }\n\n  /**\n   * Render the choices in ASL JSON format\n   */\n  protected renderChoices(): any {\n    return {\n      Choices: renderList(this.choices, renderChoice),\n      Default: this.defaultChoice?.stateId,\n    };\n  }\n\n  /**\n   * Render InputPath/Parameters/OutputPath in ASL JSON format\n   */\n  protected renderInputOutput(): any {\n    return {\n      InputPath: renderJsonPath(this.inputPath),\n      Parameters: this.parameters,\n      OutputPath: renderJsonPath(this.outputPath),\n    };\n  }\n\n  /**\n   * Render parallel branches in ASL JSON format\n   */\n  protected renderBranches(): any {\n    return {\n      Branches: this.branches.map((b) => b.toGraphJson()),\n    };\n  }\n\n  /**\n   * Render map iterator in ASL JSON format\n   */\n  protected renderIterator(): any {\n    if (!this.iteration) return undefined;\n    return {\n      Iterator: this.iteration.toGraphJson(),\n    };\n  }\n\n  /**\n   * Render error recovery options in ASL JSON format\n   */\n  protected renderRetryCatch(): any {\n    return {\n      Retry: renderList(this.retries, renderRetry, (a, b) =>\n        compareErrors(a.errors, b.errors),\n      ),\n      Catch: renderList(this.catches, renderCatch, (a, b) =>\n        compareErrors(a.props.errors, b.props.errors),\n      ),\n    };\n  }\n\n  /**\n   * Render ResultSelector in ASL JSON format\n   */\n  protected renderResultSelector(): any {\n    return FieldUtils.renderObject({\n      ResultSelector: this.resultSelector,\n    });\n  }\n\n  /**\n   * Render ItemProcessor in ASL JSON format\n   */\n  protected renderItemProcessor(): any {\n    if (!this.processor) return undefined;\n    return {\n      ItemProcessor: {\n        ...this.renderProcessorConfig(),\n        ...this.processor.toGraphJson(),\n      },\n    };\n  }\n\n  /**\n   * Render ProcessorConfig in ASL JSON format\n   */\n  private renderProcessorConfig() {\n    const mode = this.processorConfig?.mode?.toString() ?? this.processorMode;\n    if (mode === ProcessorMode.INLINE) {\n      return {\n        ProcessorConfig: {\n          Mode: mode,\n        },\n      };\n    }\n    const executionType = this.processorConfig?.executionType?.toString();\n    return {\n      ProcessorConfig: {\n        Mode: mode,\n        ExecutionType: executionType,\n      },\n    };\n  }\n\n  /**\n   * Called whenever this state is bound to a graph\n   *\n   * Can be overridden by subclasses.\n   */\n  protected whenBoundToGraph(graph: StateGraph) {\n    graph.registerState(this);\n  }\n\n  /**\n   * Add a state to the incoming list\n   */\n  private addIncoming(source: State) {\n    this.incomingStates.push(source);\n  }\n\n  /**\n   * Return all states this state can transition to\n   */\n  private outgoingTransitions(options: FindStateOptions): State[] {\n    const ret = new Array<State>();\n    if (this._next) {\n      ret.push(this._next);\n    }\n    if (this.defaultChoice) {\n      ret.push(this.defaultChoice);\n    }\n    for (const c of this.choices) {\n      ret.push(c.next);\n    }\n    if (options.includeErrorHandlers) {\n      for (const c of this.catches) {\n        ret.push(c.next);\n      }\n    }\n    return ret;\n  }\n}\n\n/**\n * Options for finding reachable states\n */\nexport interface FindStateOptions {\n  /**\n   * Whether or not to follow error-handling transitions\n   *\n   * @default false\n   */\n  readonly includeErrorHandlers?: boolean;\n}\n\n/**\n * A Choice Transition\n */\ninterface ChoiceTransition extends ChoiceTransitionOptions {\n  /**\n   * State to transition to\n   */\n  next: State;\n\n  /**\n   * Condition for this transition\n   */\n  condition: Condition;\n}\n\n/**\n * Options for Choice Transition\n */\nexport interface ChoiceTransitionOptions {\n  /**\n   * An optional description for the choice transition\n   *\n   * @default No comment\n   */\n  readonly comment?: string;\n}\n\n/**\n * Render a choice transition\n */\nfunction renderChoice(c: ChoiceTransition) {\n  return {\n    ...c.condition.renderCondition(),\n    Next: c.next.stateId,\n    Comment: c.comment,\n  };\n}\n\n/**\n * A Catch Transition\n */\ninterface CatchTransition {\n  /**\n   * State to transition to\n   */\n  next: State;\n\n  /**\n   * Additional properties for this transition\n   */\n  props: CatchProps;\n}\n\n/**\n * Render a Retry object to ASL\n */\nfunction renderRetry(retry: RetryProps) {\n  return {\n    ErrorEquals: retry.errors,\n    IntervalSeconds: retry.interval && retry.interval.toSeconds(),\n    MaxAttempts: retry.maxAttempts,\n    BackoffRate: retry.backoffRate,\n    MaxDelaySeconds: retry.maxDelay && retry.maxDelay.toSeconds(),\n    JitterStrategy: retry.jitterStrategy,\n  };\n}\n\n/**\n * Render a Catch object to ASL\n */\nfunction renderCatch(c: CatchTransition) {\n  return {\n    ErrorEquals: c.props.errors,\n    ResultPath: renderJsonPath(c.props.resultPath),\n    Next: c.next.stateId,\n  };\n}\n\n/**\n * Compares a list of Errors to move Errors.ALL last in a sort function\n */\nfunction compareErrors(a?: string[], b?: string[]) {\n  if (a?.includes(Errors.ALL)) {\n    return 1;\n  }\n  if (b?.includes(Errors.ALL)) {\n    return -1;\n  }\n  return 0;\n}\n\n/**\n * Validates an errors list\n */\nfunction validateErrors(errors?: string[]) {\n  if (errors?.includes(Errors.ALL) && errors.length > 1) {\n    throw new Error(`${Errors.ALL} must appear alone in an error list`);\n  }\n}\n\n/**\n * Render a list or return undefined for an empty list\n */\nexport function renderList<T>(\n  xs: T[],\n  mapFn: (x: T) => any,\n  sortFn?: (a: T, b: T) => number,\n): any {\n  if (xs.length === 0) {\n    return undefined;\n  }\n  let list = xs;\n  if (sortFn) {\n    list = xs.sort(sortFn);\n  }\n  return list.map(mapFn);\n}\n\n/**\n * Render JSON path, respecting the special value JsonPath.DISCARD\n */\nexport function renderJsonPath(jsonPath?: string): undefined | null | string {\n  if (jsonPath === undefined) {\n    return undefined;\n  }\n\n  if (!Token.isUnresolved(jsonPath) && !jsonPath.startsWith(\"$\")) {\n    throw new Error(`Expected JSON path to start with '$', got: ${jsonPath}`);\n  }\n  return jsonPath;\n}\n\n/**\n * Interface for structural feature testing (to make TypeScript happy)\n */\ninterface Prefixable {\n  addPrefix(x: string): void;\n}\n\n/**\n * Whether an object is a Prefixable\n */\nfunction isPrefixable(x: any): x is Prefixable {\n  return typeof x === \"object\" && x.addPrefix;\n}\n\n/**\n * Whether an object is INextable\n */\nfunction isNextable(x: any): x is INextable {\n  return typeof x === \"object\" && x.next;\n}\n"]}

package/lib/aws/compute/states/succeed.d.ts

@@ -0,0 +1,51 @@
+import { Construct } from "constructs";
+import { State } from "./state";
+import { INextable } from "../types";
+/**
+ * Properties for defining a Succeed state
+ */
+export interface SucceedProps {
+    /**
+     * Optional name for this state
+     *
+     * @default - The construct ID will be used as state name
+     */
+    readonly stateName?: string;
+    /**
+     * An optional description for this state
+     *
+     * @default No comment
+     */
+    readonly comment?: string;
+    /**
+     * JSONPath expression to select part of the state to be the input to this state.
+     *
+     * May also be the special value JsonPath.DISCARD, which will cause the effective
+     * input to be the empty object {}.
+     *
+     * @default $
+     */
+    readonly inputPath?: string;
+    /**
+     * JSONPath expression to select part of the state to be the output to this state.
+     *
+     * May also be the special value JsonPath.DISCARD, which will cause the effective
+     * output to be the empty object {}.
+     *
+     * @default $
+     */
+    readonly outputPath?: string;
+}
+/**
+ * Define a Succeed state in the state machine
+ *
+ * Reaching a Succeed state terminates the state execution in success.
+ */
+export declare class Succeed extends State {
+    readonly endStates: INextable[];
+    constructor(scope: Construct, id: string, props?: SucceedProps);
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(): object;
+}

package/lib/aws/compute/states/succeed.js

@@ -0,0 +1,32 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Succeed = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const state_type_1 = require("./private/state-type");
+const state_1 = require("./state");
+/**
+ * Define a Succeed state in the state machine
+ *
+ * Reaching a Succeed state terminates the state execution in success.
+ */
+class Succeed extends state_1.State {
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.endStates = [];
+    }
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson() {
+        return {
+            Type: state_type_1.StateType.SUCCEED,
+            Comment: this.comment,
+            ...this.renderInputOutput(),
+        };
+    }
+}
+exports.Succeed = Succeed;
+_a = JSII_RTTI_SYMBOL_1;
+Succeed[_a] = { fqn: "terraconstructs.aws.compute.Succeed", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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