terraconstructs 0.0.8

package/lib/aws/compute/states/map-base.js

@@ -0,0 +1,109 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapBase = exports.isPositiveInteger = 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/map-base.ts
+const cdktf_1 = require("cdktf");
+const state_type_1 = require("./private/state-type");
+const state_1 = require("./state");
+const chain_1 = require("../chain");
+const fields_1 = require("../fields");
+const types_1 = require("../types");
+/**
+ * Returns true if the value passed is a positive integer
+ * @param value the value to validate
+ */
+const isPositiveInteger = (value) => {
+    const isFloat = Math.floor(value) !== value;
+    const isNotPositiveInteger = value < 0 || value > Number.MAX_SAFE_INTEGER;
+    return !isFloat && !isNotPositiveInteger;
+};
+exports.isPositiveInteger = isPositiveInteger;
+/**
+ * Define a Map state in the state machine
+ *
+ * A `Map` state can be used to run a set of steps for each element of an input array.
+ * A Map state will execute the same steps for multiple entries of an array in the state input.
+ *
+ * While the Parallel state executes multiple branches of steps using the same input, a Map state
+ * will execute the same steps for multiple entries of an array in the state input.
+ *
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-map-state.html
+ */
+class MapBase extends state_1.State {
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.endStates = [this];
+        this.maxConcurrency = props.maxConcurrency;
+        this.maxConcurrencyPath = props.maxConcurrencyPath;
+        this.itemsPath = props.itemsPath;
+        this.itemSelector = props.itemSelector;
+    }
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next) {
+        super.makeNext(next.startState);
+        return chain_1.Chain.sequence(this, next);
+    }
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson() {
+        return {
+            Type: state_type_1.StateType.MAP,
+            Comment: this.comment,
+            ResultPath: (0, state_1.renderJsonPath)(this.resultPath),
+            ...this.renderNextEnd(),
+            ...this.renderInputOutput(),
+            ...this.renderResultSelector(),
+            ...this.renderRetryCatch(),
+            ...this.renderItemsPath(),
+            ...this.renderItemSelector(),
+            ...this.renderItemProcessor(),
+            ...(this.maxConcurrency && { MaxConcurrency: this.maxConcurrency }),
+            ...(this.maxConcurrencyPath && {
+                MaxConcurrencyPath: (0, state_1.renderJsonPath)(this.maxConcurrencyPath),
+            }),
+        };
+    }
+    /**
+     * Validate this state
+     */
+    validateState() {
+        const errors = [];
+        if (this.processorConfig?.mode === types_1.ProcessorMode.DISTRIBUTED &&
+            !this.processorConfig?.executionType) {
+            errors.push("You must specify an execution type for the distributed Map workflow");
+        }
+        if (this.maxConcurrency &&
+            !cdktf_1.Token.isUnresolved(this.maxConcurrency) &&
+            !(0, exports.isPositiveInteger)(this.maxConcurrency)) {
+            errors.push("maxConcurrency has to be a positive integer");
+        }
+        if (this.maxConcurrency && this.maxConcurrencyPath) {
+            errors.push("Provide either `maxConcurrency` or `maxConcurrencyPath`, but not both");
+        }
+        return errors;
+    }
+    renderItemsPath() {
+        return {
+            ItemsPath: (0, state_1.renderJsonPath)(this.itemsPath),
+        };
+    }
+    /**
+     * Render ItemSelector in ASL JSON format
+     */
+    renderItemSelector() {
+        if (!this.itemSelector)
+            return undefined;
+        return fields_1.FieldUtils.renderObject({
+            ItemSelector: this.itemSelector,
+        });
+    }
+}
+exports.MapBase = MapBase;
+_a = JSII_RTTI_SYMBOL_1;
+MapBase[_a] = { fqn: "terraconstructs.aws.compute.MapBase", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map-base.js","sourceRoot":"","sources":["../../../../src/aws/compute/states/map-base.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/map-base.ts\n\nimport { Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { StateType } from \"./private/state-type\";\nimport { renderJsonPath, State } from \"./state\";\nimport { Chain } from \"../chain\";\nimport { FieldUtils } from \"../fields\";\nimport { IChainable, INextable, ProcessorMode } from \"../types\";\n\n/**\n * Properties for defining a Map state\n */\nexport interface MapBaseProps {\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   * An optional description for 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   * 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   * JSONPath expression to select the array to iterate over\n   *\n   * @default $\n   */\n  readonly itemsPath?: string;\n\n  /**\n   * The JSON that you want to override your default iteration input (mutually exclusive  with `parameters`).\n   *\n   * @see\n   * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-itemselector.html\n   *\n   * @default $\n   */\n  readonly itemSelector?: { [key: string]: any };\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   * MaxConcurrency\n   *\n   * An upper bound on the number of iterations you want running at once.\n   *\n   * @see\n   * https://docs.aws.amazon.com/step-functions/latest/dg/concepts-asl-use-map-state-inline.html#map-state-inline-additional-fields\n   *\n   * @default - full concurrency\n   */\n  readonly maxConcurrency?: number;\n\n  /**\n   * MaxConcurrencyPath\n   *\n   * A JsonPath that specifies the maximum concurrency dynamically from the state input.\n   *\n   * @see\n   * https://docs.aws.amazon.com/step-functions/latest/dg/concepts-asl-use-map-state-inline.html#map-state-inline-additional-fields\n   *\n   * @default - full concurrency\n   */\n  readonly maxConcurrencyPath?: string;\n}\n\n/**\n * Returns true if the value passed is a positive integer\n * @param value the value to validate\n */\nexport const isPositiveInteger = (value: number) => {\n  const isFloat = Math.floor(value) !== value;\n\n  const isNotPositiveInteger = value < 0 || value > Number.MAX_SAFE_INTEGER;\n\n  return !isFloat && !isNotPositiveInteger;\n};\n\n/**\n * Define a Map state in the state machine\n *\n * A `Map` state can be used to run a set of steps for each element of an input array.\n * A Map state will execute the same steps for multiple entries of an array in the state input.\n *\n * While the Parallel state executes multiple branches of steps using the same input, a Map state\n * will execute the same steps for multiple entries of an array in the state input.\n *\n * @see https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-map-state.html\n */\nexport abstract class MapBase extends State implements INextable {\n  public readonly endStates: INextable[];\n\n  private readonly maxConcurrency?: number;\n  private readonly maxConcurrencyPath?: string;\n  protected readonly itemsPath?: string;\n  protected readonly itemSelector?: { [key: string]: any };\n\n  constructor(scope: Construct, id: string, props: MapBaseProps = {}) {\n    super(scope, id, props);\n    this.endStates = [this];\n    this.maxConcurrency = props.maxConcurrency;\n    this.maxConcurrencyPath = props.maxConcurrencyPath;\n    this.itemsPath = props.itemsPath;\n    this.itemSelector = props.itemSelector;\n  }\n\n  /**\n   * Continue normal execution with the given state\n   */\n  public next(next: IChainable): Chain {\n    super.makeNext(next.startState);\n    return Chain.sequence(this, next);\n  }\n\n  /**\n   * Return the Amazon States Language object for this state\n   */\n  public toStateJson(): object {\n    return {\n      Type: StateType.MAP,\n      Comment: this.comment,\n      ResultPath: renderJsonPath(this.resultPath),\n      ...this.renderNextEnd(),\n      ...this.renderInputOutput(),\n      ...this.renderResultSelector(),\n      ...this.renderRetryCatch(),\n      ...this.renderItemsPath(),\n      ...this.renderItemSelector(),\n      ...this.renderItemProcessor(),\n      ...(this.maxConcurrency && { MaxConcurrency: this.maxConcurrency }),\n      ...(this.maxConcurrencyPath && {\n        MaxConcurrencyPath: renderJsonPath(this.maxConcurrencyPath),\n      }),\n    };\n  }\n\n  /**\n   * Validate this state\n   */\n  protected validateState(): string[] {\n    const errors: string[] = [];\n\n    if (\n      this.processorConfig?.mode === ProcessorMode.DISTRIBUTED &&\n      !this.processorConfig?.executionType\n    ) {\n      errors.push(\n        \"You must specify an execution type for the distributed Map workflow\",\n      );\n    }\n\n    if (\n      this.maxConcurrency &&\n      !Token.isUnresolved(this.maxConcurrency) &&\n      !isPositiveInteger(this.maxConcurrency)\n    ) {\n      errors.push(\"maxConcurrency has to be a positive integer\");\n    }\n\n    if (this.maxConcurrency && this.maxConcurrencyPath) {\n      errors.push(\n        \"Provide either `maxConcurrency` or `maxConcurrencyPath`, but not both\",\n      );\n    }\n\n    return errors;\n  }\n\n  private renderItemsPath(): any {\n    return {\n      ItemsPath: renderJsonPath(this.itemsPath),\n    };\n  }\n\n  /**\n   * Render ItemSelector in ASL JSON format\n   */\n  private renderItemSelector(): any {\n    if (!this.itemSelector) return undefined;\n    return FieldUtils.renderObject({\n      ItemSelector: this.itemSelector,\n    });\n  }\n}\n"]}

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

