terraconstructs 0.0.8

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

@@ -0,0 +1,207 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributedMap = 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/distributed-map.ts
+const cdktf_1 = require("cdktf");
+const map_base_1 = require("./map-base");
+const fields_1 = require("../fields");
+const state_graph_1 = require("../state-graph");
+const state_machine_1 = require("../state-machine");
+const types_1 = require("../types");
+const DISTRIBUTED_MAP_SYMBOL = Symbol.for("terraconstructs/lib/aws/compute.DistributedMap");
+/**
+ * Define a Distributed Mode 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.
+ *
+ * A `Map` state in `Distributed` mode will execute a child workflow for each iteration of the Map state.
+ * This serves to increase concurrency and allows for larger workloads to be run in a single state machine.
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-asl-use-map-state-distributed.html
+ */
+class DistributedMap extends map_base_1.MapBase {
+    /**
+     * Return whether the given object is a DistributedMap.
+     */
+    static isDistributedMap(x) {
+        return x !== null && typeof x === "object" && DISTRIBUTED_MAP_SYMBOL in x;
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.mapExecutionType = props.mapExecutionType ?? state_machine_1.StateMachineType.STANDARD;
+        this.itemReader = props.itemReader;
+        this.toleratedFailurePercentage = props.toleratedFailurePercentage;
+        this.toleratedFailurePercentagePath = props.toleratedFailurePercentagePath;
+        this.toleratedFailureCount = props.toleratedFailureCount;
+        this.toleratedFailureCountPath = props.toleratedFailureCountPath;
+        this.label = props.label;
+        this.itemBatcher = props.itemBatcher;
+        this.resultWriter = props.resultWriter;
+        this.processorMode = types_1.ProcessorMode.DISTRIBUTED;
+    }
+    /**
+     * Validate this state
+     */
+    validateState() {
+        const errors = super.validateState();
+        if (this.processorConfig?.mode === types_1.ProcessorMode.INLINE) {
+            errors.push("Processing mode cannot be `INLINE` for a Distributed Map");
+        }
+        if (this.itemsPath && this.itemReader) {
+            errors.push("Provide either `itemsPath` or `itemReader`, but not both");
+        }
+        if (this.toleratedFailurePercentage &&
+            this.toleratedFailurePercentagePath) {
+            errors.push("Provide either `toleratedFailurePercentage` or `toleratedFailurePercentagePath`, but not both");
+        }
+        if (this.toleratedFailurePercentage &&
+            !(this.toleratedFailurePercentage >= 0 &&
+                this.toleratedFailurePercentage <= 100)) {
+            errors.push("toleratedFailurePercentage must be between 0 and 100");
+        }
+        if (this.toleratedFailureCount && this.toleratedFailureCountPath) {
+            errors.push("Provide either `toleratedFailureCount` or `toleratedFailureCountPath`, but not both");
+        }
+        if (this.itemBatcher) {
+            errors.push(...this.itemBatcher.validateItemBatcher());
+        }
+        if (this.itemReader) {
+            errors.push(...this.itemReader.validateItemReader());
+        }
+        if (this.label) {
+            if (this.label.length > 40) {
+                errors.push("label must be 40 characters or less");
+            }
+            let labelRegex = /[\s\?\*\<\>\{\}\\[\]\:\;\,\|\^\~\$\#\%\&\`\"]|[\u0000-\u001f]|[\u007f-\u009f]/gi;
+            if (labelRegex.test(this.label)) {
+                errors.push("label cannot contain any whitespace or special characters");
+            }
+        }
+        return errors;
+    }
+    whenBoundToGraph(graph) {
+        super.whenBoundToGraph(graph);
+        if (this.resultWriter) {
+            this.resultWriter.providePolicyStatements().forEach((policyStatement) => {
+                graph.registerPolicyStatement(policyStatement);
+            });
+        }
+        if (this.itemReader) {
+            this.itemReader.providePolicyStatements().forEach((policyStatement) => {
+                graph.registerPolicyStatement(policyStatement);
+            });
+        }
+    }
+    /**
+     * 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 a Distributed Map.
+     *
+     * A Distributed Map must have a non-empty item processor
+     */
+    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;
+    }
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson() {
+        let rendered = super.toStateJson();
+        if (rendered.ItemProcessor.ProcessorConfig.ExecutionType) {
+            // "@aws-cdk/aws-stepfunctions:propertyIgnored", // TODO: CDKTF does not support acknowledgeable warnings
+            cdktf_1.Annotations.of(this).addWarning("Property 'ProcessorConfig.executionType' is ignored, use the 'mapExecutionType' in the 'DistributedMap' class instead.");
+        }
+        rendered.ItemProcessor.ProcessorConfig.ExecutionType =
+            this.mapExecutionType;
+        return {
+            ...rendered,
+            ...this.renderItemReader(),
+            ...this.renderItemBatcher(),
+            ...(this.toleratedFailurePercentage && {
+                ToleratedFailurePercentage: this.toleratedFailurePercentage,
+            }),
+            ...(this.toleratedFailurePercentagePath && {
+                ToleratedFailurePercentagePath: this.toleratedFailurePercentagePath,
+            }),
+            ...(this.toleratedFailureCount && {
+                ToleratedFailureCount: this.toleratedFailureCount,
+            }),
+            ...(this.toleratedFailureCountPath && {
+                ToleratedFailureCountPath: this.toleratedFailureCountPath,
+            }),
+            ...(this.label && { Label: this.label }),
+            ...this.renderResultWriter(),
+        };
+    }
+    /**
+     * Render the ItemReader as JSON object
+     */
+    renderItemReader() {
+        if (!this.itemReader) {
+            return undefined;
+        }
+        return fields_1.FieldUtils.renderObject({
+            ItemReader: this.itemReader.render(),
+        });
+    }
+    /**
+     * Render ResultWriter in ASL JSON format
+     */
+    renderResultWriter() {
+        if (!this.resultWriter) {
+            return undefined;
+        }
+        return fields_1.FieldUtils.renderObject({
+            ResultWriter: this.resultWriter.render(),
+        });
+    }
+    /**
+     * Render ItemBatcher in ASL JSON format
+     */
+    renderItemBatcher() {
+        if (!this.itemBatcher) {
+            return undefined;
+        }
+        return {
+            ItemBatcher: this.itemBatcher.render(),
+        };
+    }
+}
+exports.DistributedMap = DistributedMap;
+_a = JSII_RTTI_SYMBOL_1;
+DistributedMap[_a] = { fqn: "terraconstructs.aws.compute.DistributedMap", version: "0.0.8" };
+/**
+ * Mark all instances of 'DistributeMap'.
+ */
+Object.defineProperty(DistributedMap.prototype, DISTRIBUTED_MAP_SYMBOL, {
+    value: true,
+    enumerable: false,
+    writable: false,
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"distributed-map.js","sourceRoot":"","sources":["../../../../src/aws/compute/states/distributed-map.ts"],"names":[],"mappings":";;;;;AAAA,oHAAoH;AAEpH,iCAAoC;AAKpC,yCAAmD;AACnD,sCAAuC;AACvC,gDAA4C;AAC5C,oDAAoD;AACpD,oCAOkB;AAElB,MAAM,sBAAsB,GAAG,MAAM,CAAC,GAAG,CACvC,gDAAgD,CACjD,CAAC;AAsFF;;;;;;;;;;;;GAYG;AACH,MAAa,cAAe,SAAQ,kBAAO;IACzC;;OAEG;IACI,MAAM,CAAC,gBAAgB,CAAC,CAAM;QACnC,OAAO,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,sBAAsB,IAAI,CAAC,CAAC;IAC5E,CAAC;IAYD,YAAY,KAAgB,EAAE,EAAU,EAAE,QAA6B,EAAE;QACvE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QACxB,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC,gBAAgB,IAAI,gCAAgB,CAAC,QAAQ,CAAC;QAC5E,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC;QACnC,IAAI,CAAC,0BAA0B,GAAG,KAAK,CAAC,0BAA0B,CAAC;QACnE,IAAI,CAAC,8BAA8B,GAAG,KAAK,CAAC,8BAA8B,CAAC;QAC3E,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC,qBAAqB,CAAC;QACzD,IAAI,CAAC,yBAAyB,GAAG,KAAK,CAAC,yBAAyB,CAAC;QACjE,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QACzB,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;QACrC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC;QACvC,IAAI,CAAC,aAAa,GAAG,qBAAa,CAAC,WAAW,CAAC;IACjD,CAAC;IAED;;OAEG;IACO,aAAa;QACrB,MAAM,MAAM,GAAa,KAAK,CAAC,aAAa,EAAE,CAAC;QAE/C,IAAI,IAAI,CAAC,eAAe,EAAE,IAAI,KAAK,qBAAa,CAAC,MAAM,EAAE,CAAC;YACxD,MAAM,CAAC,IAAI,CAAC,0DAA0D,CAAC,CAAC;QAC1E,CAAC;QAED,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACtC,MAAM,CAAC,IAAI,CAAC,0DAA0D,CAAC,CAAC;QAC1E,CAAC;QAED,IACE,IAAI,CAAC,0BAA0B;YAC/B,IAAI,CAAC,8BAA8B,EACnC,CAAC;YACD,MAAM,CAAC,IAAI,CACT,+FAA+F,CAChG,CAAC;QACJ,CAAC;QAED,IACE,IAAI,CAAC,0BAA0B;YAC/B,CAAC,CACC,IAAI,CAAC,0BAA0B,IAAI,CAAC;gBACpC,IAAI,CAAC,0BAA0B,IAAI,GAAG,CACvC,EACD,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,sDAAsD,CAAC,CAAC;QACtE,CAAC;QAED,IAAI,IAAI,CAAC,qBAAqB,IAAI,IAAI,CAAC,yBAAyB,EAAE,CAAC;YACjE,MAAM,CAAC,IAAI,CACT,qFAAqF,CACtF,CAAC;QACJ,CAAC;QAED,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,mBAAmB,EAAE,CAAC,CAAC;QACzD,CAAC;QAED,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,kBAAkB,EAAE,CAAC,CAAC;QACvD,CAAC;QAED,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;gBAC3B,MAAM,CAAC,IAAI,CAAC,qCAAqC,CAAC,CAAC;YACrD,CAAC;YAED,IAAI,UAAU,GACZ,iFAAiF,CAAC;YACpF,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;gBAChC,MAAM,CAAC,IAAI,CACT,2DAA2D,CAC5D,CAAC;YACJ,CAAC;QACH,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAES,gBAAgB,CAAC,KAAiB;QAC1C,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAC9B,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,IAAI,CAAC,YAAY,CAAC,uBAAuB,EAAE,CAAC,OAAO,CAAC,CAAC,eAAe,EAAE,EAAE;gBACtE,KAAK,CAAC,uBAAuB,CAAC,eAAe,CAAC,CAAC;YACjD,CAAC,CAAC,CAAC;QACL,CAAC;QACD,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,IAAI,CAAC,UAAU,CAAC,uBAAuB,EAAE,CAAC,OAAO,CAAC,CAAC,eAAe,EAAE,EAAE;gBACpE,KAAK,CAAC,uBAAuB,CAAC,eAAe,CAAC,CAAC;YACjD,CAAC,CAAC,CAAC;QACL,CAAC;IACH,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;IAED;;OAEG;IACI,WAAW;QAChB,IAAI,QAAQ,GAAQ,KAAK,CAAC,WAAW,EAAE,CAAC;QACxC,IAAI,QAAQ,CAAC,aAAa,CAAC,eAAe,CAAC,aAAa,EAAE,CAAC;YACzD,yGAAyG;YACzG,mBAAW,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,UAAU,CAC7B,wHAAwH,CACzH,CAAC;QACJ,CAAC;QACD,QAAQ,CAAC,aAAa,CAAC,eAAe,CAAC,aAAa;YAClD,IAAI,CAAC,gBAAgB,CAAC;QAExB,OAAO;YACL,GAAG,QAAQ;YACX,GAAG,IAAI,CAAC,gBAAgB,EAAE;YAC1B,GAAG,IAAI,CAAC,iBAAiB,EAAE;YAC3B,GAAG,CAAC,IAAI,CAAC,0BAA0B,IAAI;gBACrC,0BAA0B,EAAE,IAAI,CAAC,0BAA0B;aAC5D,CAAC;YACF,GAAG,CAAC,IAAI,CAAC,8BAA8B,IAAI;gBACzC,8BAA8B,EAAE,IAAI,CAAC,8BAA8B;aACpE,CAAC;YACF,GAAG,CAAC,IAAI,CAAC,qBAAqB,IAAI;gBAChC,qBAAqB,EAAE,IAAI,CAAC,qBAAqB;aAClD,CAAC;YACF,GAAG,CAAC,IAAI,CAAC,yBAAyB,IAAI;gBACpC,yBAAyB,EAAE,IAAI,CAAC,yBAAyB;aAC1D,CAAC;YACF,GAAG,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC;YACxC,GAAG,IAAI,CAAC,kBAAkB,EAAE;SAC7B,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,gBAAgB;QACtB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,mBAAU,CAAC,YAAY,CAAC;YAC7B,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE;SACrC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,kBAAkB;QACxB,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,mBAAU,CAAC,YAAY,CAAC;YAC7B,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE;SACzC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,iBAAiB;QACvB,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACtB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO;YACL,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE;SACvC,CAAC;IACJ,CAAC;;AA3NH,wCA4NC;;;AAED;;GAEG;AACH,MAAM,CAAC,cAAc,CAAC,cAAc,CAAC,SAAS,EAAE,sBAAsB,EAAE;IACtE,KAAK,EAAE,IAAI;IACX,UAAU,EAAE,KAAK;IACjB,QAAQ,EAAE,KAAK;CAChB,CAAC,CAAC","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-stepfunctions/lib/states/distributed-map.ts\n\nimport { Annotations } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ItemBatcher } from \"./distributed-map/item-batcher\";\nimport { IItemReader } from \"./distributed-map/item-reader\";\nimport { ResultWriter } from \"./distributed-map/result-writer\";\nimport { MapBase, MapBaseProps } from \"./map-base\";\nimport { FieldUtils } from \"../fields\";\nimport { StateGraph } from \"../state-graph\";\nimport { StateMachineType } from \"../state-machine\";\nimport {\n  CatchProps,\n  IChainable,\n  INextable,\n  ProcessorConfig,\n  ProcessorMode,\n  RetryProps,\n} from \"../types\";\n\nconst DISTRIBUTED_MAP_SYMBOL = Symbol.for(\n  \"terraconstructs/lib/aws/compute.DistributedMap\",\n);\n\n/**\n * Properties for configuring a Distribute Map state\n */\nexport interface DistributedMapProps extends MapBaseProps {\n  /**\n   * MapExecutionType\n   *\n   * The execution type of the distributed map state\n   *\n   * This property overwrites ProcessorConfig.executionType\n   *\n   * @default StateMachineType.STANDARD\n   */\n  readonly mapExecutionType?: StateMachineType;\n\n  /**\n   * ItemReader\n   *\n   * Configuration for where to read items dataset in S3 to iterate\n   *\n   * @default - No itemReader\n   */\n  readonly itemReader?: IItemReader;\n\n  /**\n   * ToleratedFailurePercentage\n   *\n   * Percentage of failed items to tolerate in a Map Run, as static number\n   *\n   * @default - No toleratedFailurePercentage\n   */\n  readonly toleratedFailurePercentage?: number;\n\n  /**\n   * ToleratedFailurePercentagePath\n   *\n   * Percentage of failed items to tolerate in a Map Run, as JsonPath\n   *\n   * @default - No toleratedFailurePercentagePath\n   */\n  readonly toleratedFailurePercentagePath?: string;\n\n  /**\n   * ToleratedFailureCount\n   *\n   * Number of failed items to tolerate in a Map Run, as static number\n   *\n   * @default - No toleratedFailureCount\n   */\n  readonly toleratedFailureCount?: number;\n\n  /**\n   * ToleratedFailureCountPath\n   *\n   * Number of failed items to tolerate in a Map Run, as JsonPath\n   *\n   * @default - No toleratedFailureCountPath\n   */\n  readonly toleratedFailureCountPath?: string;\n\n  /**\n   * Label\n   *\n   * Unique name for the Distributed Map state added to each Map Run\n   *\n   * @default - No label\n   */\n  readonly label?: string;\n\n  /**\n   * Configuration for S3 location in which to save Map Run results\n   *\n   * @default - No resultWriter\n   */\n  readonly resultWriter?: ResultWriter;\n\n  /**\n   * Specifies to process a group of items in a single child workflow execution\n   *\n   * @default - No itemBatcher\n   */\n  readonly itemBatcher?: ItemBatcher;\n}\n\n/**\n * Define a Distributed Mode 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 * A `Map` state in `Distributed` mode will execute a child workflow for each iteration of the Map state.\n * This serves to increase concurrency and allows for larger workloads to be run in a single state machine.\n * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-asl-use-map-state-distributed.html\n */\nexport class DistributedMap extends MapBase implements INextable {\n  /**\n   * Return whether the given object is a DistributedMap.\n   */\n  public static isDistributedMap(x: any): x is DistributedMap {\n    return x !== null && typeof x === \"object\" && DISTRIBUTED_MAP_SYMBOL in x;\n  }\n\n  private readonly mapExecutionType?: StateMachineType;\n  private readonly itemReader?: IItemReader;\n  private readonly toleratedFailurePercentage?: number;\n  private readonly toleratedFailurePercentagePath?: string;\n  private readonly toleratedFailureCount?: number;\n  private readonly toleratedFailureCountPath?: string;\n  private readonly label?: string;\n  private readonly resultWriter?: ResultWriter;\n  private readonly itemBatcher?: ItemBatcher;\n\n  constructor(scope: Construct, id: string, props: DistributedMapProps = {}) {\n    super(scope, id, props);\n    this.mapExecutionType = props.mapExecutionType ?? StateMachineType.STANDARD;\n    this.itemReader = props.itemReader;\n    this.toleratedFailurePercentage = props.toleratedFailurePercentage;\n    this.toleratedFailurePercentagePath = props.toleratedFailurePercentagePath;\n    this.toleratedFailureCount = props.toleratedFailureCount;\n    this.toleratedFailureCountPath = props.toleratedFailureCountPath;\n    this.label = props.label;\n    this.itemBatcher = props.itemBatcher;\n    this.resultWriter = props.resultWriter;\n    this.processorMode = ProcessorMode.DISTRIBUTED;\n  }\n\n  /**\n   * Validate this state\n   */\n  protected validateState(): string[] {\n    const errors: string[] = super.validateState();\n\n    if (this.processorConfig?.mode === ProcessorMode.INLINE) {\n      errors.push(\"Processing mode cannot be `INLINE` for a Distributed Map\");\n    }\n\n    if (this.itemsPath && this.itemReader) {\n      errors.push(\"Provide either `itemsPath` or `itemReader`, but not both\");\n    }\n\n    if (\n      this.toleratedFailurePercentage &&\n      this.toleratedFailurePercentagePath\n    ) {\n      errors.push(\n        \"Provide either `toleratedFailurePercentage` or `toleratedFailurePercentagePath`, but not both\",\n      );\n    }\n\n    if (\n      this.toleratedFailurePercentage &&\n      !(\n        this.toleratedFailurePercentage >= 0 &&\n        this.toleratedFailurePercentage <= 100\n      )\n    ) {\n      errors.push(\"toleratedFailurePercentage must be between 0 and 100\");\n    }\n\n    if (this.toleratedFailureCount && this.toleratedFailureCountPath) {\n      errors.push(\n        \"Provide either `toleratedFailureCount` or `toleratedFailureCountPath`, but not both\",\n      );\n    }\n\n    if (this.itemBatcher) {\n      errors.push(...this.itemBatcher.validateItemBatcher());\n    }\n\n    if (this.itemReader) {\n      errors.push(...this.itemReader.validateItemReader());\n    }\n\n    if (this.label) {\n      if (this.label.length > 40) {\n        errors.push(\"label must be 40 characters or less\");\n      }\n\n      let labelRegex =\n        /[\\s\\?\\*\\<\\>\\{\\}\\\\[\\]\\:\\;\\,\\|\\^\\~\\$\\#\\%\\&\\`\\\"]|[\\u0000-\\u001f]|[\\u007f-\\u009f]/gi;\n      if (labelRegex.test(this.label)) {\n        errors.push(\n          \"label cannot contain any whitespace or special characters\",\n        );\n      }\n    }\n\n    return errors;\n  }\n\n  protected whenBoundToGraph(graph: StateGraph) {\n    super.whenBoundToGraph(graph);\n    if (this.resultWriter) {\n      this.resultWriter.providePolicyStatements().forEach((policyStatement) => {\n        graph.registerPolicyStatement(policyStatement);\n      });\n    }\n    if (this.itemReader) {\n      this.itemReader.providePolicyStatements().forEach((policyStatement) => {\n        graph.registerPolicyStatement(policyStatement);\n      });\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 = {}): DistributedMap {\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 = {}): DistributedMap {\n    super._addCatch(handler.startState, props);\n    return this;\n  }\n\n  /**\n   * Define item processor in a Distributed Map.\n   *\n   * A Distributed Map must have a non-empty item processor\n   */\n  public itemProcessor(\n    processor: IChainable,\n    config: ProcessorConfig = {},\n  ): DistributedMap {\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  /**\n   * Return the Amazon States Language object for this state\n   */\n  public toStateJson(): object {\n    let rendered: any = super.toStateJson();\n    if (rendered.ItemProcessor.ProcessorConfig.ExecutionType) {\n      // \"@aws-cdk/aws-stepfunctions:propertyIgnored\", // TODO: CDKTF does not support acknowledgeable warnings\n      Annotations.of(this).addWarning(\n        \"Property 'ProcessorConfig.executionType' is ignored, use the 'mapExecutionType' in the 'DistributedMap' class instead.\",\n      );\n    }\n    rendered.ItemProcessor.ProcessorConfig.ExecutionType =\n      this.mapExecutionType;\n\n    return {\n      ...rendered,\n      ...this.renderItemReader(),\n      ...this.renderItemBatcher(),\n      ...(this.toleratedFailurePercentage && {\n        ToleratedFailurePercentage: this.toleratedFailurePercentage,\n      }),\n      ...(this.toleratedFailurePercentagePath && {\n        ToleratedFailurePercentagePath: this.toleratedFailurePercentagePath,\n      }),\n      ...(this.toleratedFailureCount && {\n        ToleratedFailureCount: this.toleratedFailureCount,\n      }),\n      ...(this.toleratedFailureCountPath && {\n        ToleratedFailureCountPath: this.toleratedFailureCountPath,\n      }),\n      ...(this.label && { Label: this.label }),\n      ...this.renderResultWriter(),\n    };\n  }\n\n  /**\n   * Render the ItemReader as JSON object\n   */\n  private renderItemReader(): any {\n    if (!this.itemReader) {\n      return undefined;\n    }\n\n    return FieldUtils.renderObject({\n      ItemReader: this.itemReader.render(),\n    });\n  }\n\n  /**\n   * Render ResultWriter in ASL JSON format\n   */\n  private renderResultWriter(): any {\n    if (!this.resultWriter) {\n      return undefined;\n    }\n\n    return FieldUtils.renderObject({\n      ResultWriter: this.resultWriter.render(),\n    });\n  }\n\n  /**\n   * Render ItemBatcher in ASL JSON format\n   */\n  private renderItemBatcher(): any {\n    if (!this.itemBatcher) {\n      return undefined;\n    }\n\n    return {\n      ItemBatcher: this.itemBatcher.render(),\n    };\n  }\n}\n\n/**\n * Mark all instances of 'DistributeMap'.\n */\nObject.defineProperty(DistributedMap.prototype, DISTRIBUTED_MAP_SYMBOL, {\n  value: true,\n  enumerable: false,\n  writable: false,\n});\n"]}

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