@@ -0,0 +1,76 @@
+import { Construct } from "constructs";
+import { MapBase, MapBaseProps } from "./map-base";
+import { CatchProps, IChainable, INextable, ProcessorConfig, RetryProps } from "../types";
+/**
+ * Properties for defining a Map state
+ */
+export interface MapProps extends MapBaseProps {
+    /**
+     * The JSON that you want to override your default iteration input (mutually exclusive  with `itemSelector`).
+     *
+     * @deprecated Step Functions has deprecated the `parameters` field in favor of
+     * the new `itemSelector` field
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-itemselector.html
+     *
+     * @default $
+     */
+    readonly parameters?: {
+        [key: string]: any;
+    };
+}
+/**
+ * Define a Map state in the state machine
+ *
+ * A `Map` state can be used to run a set of steps for each element of an input array.
+ * A Map state will execute the same steps for multiple entries of an array in the state input.
+ *
+ * While the Parallel state executes multiple branches of steps using the same input, a Map state
+ * will execute the same steps for multiple entries of an array in the state input.
+ *
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-map-state.html
+ */
+export declare class Map extends MapBase implements INextable {
+    constructor(scope: Construct, id: string, props?: MapProps);
+    /**
+     * Define iterator state machine in Map.
+     *
+     * A Map must either have a non-empty iterator or a non-empty item processor (mutually exclusive  with `itemProcessor`).
+     *
+     * @deprecated - use `itemProcessor` instead.
+     */
+    iterator(iterator: IChainable): Map;
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(): object;
+    /**
+     * Validate this state
+     */
+    protected validateState(): string[];
+    /**
+     * Render Parameters in ASL JSON format
+     */
+    private renderParameters;
+    /**
+     * Add retry configuration for this state
+     *
+     * This controls if and how the execution will be retried if a particular
+     * error occurs.
+     */
+    addRetry(props?: RetryProps): Map;
+    /**
+     * Add a recovery handler for this state
+     *
+     * When a particular error occurs, execution will continue at the error
+     * handler instead of failing the state machine execution.
+     */
+    addCatch(handler: IChainable, props?: CatchProps): Map;
+    /**
+     * Define item processor in Map.
+     *
+     * A Map must either have a non-empty iterator or a non-empty item processor (mutually exclusive  with `iterator`).
+     */
+    itemProcessor(processor: IChainable, config?: ProcessorConfig): Map;
+}

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

@@ -0,0 +1,110 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Map = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const map_base_1 = require("./map-base");
+const fields_1 = require("../fields");
+const state_graph_1 = require("../state-graph");
+const types_1 = require("../types");
+/**
+ * Define a Map state in the state machine
+ *
+ * A `Map` state can be used to run a set of steps for each element of an input array.
+ * A Map state will execute the same steps for multiple entries of an array in the state input.
+ *
+ * While the Parallel state executes multiple branches of steps using the same input, a Map state
+ * will execute the same steps for multiple entries of an array in the state input.
+ *
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-map-state.html
+ */
+class Map extends map_base_1.MapBase {
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.processorMode = types_1.ProcessorMode.INLINE;
+    }
+    /**
+     * Define iterator state machine in Map.
+     *
+     * A Map must either have a non-empty iterator or a non-empty item processor (mutually exclusive  with `itemProcessor`).
+     *
+     * @deprecated - use `itemProcessor` instead.
+     */
+    iterator(iterator) {
+        const name = `Map ${this.stateId} Iterator`;
+        super.addIterator(new state_graph_1.StateGraph(iterator.startState, name));
+        return this;
+    }
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson() {
+        return {
+            ...super.toStateJson(),
+            ...this.renderParameters(),
+            ...this.renderIterator(),
+        };
+    }
+    /**
+     * Validate this state
+     */
+    validateState() {
+        const errors = super.validateState();
+        if (!this.iteration && !this.processor) {
+            errors.push("Map state must either have a non-empty iterator or a non-empty item processor");
+        }
+        if (this.iteration && this.processor) {
+            errors.push("Map state cannot have both an iterator and an item processor");
+        }
+        if (this.parameters && this.itemSelector) {
+            errors.push("Map state cannot have both parameters and an item selector");
+        }
+        return errors;
+    }
+    /**
+     * Render Parameters in ASL JSON format
+     */
+    renderParameters() {
+        if (!this.parameters) {
+            return undefined;
+        }
+        return fields_1.FieldUtils.renderObject({
+            Parameters: this.parameters,
+        });
+    }
+    /**
+     * Add retry configuration for this state
+     *
+     * This controls if and how the execution will be retried if a particular
+     * error occurs.
+     */
+    addRetry(props = {}) {
+        super._addRetry(props);
+        return this;
+    }
+    /**
+     * Add a recovery handler for this state
+     *
+     * When a particular error occurs, execution will continue at the error
+     * handler instead of failing the state machine execution.
+     */
+    addCatch(handler, props = {}) {
+        super._addCatch(handler.startState, props);
+        return this;
+    }
+    /**
+     * Define item processor in Map.
+     *
+     * A Map must either have a non-empty iterator or a non-empty item processor (mutually exclusive  with `iterator`).
+     */
+    itemProcessor(processor, config = {}) {
+        const name = `Map ${this.stateId} Item Processor`;
+        const stateGraph = new state_graph_1.StateGraph(processor.startState, name);
+        super.addItemProcessor(stateGraph, config);
+        return this;
+    }
+}
+exports.Map = Map;
+_a = JSII_RTTI_SYMBOL_1;
+Map[_a] = { fqn: "terraconstructs.aws.compute.Map", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map.js","sourceRoot":"","sources":["../../../../src/aws/compute/states/map.ts"],"names":[],"mappings":";;;;;AAGA,yCAAmD;AACnD,sCAAuC;AACvC,gDAA4C;AAC5C,oCAOkB;AAoBlB;;;;;;;;;;GAUG;AACH,MAAa,GAAI,SAAQ,kBAAO;IAC9B,YAAY,KAAgB,EAAE,EAAU,EAAE,QAAkB,EAAE;QAC5D,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QACxB,IAAI,CAAC,aAAa,GAAG,qBAAa,CAAC,MAAM,CAAC;IAC5C,CAAC;IAED;;;;;;OAMG;IACI,QAAQ,CAAC,QAAoB;QAClC,MAAM,IAAI,GAAG,OAAO,IAAI,CAAC,OAAO,WAAW,CAAC;QAC5C,KAAK,CAAC,WAAW,CAAC,IAAI,wBAAU,CAAC,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC;QAC7D,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACI,WAAW;QAChB,OAAO;YACL,GAAG,KAAK,CAAC,WAAW,EAAE;YACtB,GAAG,IAAI,CAAC,gBAAgB,EAAE;YAC1B,GAAG,IAAI,CAAC,cAAc,EAAE;SACzB,CAAC;IACJ,CAAC;IAED;;OAEG;IACO,aAAa;QACrB,MAAM,MAAM,GAAG,KAAK,CAAC,aAAa,EAAE,CAAC;QAErC,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACvC,MAAM,CAAC,IAAI,CACT,+EAA+E,CAChF,CAAC;QACJ,CAAC;QAED,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACrC,MAAM,CAAC,IAAI,CACT,8DAA8D,CAC/D,CAAC;QACJ,CAAC;QAED,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACzC,MAAM,CAAC,IAAI,CAAC,4DAA4D,CAAC,CAAC;QAC5E,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACK,gBAAgB;QACtB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO,mBAAU,CAAC,YAAY,CAAC;YAC7B,UAAU,EAAE,IAAI,CAAC,UAAU;SAC5B,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACI,QAAQ,CAAC,QAAoB,EAAE;QACpC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACvB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACI,QAAQ,CAAC,OAAmB,EAAE,QAAoB,EAAE;QACzD,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;QAC3C,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACI,aAAa,CAClB,SAAqB,EACrB,SAA0B,EAAE;QAE5B,MAAM,IAAI,GAAG,OAAO,IAAI,CAAC,OAAO,iBAAiB,CAAC;QAClD,MAAM,UAAU,GAAG,IAAI,wBAAU,CAAC,SAAS,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;QAC9D,KAAK,CAAC,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;QAC3C,OAAO,IAAI,CAAC;IACd,CAAC;;AAtGH,kBAuGC","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-stepfunctions/lib/states/map.ts\n\nimport { Construct } from \"constructs\";\nimport { MapBase, MapBaseProps } from \"./map-base\";\nimport { FieldUtils } from \"../fields\";\nimport { StateGraph } from \"../state-graph\";\nimport {\n  CatchProps,\n  IChainable,\n  INextable,\n  ProcessorConfig,\n  ProcessorMode,\n  RetryProps,\n} from \"../types\";\n\n/**\n * Properties for defining a Map state\n */\nexport interface MapProps extends MapBaseProps {\n  /**\n   * The JSON that you want to override your default iteration input (mutually exclusive  with `itemSelector`).\n   *\n   * @deprecated Step Functions has deprecated the `parameters` field in favor of\n   * the new `itemSelector` field\n   *\n   * @see\n   * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-itemselector.html\n   *\n   * @default $\n   */\n  readonly parameters?: { [key: string]: any };\n}\n\n/**\n * Define a Map state in the state machine\n *\n * A `Map` state can be used to run a set of steps for each element of an input array.\n * A Map state will execute the same steps for multiple entries of an array in the state input.\n *\n * While the Parallel state executes multiple branches of steps using the same input, a Map state\n * will execute the same steps for multiple entries of an array in the state input.\n *\n * @see https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-map-state.html\n */\nexport class Map extends MapBase implements INextable {\n  constructor(scope: Construct, id: string, props: MapProps = {}) {\n    super(scope, id, props);\n    this.processorMode = ProcessorMode.INLINE;\n  }\n\n  /**\n   * Define iterator state machine in Map.\n   *\n   * A Map must either have a non-empty iterator or a non-empty item processor (mutually exclusive  with `itemProcessor`).\n   *\n   * @deprecated - use `itemProcessor` instead.\n   */\n  public iterator(iterator: IChainable): Map {\n    const name = `Map ${this.stateId} Iterator`;\n    super.addIterator(new StateGraph(iterator.startState, name));\n    return this;\n  }\n\n  /**\n   * Return the Amazon States Language object for this state\n   */\n  public toStateJson(): object {\n    return {\n      ...super.toStateJson(),\n      ...this.renderParameters(),\n      ...this.renderIterator(),\n    };\n  }\n\n  /**\n   * Validate this state\n   */\n  protected validateState(): string[] {\n    const errors = super.validateState();\n\n    if (!this.iteration && !this.processor) {\n      errors.push(\n        \"Map state must either have a non-empty iterator or a non-empty item processor\",\n      );\n    }\n\n    if (this.iteration && this.processor) {\n      errors.push(\n        \"Map state cannot have both an iterator and an item processor\",\n      );\n    }\n\n    if (this.parameters && this.itemSelector) {\n      errors.push(\"Map state cannot have both parameters and an item selector\");\n    }\n\n    return errors;\n  }\n\n  /**\n   * Render Parameters in ASL JSON format\n   */\n  private renderParameters(): any {\n    if (!this.parameters) {\n      return undefined;\n    }\n    return FieldUtils.renderObject({\n      Parameters: this.parameters,\n    });\n  }\n\n  /**\n   * Add retry configuration for this state\n   *\n   * This controls if and how the execution will be retried if a particular\n   * error occurs.\n   */\n  public addRetry(props: RetryProps = {}): Map {\n    super._addRetry(props);\n    return this;\n  }\n\n  /**\n   * Add a recovery handler for this state\n   *\n   * When a particular error occurs, execution will continue at the error\n   * handler instead of failing the state machine execution.\n   */\n  public addCatch(handler: IChainable, props: CatchProps = {}): Map {\n    super._addCatch(handler.startState, props);\n    return this;\n  }\n\n  /**\n   * Define item processor in Map.\n   *\n   * A Map must either have a non-empty iterator or a non-empty item processor (mutually exclusive  with `iterator`).\n   */\n  public itemProcessor(\n    processor: IChainable,\n    config: ProcessorConfig = {},\n  ): Map {\n    const name = `Map ${this.stateId} Item Processor`;\n    const stateGraph = new StateGraph(processor.startState, name);\n    super.addItemProcessor(stateGraph, config);\n    return this;\n  }\n}\n"]}

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