@@ -0,0 +1,74 @@
+import { Construct } from "constructs";
+import { State } from "./state";
+import { INextable } from "../types";
+/**
+ * Properties for defining a Fail state
+ */
+export interface FailProps {
+    /**
+     * 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;
+    /**
+     * Error code used to represent this failure
+     *
+     * @default - No error code
+     */
+    readonly error?: string;
+    /**
+     * JsonPath expression to select part of the state to be the error to this state.
+     *
+     * You can also use an intrinsic function that returns a string to specify this property.
+     * The allowed functions include States.Format, States.JsonToString, States.ArrayGetItem, States.Base64Encode, States.Base64Decode, States.Hash, and States.UUID.
+     *
+     * @default - No error path
+     */
+    readonly errorPath?: string;
+    /**
+     * A description for the cause of the failure
+     *
+     * @default - No description
+     */
+    readonly cause?: string;
+    /**
+     * JsonPath expression to select part of the state to be the cause to this state.
+     *
+     * You can also use an intrinsic function that returns a string to specify this property.
+     * The allowed functions include States.Format, States.JsonToString, States.ArrayGetItem, States.Base64Encode, States.Base64Decode, States.Hash, and States.UUID.
+     *
+     * @default - No cause path
+     */
+    readonly causePath?: string;
+}
+/**
+ * Define a Fail state in the state machine
+ *
+ * Reaching a Fail state terminates the state execution in failure.
+ */
+export declare class Fail extends State {
+    private static allowedIntrinsics;
+    readonly endStates: INextable[];
+    private readonly error?;
+    private readonly errorPath?;
+    private readonly cause?;
+    private readonly causePath?;
+    constructor(scope: Construct, id: string, props?: FailProps);
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(): object;
+    /**
+     * Validate this state
+     */
+    protected validateState(): string[];
+    private isIntrinsicString;
+    private isAllowedIntrinsic;
+}

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