@@ -0,0 +1,113 @@
+import { Construct } from "constructs";
+import { State } from "./state";
+import { Chain } from "../chain";
+import { StateGraph } from "../state-graph";
+import { CatchProps, IChainable, INextable, RetryProps } from "../types";
+/**
+ * Properties for defining a Parallel state
+ */
+export interface ParallelProps {
+    /**
+     * 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;
+    /**
+     * JSONPath expression to indicate where to inject the state's output
+     *
+     * May also be the special value JsonPath.DISCARD, which will cause the state's
+     * input to become its output.
+     *
+     * @default $
+     */
+    readonly resultPath?: string;
+    /**
+     * The JSON that will replace the state's raw result and become the effective
+     * result before ResultPath is applied.
+     *
+     * You can use ResultSelector to create a payload with values that are static
+     * or selected from the state's raw result.
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-inputpath-params.html#input-output-resultselector
+     *
+     * @default - None
+     */
+    readonly resultSelector?: {
+        [key: string]: any;
+    };
+}
+/**
+ * Define a Parallel state in the state machine
+ *
+ * A Parallel state can be used to run one or more state machines at the same
+ * time.
+ *
+ * The Result of a Parallel state is an array of the results of its substatemachines.
+ */
+export declare class Parallel extends State implements INextable {
+    readonly endStates: INextable[];
+    private readonly _branches;
+    constructor(scope: Construct, id: string, props?: ParallelProps);
+    /**
+     * Add retry configuration for this state
+     *
+     * This controls if and how the execution will be retried if a particular
+     * error occurs.
+     */
+    addRetry(props?: RetryProps): Parallel;
+    /**
+     * Add a recovery handler for this state
+     *
+     * When a particular error occurs, execution will continue at the error
+     * handler instead of failing the state machine execution.
+     */
+    addCatch(handler: IChainable, props?: CatchProps): Parallel;
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next: IChainable): Chain;
+    /**
+     * Define one or more branches to run in parallel
+     */
+    branch(...branches: IChainable[]): Parallel;
+    /**
+     * Overwrites State.bindToGraph. Adds branches to
+     * the Parallel state here so that any necessary
+     * prefixes are appended first.
+     */
+    bindToGraph(graph: StateGraph): void;
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(): object;
+    /**
+     * Validate this state
+     */
+    protected validateState(): string[];
+}

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

@@ -0,0 +1,100 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parallel = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const state_type_1 = require("./private/state-type");
+const state_1 = require("./state");
+const chain_1 = require("../chain");
+const state_graph_1 = require("../state-graph");
+/**
+ * Define a Parallel state in the state machine
+ *
+ * A Parallel state can be used to run one or more state machines at the same
+ * time.
+ *
+ * The Result of a Parallel state is an array of the results of its substatemachines.
+ */
+class Parallel extends state_1.State {
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this._branches = [];
+        this.endStates = [this];
+    }
+    /**
+     * Add retry configuration for this state
+     *
+     * This controls if and how the execution will be retried if a particular
+     * error occurs.
+     */
+    addRetry(props = {}) {
+        super._addRetry(props);
+        return this;
+    }
+    /**
+     * Add a recovery handler for this state
+     *
+     * When a particular error occurs, execution will continue at the error
+     * handler instead of failing the state machine execution.
+     */
+    addCatch(handler, props = {}) {
+        super._addCatch(handler.startState, props);
+        return this;
+    }
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next) {
+        super.makeNext(next.startState);
+        return chain_1.Chain.sequence(this, next);
+    }
+    /**
+     * Define one or more branches to run in parallel
+     */
+    branch(...branches) {
+        // Store branches for late-bound stategraph creation when we call bindToGraph.
+        this._branches.push(...branches);
+        return this;
+    }
+    /**
+     * Overwrites State.bindToGraph. Adds branches to
+     * the Parallel state here so that any necessary
+     * prefixes are appended first.
+     */
+    bindToGraph(graph) {
+        for (const branch of this._branches) {
+            const name = `Parallel '${this.stateId}' branch ${this.branches.length + 1}`;
+            super.addBranch(new state_graph_1.StateGraph(branch.startState, name));
+        }
+        this._branches.splice(0, this._branches.length);
+        return super.bindToGraph(graph);
+    }
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson() {
+        return {
+            Type: state_type_1.StateType.PARALLEL,
+            Comment: this.comment,
+            ResultPath: (0, state_1.renderJsonPath)(this.resultPath),
+            ...this.renderNextEnd(),
+            ...this.renderInputOutput(),
+            ...this.renderRetryCatch(),
+            ...this.renderBranches(),
+            ...this.renderResultSelector(),
+        };
+    }
+    /**
+     * Validate this state
+     */
+    validateState() {
+        if (this.branches.length === 0) {
+            return ["Parallel must have at least one branch"];
+        }
+        return [];
+    }
+}
+exports.Parallel = Parallel;
+_a = JSII_RTTI_SYMBOL_1;
+Parallel[_a] = { fqn: "terraconstructs.aws.compute.Parallel", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parallel.js","sourceRoot":"","sources":["../../../../src/aws/compute/states/parallel.ts"],"names":[],"mappings":";;;;;AAGA,qDAAiD;AACjD,mCAAgD;AAChD,oCAAiC;AACjC,gDAA4C;AAkE5C;;;;;;;GAOG;AACH,MAAa,QAAS,SAAQ,aAAK;IAIjC,YAAY,KAAgB,EAAE,EAAU,EAAE,QAAuB,EAAE;QACjE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QAHT,cAAS,GAAiB,EAAE,CAAC;QAK5C,IAAI,CAAC,SAAS,GAAG,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED;;;;;OAKG;IACI,QAAQ,CAAC,QAAoB,EAAE;QACpC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACvB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACI,QAAQ,CAAC,OAAmB,EAAE,QAAoB,EAAE;QACzD,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;QAC3C,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACI,IAAI,CAAC,IAAgB;QAC1B,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAChC,OAAO,aAAK,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACpC,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,GAAG,QAAsB;QACrC,8EAA8E;QAC9E,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,CAAC;QACjC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACI,WAAW,CAAC,KAAiB;QAClC,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACpC,MAAM,IAAI,GAAG,aAAa,IAAI,CAAC,OAAO,YAAY,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC7E,KAAK,CAAC,SAAS,CAAC,IAAI,wBAAU,CAAC,MAAM,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC;QAC3D,CAAC;QACD,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAChD,OAAO,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAED;;OAEG;IACI,WAAW;QAChB,OAAO;YACL,IAAI,EAAE,sBAAS,CAAC,QAAQ;YACxB,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,UAAU,EAAE,IAAA,sBAAc,EAAC,IAAI,CAAC,UAAU,CAAC;YAC3C,GAAG,IAAI,CAAC,aAAa,EAAE;YACvB,GAAG,IAAI,CAAC,iBAAiB,EAAE;YAC3B,GAAG,IAAI,CAAC,gBAAgB,EAAE;YAC1B,GAAG,IAAI,CAAC,cAAc,EAAE;YACxB,GAAG,IAAI,CAAC,oBAAoB,EAAE;SAC/B,CAAC;IACJ,CAAC;IAED;;OAEG;IACO,aAAa;QACrB,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC/B,OAAO,CAAC,wCAAwC,CAAC,CAAC;QACpD,CAAC;QACD,OAAO,EAAE,CAAC;IACZ,CAAC;;AAvFH,4BAwFC","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-stepfunctions/lib/states/parallel.ts\n\nimport { Construct } from \"constructs\";\nimport { StateType } from \"./private/state-type\";\nimport { renderJsonPath, State } from \"./state\";\nimport { Chain } from \"../chain\";\nimport { StateGraph } from \"../state-graph\";\nimport { CatchProps, IChainable, INextable, RetryProps } from \"../types\";\n\n/**\n * Properties for defining a Parallel state\n */\nexport interface ParallelProps {\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   * An optional description for 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   * 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 * Define a Parallel state in the state machine\n *\n * A Parallel state can be used to run one or more state machines at the same\n * time.\n *\n * The Result of a Parallel state is an array of the results of its substatemachines.\n */\nexport class Parallel extends State implements INextable {\n  public readonly endStates: INextable[];\n  private readonly _branches: IChainable[] = [];\n\n  constructor(scope: Construct, id: string, props: ParallelProps = {}) {\n    super(scope, id, props);\n\n    this.endStates = [this];\n  }\n\n  /**\n   * Add retry configuration for this state\n   *\n   * This controls if and how the execution will be retried if a particular\n   * error occurs.\n   */\n  public addRetry(props: RetryProps = {}): Parallel {\n    super._addRetry(props);\n    return this;\n  }\n\n  /**\n   * Add a recovery handler for this state\n   *\n   * When a particular error occurs, execution will continue at the error\n   * handler instead of failing the state machine execution.\n   */\n  public addCatch(handler: IChainable, props: CatchProps = {}): Parallel {\n    super._addCatch(handler.startState, props);\n    return this;\n  }\n\n  /**\n   * Continue normal execution with the given state\n   */\n  public next(next: IChainable): Chain {\n    super.makeNext(next.startState);\n    return Chain.sequence(this, next);\n  }\n\n  /**\n   * Define one or more branches to run in parallel\n   */\n  public branch(...branches: IChainable[]): Parallel {\n    // Store branches for late-bound stategraph creation when we call bindToGraph.\n    this._branches.push(...branches);\n    return this;\n  }\n\n  /**\n   * Overwrites State.bindToGraph. Adds branches to\n   * the Parallel state here so that any necessary\n   * prefixes are appended first.\n   */\n  public bindToGraph(graph: StateGraph) {\n    for (const branch of this._branches) {\n      const name = `Parallel '${this.stateId}' branch ${this.branches.length + 1}`;\n      super.addBranch(new StateGraph(branch.startState, name));\n    }\n    this._branches.splice(0, this._branches.length);\n    return super.bindToGraph(graph);\n  }\n\n  /**\n   * Return the Amazon States Language object for this state\n   */\n  public toStateJson(): object {\n    return {\n      Type: StateType.PARALLEL,\n      Comment: this.comment,\n      ResultPath: renderJsonPath(this.resultPath),\n      ...this.renderNextEnd(),\n      ...this.renderInputOutput(),\n      ...this.renderRetryCatch(),\n      ...this.renderBranches(),\n      ...this.renderResultSelector(),\n    };\n  }\n\n  /**\n   * Validate this state\n   */\n  protected validateState(): string[] {\n    if (this.branches.length === 0) {\n      return [\"Parallel must have at least one branch\"];\n    }\n    return [];\n  }\n}\n"]}