@@ -0,0 +1,83 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fail = 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/fail.ts
+const cdktf_1 = require("cdktf");
+const state_type_1 = require("./private/state-type");
+const state_1 = require("./state");
+/**
+ * Define a Fail state in the state machine
+ *
+ * Reaching a Fail state terminates the state execution in failure.
+ */
+class Fail extends state_1.State {
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.endStates = [];
+        this.error = props.error;
+        this.errorPath = props.errorPath;
+        this.cause = props.cause;
+        this.causePath = props.causePath;
+    }
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson() {
+        return {
+            Type: state_type_1.StateType.FAIL,
+            Comment: this.comment,
+            Error: this.error,
+            ErrorPath: this.isIntrinsicString(this.errorPath)
+                ? this.errorPath
+                : (0, state_1.renderJsonPath)(this.errorPath),
+            Cause: this.cause,
+            CausePath: this.isIntrinsicString(this.causePath)
+                ? this.causePath
+                : (0, state_1.renderJsonPath)(this.causePath),
+        };
+    }
+    /**
+     * Validate this state
+     */
+    validateState() {
+        const errors = super.validateState();
+        if (this.errorPath &&
+            this.isIntrinsicString(this.errorPath) &&
+            !this.isAllowedIntrinsic(this.errorPath)) {
+            errors.push(`You must specify a valid intrinsic function in errorPath. Must be one of ${Fail.allowedIntrinsics.join(", ")}`);
+        }
+        if (this.causePath &&
+            this.isIntrinsicString(this.causePath) &&
+            !this.isAllowedIntrinsic(this.causePath)) {
+            errors.push(`You must specify a valid intrinsic function in causePath. Must be one of ${Fail.allowedIntrinsics.join(", ")}`);
+        }
+        if (this.error && this.errorPath) {
+            errors.push("Fail state cannot have both error and errorPath");
+        }
+        if (this.cause && this.causePath) {
+            errors.push("Fail state cannot have both cause and causePath");
+        }
+        return errors;
+    }
+    isIntrinsicString(jsonPath) {
+        return !cdktf_1.Token.isUnresolved(jsonPath) && !jsonPath?.startsWith("$");
+    }
+    isAllowedIntrinsic(intrinsic) {
+        return Fail.allowedIntrinsics.some((allowed) => intrinsic.startsWith(allowed));
+    }
+}
+exports.Fail = Fail;
+_a = JSII_RTTI_SYMBOL_1;
+Fail[_a] = { fqn: "terraconstructs.aws.compute.Fail", version: "0.0.8" };
+Fail.allowedIntrinsics = [
+    "States.Format",
+    "States.JsonToString",
+    "States.ArrayGetItem",
+    "States.Base64Encode",
+    "States.Base64Decode",
+    "States.Hash",
+    "States.UUID",
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fail.js","sourceRoot":"","sources":["../../../../src/aws/compute/states/fail.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/fail.ts\n\nimport { Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { StateType } from \"./private/state-type\";\nimport { renderJsonPath, State } from \"./state\";\nimport { INextable } from \"../types\";\n\n/**\n * Properties for defining a Fail state\n */\nexport interface FailProps {\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   * Error code used to represent this failure\n   *\n   * @default - No error code\n   */\n  readonly error?: string;\n\n  /**\n   * JsonPath expression to select part of the state to be the error to this state.\n   *\n   * You can also use an intrinsic function that returns a string to specify this property.\n   * The allowed functions include States.Format, States.JsonToString, States.ArrayGetItem, States.Base64Encode, States.Base64Decode, States.Hash, and States.UUID.\n   *\n   * @default - No error path\n   */\n  readonly errorPath?: string;\n\n  /**\n   * A description for the cause of the failure\n   *\n   * @default - No description\n   */\n  readonly cause?: string;\n\n  /**\n   * JsonPath expression to select part of the state to be the cause to this state.\n   *\n   * You can also use an intrinsic function that returns a string to specify this property.\n   * The allowed functions include States.Format, States.JsonToString, States.ArrayGetItem, States.Base64Encode, States.Base64Decode, States.Hash, and States.UUID.\n   *\n   * @default - No cause path\n   */\n  readonly causePath?: string;\n}\n\n/**\n * Define a Fail state in the state machine\n *\n * Reaching a Fail state terminates the state execution in failure.\n */\nexport class Fail extends State {\n  private static allowedIntrinsics = [\n    \"States.Format\",\n    \"States.JsonToString\",\n    \"States.ArrayGetItem\",\n    \"States.Base64Encode\",\n    \"States.Base64Decode\",\n    \"States.Hash\",\n    \"States.UUID\",\n  ];\n\n  public readonly endStates: INextable[] = [];\n\n  private readonly error?: string;\n  private readonly errorPath?: string;\n  private readonly cause?: string;\n  private readonly causePath?: string;\n\n  constructor(scope: Construct, id: string, props: FailProps = {}) {\n    super(scope, id, props);\n\n    this.error = props.error;\n    this.errorPath = props.errorPath;\n    this.cause = props.cause;\n    this.causePath = props.causePath;\n  }\n\n  /**\n   * Return the Amazon States Language object for this state\n   */\n  public toStateJson(): object {\n    return {\n      Type: StateType.FAIL,\n      Comment: this.comment,\n      Error: this.error,\n      ErrorPath: this.isIntrinsicString(this.errorPath)\n        ? this.errorPath\n        : renderJsonPath(this.errorPath),\n      Cause: this.cause,\n      CausePath: this.isIntrinsicString(this.causePath)\n        ? this.causePath\n        : renderJsonPath(this.causePath),\n    };\n  }\n\n  /**\n   * Validate this state\n   */\n  protected validateState(): string[] {\n    const errors = super.validateState();\n\n    if (\n      this.errorPath &&\n      this.isIntrinsicString(this.errorPath) &&\n      !this.isAllowedIntrinsic(this.errorPath)\n    ) {\n      errors.push(\n        `You must specify a valid intrinsic function in errorPath. Must be one of ${Fail.allowedIntrinsics.join(\", \")}`,\n      );\n    }\n\n    if (\n      this.causePath &&\n      this.isIntrinsicString(this.causePath) &&\n      !this.isAllowedIntrinsic(this.causePath)\n    ) {\n      errors.push(\n        `You must specify a valid intrinsic function in causePath. Must be one of ${Fail.allowedIntrinsics.join(\", \")}`,\n      );\n    }\n\n    if (this.error && this.errorPath) {\n      errors.push(\"Fail state cannot have both error and errorPath\");\n    }\n\n    if (this.cause && this.causePath) {\n      errors.push(\"Fail state cannot have both cause and causePath\");\n    }\n\n    return errors;\n  }\n\n  private isIntrinsicString(jsonPath?: string): boolean {\n    return !Token.isUnresolved(jsonPath) && !jsonPath?.startsWith(\"$\");\n  }\n\n  private isAllowedIntrinsic(intrinsic: string): boolean {\n    return Fail.allowedIntrinsics.some((allowed) =>\n      intrinsic.startsWith(allowed),\n    );\n  }\n}\n"]}

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

@@ -0,0 +1,145 @@
+import { Construct } from "constructs";
+import { State } from "./state";
+import { Chain } from "../chain";
+import { IChainable, INextable } from "../types";
+/**
+ * Properties for defining a Map state
+ */
+export interface MapBaseProps {
+    /**
+     * 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;
+    /**
+     * JSONPath expression to select the array to iterate over
+     *
+     * @default $
+     */
+    readonly itemsPath?: string;
+    /**
+     * The JSON that you want to override your default iteration input (mutually exclusive  with `parameters`).
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-itemselector.html
+     *
+     * @default $
+     */
+    readonly itemSelector?: {
+        [key: string]: any;
+    };
+    /**
+     * 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;
+    };
+    /**
+     * MaxConcurrency
+     *
+     * An upper bound on the number of iterations you want running at once.
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/concepts-asl-use-map-state-inline.html#map-state-inline-additional-fields
+     *
+     * @default - full concurrency
+     */
+    readonly maxConcurrency?: number;
+    /**
+     * MaxConcurrencyPath
+     *
+     * A JsonPath that specifies the maximum concurrency dynamically from the state input.
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/concepts-asl-use-map-state-inline.html#map-state-inline-additional-fields
+     *
+     * @default - full concurrency
+     */
+    readonly maxConcurrencyPath?: string;
+}
+/**
+ * Returns true if the value passed is a positive integer
+ * @param value the value to validate
+ */
+export declare const isPositiveInteger: (value: number) => boolean;
+/**
+ * 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 abstract class MapBase extends State implements INextable {
+    readonly endStates: INextable[];
+    private readonly maxConcurrency?;
+    private readonly maxConcurrencyPath?;
+    protected readonly itemsPath?: string;
+    protected readonly itemSelector?: {
+        [key: string]: any;
+    };
+    constructor(scope: Construct, id: string, props?: MapBaseProps);
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next: IChainable): Chain;
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(): object;
+    /**
+     * Validate this state
+     */
+    protected validateState(): string[];
+    private renderItemsPath;
+    /**
+     * Render ItemSelector in ASL JSON format
+     */
+    private renderItemSelector;
+}