terraconstructs 0.0.8

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

@@ -0,0 +1,253 @@
+"use strict";
+var _a, _b, _c, _d, _e;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3ManifestItemReader = exports.S3CsvItemReader = exports.CsvHeaders = exports.CsvHeaderLocation = exports.S3JsonItemReader = exports.S3ObjectsItemReader = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const __1 = require("../../..");
+const iam = require("../../../iam");
+const fields_1 = require("../../fields");
+/**
+ * Item Reader configuration for iterating over objects in an S3 bucket
+ */
+class S3ObjectsItemReader {
+    get partition() {
+        if (this.bucket) {
+            return this.bucket.env.partition;
+        }
+        if (this.bucketNameScope) {
+            return __1.AwsStack.ofAwsConstruct(this.bucketNameScope).partition;
+        }
+        throw new Error("Cannot determine partition");
+    }
+    constructor(props) {
+        this.bucket = props.bucket;
+        this.bucketNamePath = props.bucketNamePath;
+        this.bucketNameScope = props.bucketNameScope;
+        this.prefix = props.prefix;
+        this.maxItems = props.maxItems;
+        this.resource = __1.Arn.format({
+            region: "",
+            account: "",
+            partition: this.partition,
+            service: "states",
+            resource: "s3",
+            resourceName: "listObjectsV2",
+            arnFormat: __1.ArnFormat.COLON_RESOURCE_NAME,
+        });
+    }
+    /**
+     * Renders the ItemReader configuration as JSON object
+     * @returns - JSON object
+     */
+    render() {
+        return fields_1.FieldUtils.renderObject({
+            Resource: this.resource,
+            ...(this.maxItems && { ReaderConfig: { MaxItems: this.maxItems } }),
+            Parameters: {
+                ...(this.bucket && { Bucket: this.bucket.bucketName }),
+                ...(this.bucketNamePath && { Bucket: this.bucketNamePath }),
+                ...(this.prefix && { Prefix: this.prefix }),
+            },
+        });
+    }
+    /**
+     * Compile policy statements to provide relevent permissions to the state machine
+     */
+    providePolicyStatements() {
+        return [
+            new iam.PolicyStatement({
+                actions: ["s3:ListBucket"],
+                resources: [this.bucket ? this.bucket.bucketArn : "*"],
+            }),
+        ];
+    }
+    /**
+     * Validate that ItemReader contains exactly either @see bucket or @see bucketNamePath
+     */
+    validateItemReader() {
+        const errors = [];
+        if (this.bucket && this.bucketNamePath) {
+            errors.push("Provide either `bucket` or `bucketNamePath`, but not both");
+        }
+        else if (!this.bucket && !this.bucketNamePath) {
+            errors.push("Provide either `bucket` or `bucketNamePath`");
+        }
+        return errors;
+    }
+}
+exports.S3ObjectsItemReader = S3ObjectsItemReader;
+_a = JSII_RTTI_SYMBOL_1;
+S3ObjectsItemReader[_a] = { fqn: "terraconstructs.aws.compute.S3ObjectsItemReader", version: "0.0.8" };
+/**
+ * Base Item Reader configuration for iterating over entries in a S3 file
+ */
+class S3FileItemReader {
+    get partition() {
+        if (this.bucket) {
+            return this.bucket.env.partition;
+        }
+        if (this.bucketNameScope) {
+            return __1.AwsStack.ofAwsConstruct(this.bucketNameScope).partition;
+        }
+        throw new Error("Cannot determine partition");
+    }
+    constructor(props) {
+        this.bucket = props.bucket;
+        this.bucketNamePath = props.bucketNamePath;
+        this.bucketNameScope = props.bucketNameScope;
+        this.key = props.key;
+        this.maxItems = props.maxItems;
+        this.resource = __1.Arn.format({
+            region: "",
+            account: "",
+            partition: this.partition,
+            service: "states",
+            resource: "s3",
+            resourceName: "getObject",
+            arnFormat: __1.ArnFormat.COLON_RESOURCE_NAME,
+        });
+    }
+    /**
+     * Renders the ItemReader configuration as JSON object
+     * @returns - JSON object
+     */
+    render() {
+        return fields_1.FieldUtils.renderObject({
+            Resource: this.resource,
+            ReaderConfig: {
+                InputType: this.inputType,
+                ...(this.maxItems && { MaxItems: this.maxItems }),
+            },
+            Parameters: {
+                ...(this.bucket && { Bucket: this.bucket.bucketName }),
+                ...(this.bucketNamePath && { Bucket: this.bucketNamePath }),
+                Key: this.key,
+            },
+        });
+    }
+    /**
+     * Compile policy statements to provide relevent permissions to the state machine
+     */
+    providePolicyStatements() {
+        if (!this.bucket)
+            return [];
+        const resource = __1.Arn.format({
+            region: "",
+            account: "",
+            partition: this.bucket.env.partition,
+            service: "s3",
+            resource: this.bucket.bucketName,
+            resourceName: "*",
+        });
+        return [
+            new iam.PolicyStatement({
+                actions: ["s3:GetObject"],
+                resources: [resource],
+            }),
+        ];
+    }
+    /**
+     * Validate that ItemReader contains exactly either @see bucket or @see bucketNamePath and @see bucketNameScope
+     */
+    validateItemReader() {
+        const errors = [];
+        if (this.bucket && (this.bucketNamePath || this.bucketNameScope)) {
+            errors.push("Provide either `bucket` or `bucketNamePath` and `bucketNameScope`, but not both");
+        }
+        else if (!this.bucket &&
+            (!this.bucketNamePath || !this.bucketNameScope)) {
+            errors.push("Provide either `bucket` or `bucketNamePath` && `bucketNameScope`");
+        }
+        return errors;
+    }
+}
+/**
+ * Item Reader configuration for iterating over items in a JSON array stored in a S3 file
+ */
+class S3JsonItemReader extends S3FileItemReader {
+    constructor() {
+        super(...arguments);
+        this.inputType = "JSON";
+    }
+}
+exports.S3JsonItemReader = S3JsonItemReader;
+_b = JSII_RTTI_SYMBOL_1;
+S3JsonItemReader[_b] = { fqn: "terraconstructs.aws.compute.S3JsonItemReader", version: "0.0.8" };
+/**
+ * CSV header location options
+ */
+var CsvHeaderLocation;
+(function (CsvHeaderLocation) {
+    /**
+     * Headers will be read from first row of CSV file
+     */
+    CsvHeaderLocation["FIRST_ROW"] = "FIRST_ROW";
+    /**
+     * Headers are provided in CSVHeaders property
+     */
+    CsvHeaderLocation["GIVEN"] = "GIVEN";
+})(CsvHeaderLocation || (exports.CsvHeaderLocation = CsvHeaderLocation = {}));
+/**
+ * Configuration for CSV header options for a CSV Item Reader
+ */
+class CsvHeaders {
+    /**
+     * Configures S3CsvItemReader to read headers from the first row of the CSV file
+     * @returns - CsvHeaders
+     */
+    static useFirstRow() {
+        return new CsvHeaders(CsvHeaderLocation.FIRST_ROW);
+    }
+    /**
+     * Configures S3CsvItemReader to use the headers provided in the `headers` parameter
+     * @param headers - List of headers
+     * @returns - CsvHeaders
+     */
+    static use(headers) {
+        return new CsvHeaders(CsvHeaderLocation.GIVEN, headers);
+    }
+    constructor(headerLocation, headers) {
+        this.headerLocation = headerLocation;
+        this.headers = headers;
+    }
+}
+exports.CsvHeaders = CsvHeaders;
+_c = JSII_RTTI_SYMBOL_1;
+CsvHeaders[_c] = { fqn: "terraconstructs.aws.compute.CsvHeaders", version: "0.0.8" };
+/**
+ * Item Reader configuration for iterating over items in a CSV file stored in S3
+ */
+class S3CsvItemReader extends S3FileItemReader {
+    constructor(props) {
+        super(props);
+        this.inputType = "CSV";
+        this.csvHeaders = props.csvHeaders ?? CsvHeaders.useFirstRow();
+    }
+    render() {
+        let rendered = super.render();
+        rendered.ReaderConfig = fields_1.FieldUtils.renderObject({
+            ...rendered.ReaderConfig,
+            ...{
+                CSVHeaderLocation: this.csvHeaders.headerLocation,
+                ...(this.csvHeaders.headers && { CSVHeaders: this.csvHeaders.headers }),
+            },
+        });
+        return rendered;
+    }
+}
+exports.S3CsvItemReader = S3CsvItemReader;
+_d = JSII_RTTI_SYMBOL_1;
+S3CsvItemReader[_d] = { fqn: "terraconstructs.aws.compute.S3CsvItemReader", version: "0.0.8" };
+/**
+ * Item Reader configuration for iterating over items in a S3 inventory manifest file stored in S3
+ */
+class S3ManifestItemReader extends S3FileItemReader {
+    constructor() {
+        super(...arguments);
+        this.inputType = "MANIFEST";
+    }
+}
+exports.S3ManifestItemReader = S3ManifestItemReader;
+_e = JSII_RTTI_SYMBOL_1;
+S3ManifestItemReader[_e] = { fqn: "terraconstructs.aws.compute.S3ManifestItemReader", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"item-reader.js","sourceRoot":"","sources":["../../../../../src/aws/compute/states/distributed-map/item-reader.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/item-reader.ts\n\nimport { Construct } from \"constructs\";\nimport { Arn, ArnFormat, AwsStack } from \"../../..\";\nimport * as iam from \"../../../iam\";\nimport { IBucket } from \"../../../storage\";\nimport { FieldUtils } from \"../../fields\";\n\n/**\n * Base interface for Item Reader configurations\n */\nexport interface IItemReader {\n  /**\n   * S3 Bucket containing objects to iterate over or a file with a list to iterate over\n   */\n  readonly bucket?: IBucket;\n\n  /**\n   * S3 bucket name containing objects to iterate over or a file with a list to iterate over, as JsonPath\n   */\n  readonly bucketNamePath?: string;\n\n  /**\n   * The Amazon S3 API action that Step Functions must invoke depending on the specified dataset.\n   */\n  readonly resource: string;\n\n  /**\n   * Limits the number of items passed to the Distributed Map state\n   *\n   * @default - Distributed Map state will iterate over all items provided by the ItemReader\n   */\n  readonly maxItems?: number;\n\n  /**\n   * Render the ItemReader as JSON object\n   */\n  render(): any;\n\n  /**\n   * Compile policy statements to provide relevent permissions to the state machine\n   */\n  providePolicyStatements(): iam.PolicyStatement[];\n\n  /**\n   * Validate that ItemReader contains exactly either @see bucket or @see bucketNamePath\n   */\n  validateItemReader(): string[];\n}\n\n/**\n * Base interface for Item Reader configuration properties\n */\nexport interface ItemReaderProps {\n  /**\n   * S3 Bucket containing objects to iterate over or a file with a list to iterate over\n   *\n   * @default - S3 bucket will be determined from @see bucketNamePath\n   */\n  readonly bucket?: IBucket;\n\n  /**\n   * S3 bucket name containing objects to iterate over or a file with a list to iterate over, as JsonPath\n   *\n   * @default - S3 bucket will be determined from @see bucket\n   */\n  readonly bucketNamePath?: string;\n\n  /**\n   * S3 bucket name scope, only required if @see bucketNamePath is provided\n   */\n  readonly bucketNameScope?: Construct;\n\n  /**\n   * Limits the number of items passed to the Distributed Map state\n   *\n   * @default - Distributed Map state will iterate over all items provided by the ItemReader\n   */\n  readonly maxItems?: number;\n}\n\n/**\n * Properties for configuring an Item Reader that iterates over objects in an S3 bucket\n */\nexport interface S3ObjectsItemReaderProps extends ItemReaderProps {\n  /**\n   * S3 prefix used to limit objects to iterate over\n   *\n   * @default - No prefix\n   */\n  readonly prefix?: string;\n}\n\n/**\n * Item Reader configuration for iterating over objects in an S3 bucket\n */\nexport class S3ObjectsItemReader implements IItemReader {\n  /**\n   * S3 Bucket containing objects to iterate over\n   */\n  readonly bucket?: IBucket;\n\n  /**\n   * S3 bucket name containing objects to iterate over or a file with a list to iterate over, as JsonPath\n   */\n  readonly bucketNamePath?: string;\n\n  /**\n   * ARN for the `listObjectsV2` method of the S3 API\n   * This API method is used to iterate all objects in the S3 bucket/prefix\n   */\n  readonly resource: string;\n\n  /**\n   * S3 prefix used to limit objects to iterate over\n   *\n   * @default - No prefix\n   */\n  readonly prefix?: string;\n\n  /**\n   * Limits the number of items passed to the Distributed Map state\n   *\n   * @default - Distributed Map state will iterate over all items provided by the ItemReader\n   */\n  readonly maxItems?: number;\n\n  /**\n   * S3 bucket name scope\n   */\n  readonly bucketNameScope?: Construct;\n  protected get partition(): string {\n    if (this.bucket) {\n      return this.bucket.env.partition;\n    }\n    if (this.bucketNameScope) {\n      return AwsStack.ofAwsConstruct(this.bucketNameScope).partition;\n    }\n    throw new Error(\"Cannot determine partition\");\n  }\n\n  constructor(props: S3ObjectsItemReaderProps) {\n    this.bucket = props.bucket;\n    this.bucketNamePath = props.bucketNamePath;\n    this.bucketNameScope = props.bucketNameScope;\n    this.prefix = props.prefix;\n    this.maxItems = props.maxItems;\n    this.resource = Arn.format({\n      region: \"\",\n      account: \"\",\n      partition: this.partition,\n      service: \"states\",\n      resource: \"s3\",\n      resourceName: \"listObjectsV2\",\n      arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n    });\n  }\n\n  /**\n   * Renders the ItemReader configuration as JSON object\n   * @returns - JSON object\n   */\n  public render(): any {\n    return FieldUtils.renderObject({\n      Resource: this.resource,\n      ...(this.maxItems && { ReaderConfig: { MaxItems: this.maxItems } }),\n      Parameters: {\n        ...(this.bucket && { Bucket: this.bucket.bucketName }),\n        ...(this.bucketNamePath && { Bucket: this.bucketNamePath }),\n        ...(this.prefix && { Prefix: this.prefix }),\n      },\n    });\n  }\n\n  /**\n   * Compile policy statements to provide relevent permissions to the state machine\n   */\n  public providePolicyStatements(): iam.PolicyStatement[] {\n    return [\n      new iam.PolicyStatement({\n        actions: [\"s3:ListBucket\"],\n        resources: [this.bucket ? this.bucket.bucketArn : \"*\"],\n      }),\n    ];\n  }\n\n  /**\n   * Validate that ItemReader contains exactly either @see bucket or @see bucketNamePath\n   */\n  public validateItemReader(): string[] {\n    const errors: string[] = [];\n    if (this.bucket && this.bucketNamePath) {\n      errors.push(\"Provide either `bucket` or `bucketNamePath`, but not both\");\n    } else if (!this.bucket && !this.bucketNamePath) {\n      errors.push(\"Provide either `bucket` or `bucketNamePath`\");\n    }\n    return errors;\n  }\n}\n\n/**\n * Base interface for Item Reader configuration properties the iterate over entries in a S3 file\n */\nexport interface S3FileItemReaderProps extends ItemReaderProps {\n  /**\n   * Key of file stored in S3 bucket containing an array to iterate over\n   */\n  readonly key: string;\n}\n\n/**\n * Base Item Reader configuration for iterating over entries in a S3 file\n */\nabstract class S3FileItemReader implements IItemReader {\n  /**\n   * S3 Bucket containing a file with a list to iterate over\n   */\n  readonly bucket?: IBucket;\n\n  /**\n   * S3 bucket name containing objects to iterate over or a file with a list to iterate over, as JsonPath\n   */\n  readonly bucketNamePath?: string;\n\n  /**\n   * S3 key of a file with a list to iterate over\n   */\n  readonly key: string;\n\n  /**\n   * ARN for the `getObject` method of the S3 API\n   * This API method is used to iterate all objects in the S3 bucket/prefix\n   */\n  readonly resource: string;\n\n  /**\n   * Limits the number of items passed to the Distributed Map state\n   *\n   * @default - No maxItems\n   */\n  readonly maxItems?: number;\n\n  /**\n   * S3 bucket name scope\n   */\n  readonly bucketNameScope?: Construct;\n  protected get partition(): string {\n    if (this.bucket) {\n      return this.bucket.env.partition;\n    }\n    if (this.bucketNameScope) {\n      return AwsStack.ofAwsConstruct(this.bucketNameScope).partition;\n    }\n    throw new Error(\"Cannot determine partition\");\n  }\n\n  protected abstract readonly inputType: string;\n\n  constructor(props: S3FileItemReaderProps) {\n    this.bucket = props.bucket;\n    this.bucketNamePath = props.bucketNamePath;\n    this.bucketNameScope = props.bucketNameScope;\n    this.key = props.key;\n    this.maxItems = props.maxItems;\n    this.resource = Arn.format({\n      region: \"\",\n      account: \"\",\n      partition: this.partition,\n      service: \"states\",\n      resource: \"s3\",\n      resourceName: \"getObject\",\n      arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n    });\n  }\n\n  /**\n   * Renders the ItemReader configuration as JSON object\n   * @returns - JSON object\n   */\n  public render(): any {\n    return FieldUtils.renderObject({\n      Resource: this.resource,\n      ReaderConfig: {\n        InputType: this.inputType,\n        ...(this.maxItems && { MaxItems: this.maxItems }),\n      },\n      Parameters: {\n        ...(this.bucket && { Bucket: this.bucket.bucketName }),\n        ...(this.bucketNamePath && { Bucket: this.bucketNamePath }),\n        Key: this.key,\n      },\n    });\n  }\n\n  /**\n   * Compile policy statements to provide relevent permissions to the state machine\n   */\n  public providePolicyStatements(): iam.PolicyStatement[] {\n    if (!this.bucket) return [];\n    const resource = Arn.format({\n      region: \"\",\n      account: \"\",\n      partition: this.bucket.env.partition,\n      service: \"s3\",\n      resource: this.bucket.bucketName,\n      resourceName: \"*\",\n    });\n\n    return [\n      new iam.PolicyStatement({\n        actions: [\"s3:GetObject\"],\n        resources: [resource],\n      }),\n    ];\n  }\n\n  /**\n   * Validate that ItemReader contains exactly either @see bucket or @see bucketNamePath and @see bucketNameScope\n   */\n  public validateItemReader(): string[] {\n    const errors: string[] = [];\n    if (this.bucket && (this.bucketNamePath || this.bucketNameScope)) {\n      errors.push(\n        \"Provide either `bucket` or `bucketNamePath` and `bucketNameScope`, but not both\",\n      );\n    } else if (\n      !this.bucket &&\n      (!this.bucketNamePath || !this.bucketNameScope)\n    ) {\n      errors.push(\n        \"Provide either `bucket` or `bucketNamePath` && `bucketNameScope`\",\n      );\n    }\n    return errors;\n  }\n}\n\n/**\n * Item Reader configuration for iterating over items in a JSON array stored in a S3 file\n */\nexport class S3JsonItemReader extends S3FileItemReader {\n  protected readonly inputType: string = \"JSON\";\n}\n\n/**\n * CSV header location options\n */\nexport enum CsvHeaderLocation {\n  /**\n   * Headers will be read from first row of CSV file\n   */\n  FIRST_ROW = \"FIRST_ROW\",\n\n  /**\n   * Headers are provided in CSVHeaders property\n   */\n  GIVEN = \"GIVEN\",\n}\n\n/**\n * Configuration for CSV header options for a CSV Item Reader\n */\nexport class CsvHeaders {\n  /**\n   * Configures S3CsvItemReader to read headers from the first row of the CSV file\n   * @returns - CsvHeaders\n   */\n  public static useFirstRow(): CsvHeaders {\n    return new CsvHeaders(CsvHeaderLocation.FIRST_ROW);\n  }\n\n  /**\n   * Configures S3CsvItemReader to use the headers provided in the `headers` parameter\n   * @param headers - List of headers\n   * @returns - CsvHeaders\n   */\n  public static use(headers: string[]): CsvHeaders {\n    return new CsvHeaders(CsvHeaderLocation.GIVEN, headers);\n  }\n\n  /**\n   * Location of headers in CSV file\n   */\n  public readonly headerLocation: CsvHeaderLocation;\n\n  /**\n   * List of headers if `headerLocation` is `GIVEN`\n   */\n  public readonly headers?: string[];\n\n  private constructor(headerLocation: CsvHeaderLocation, headers?: string[]) {\n    this.headerLocation = headerLocation;\n    this.headers = headers;\n  }\n}\n\n/**\n * Properties for configuring an Item Reader that iterates over items in a CSV file in S3\n */\nexport interface S3CsvItemReaderProps extends S3FileItemReaderProps {\n  /**\n   * CSV file header configuration\n   *\n   * @default - CsvHeaders with CsvHeadersLocation.FIRST_ROW\n   */\n  readonly csvHeaders?: CsvHeaders;\n}\n\n/**\n * Item Reader configuration for iterating over items in a CSV file stored in S3\n */\nexport class S3CsvItemReader extends S3FileItemReader {\n  /**\n   * CSV headers configuration\n   */\n  readonly csvHeaders: CsvHeaders;\n  protected readonly inputType: string = \"CSV\";\n\n  constructor(props: S3CsvItemReaderProps) {\n    super(props);\n    this.csvHeaders = props.csvHeaders ?? CsvHeaders.useFirstRow();\n  }\n\n  public render(): any {\n    let rendered = super.render();\n\n    rendered.ReaderConfig = FieldUtils.renderObject({\n      ...rendered.ReaderConfig,\n      ...{\n        CSVHeaderLocation: this.csvHeaders.headerLocation,\n        ...(this.csvHeaders.headers && { CSVHeaders: this.csvHeaders.headers }),\n      },\n    });\n\n    return rendered;\n  }\n}\n\n/**\n * Item Reader configuration for iterating over items in a S3 inventory manifest file stored in S3\n */\nexport class S3ManifestItemReader extends S3FileItemReader {\n  protected readonly inputType: string = \"MANIFEST\";\n}\n"]}

package/lib/aws/compute/states/distributed-map/result-writer.d.ts

@@ -0,0 +1,41 @@
+import * as iam from "../../../iam";
+import { IBucket } from "../../../storage";
+/**
+ * Interface for Result Writer configuration properties
+ */
+export interface ResultWriterProps {
+    /**
+     * S3 Bucket in which to save Map Run results
+     */
+    readonly bucket: IBucket;
+    /**
+     * S3 prefix in which to save Map Run results
+     *
+     * @default - No prefix
+     */
+    readonly prefix?: string;
+}
+/**
+ * Configuration for writing Distributed Map state results to S3
+ */
+export declare class ResultWriter {
+    /**
+     * S3 Bucket in which to save Map Run results
+     */
+    readonly bucket: IBucket;
+    /**
+     * S3 prefix in which to save Map Run results
+     *
+     * @default - No prefix
+     */
+    readonly prefix?: string;
+    constructor(props: ResultWriterProps);
+    /**
+     * Render ResultWriter in ASL JSON format
+     */
+    render(): any;
+    /**
+     * Compile policy statements to provide relevent permissions to the state machine
+     */
+    providePolicyStatements(): iam.PolicyStatement[];
+}

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

@@ -0,0 +1,66 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultWriter = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const __1 = require("../../..");
+const iam = require("../../../iam");
+const fields_1 = require("../../fields");
+/**
+ * Configuration for writing Distributed Map state results to S3
+ */
+class ResultWriter {
+    constructor(props) {
+        this.bucket = props.bucket;
+        this.prefix = props.prefix;
+    }
+    /**
+     * Render ResultWriter in ASL JSON format
+     */
+    render() {
+        const resource = __1.Arn.format({
+            region: "",
+            account: "",
+            partition: this.bucket.env.partition,
+            service: "states",
+            resource: "s3",
+            resourceName: "putObject",
+            arnFormat: __1.ArnFormat.COLON_RESOURCE_NAME,
+        });
+        return fields_1.FieldUtils.renderObject({
+            Resource: resource,
+            Parameters: {
+                Bucket: this.bucket.bucketName,
+                ...(this.prefix && { Prefix: this.prefix }),
+            },
+        });
+    }
+    /**
+     * Compile policy statements to provide relevent permissions to the state machine
+     */
+    providePolicyStatements() {
+        const resource = __1.Arn.format({
+            region: "",
+            account: "",
+            partition: this.bucket.env.partition,
+            service: "s3",
+            resource: this.bucket.bucketName,
+            resourceName: "*",
+        });
+        return [
+            new iam.PolicyStatement({
+                actions: [
+                    "s3:PutObject",
+                    "s3:GetObject",
+                    "s3:ListMultipartUploadParts",
+                    "s3:AbortMultipartUpload",
+                ],
+                resources: [resource],
+            }),
+        ];
+    }
+}
+exports.ResultWriter = ResultWriter;
+_a = JSII_RTTI_SYMBOL_1;
+ResultWriter[_a] = { fqn: "terraconstructs.aws.compute.ResultWriter", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,153 @@
+import { Construct } from "constructs";
+import { ItemBatcher } from "./distributed-map/item-batcher";
+import { IItemReader } from "./distributed-map/item-reader";
+import { ResultWriter } from "./distributed-map/result-writer";
+import { MapBase, MapBaseProps } from "./map-base";
+import { StateGraph } from "../state-graph";
+import { StateMachineType } from "../state-machine";
+import { CatchProps, IChainable, INextable, ProcessorConfig, RetryProps } from "../types";
+/**
+ * Properties for configuring a Distribute Map state
+ */
+export interface DistributedMapProps extends MapBaseProps {
+    /**
+     * MapExecutionType
+     *
+     * The execution type of the distributed map state
+     *
+     * This property overwrites ProcessorConfig.executionType
+     *
+     * @default StateMachineType.STANDARD
+     */
+    readonly mapExecutionType?: StateMachineType;
+    /**
+     * ItemReader
+     *
+     * Configuration for where to read items dataset in S3 to iterate
+     *
+     * @default - No itemReader
+     */
+    readonly itemReader?: IItemReader;
+    /**
+     * ToleratedFailurePercentage
+     *
+     * Percentage of failed items to tolerate in a Map Run, as static number
+     *
+     * @default - No toleratedFailurePercentage
+     */
+    readonly toleratedFailurePercentage?: number;
+    /**
+     * ToleratedFailurePercentagePath
+     *
+     * Percentage of failed items to tolerate in a Map Run, as JsonPath
+     *
+     * @default - No toleratedFailurePercentagePath
+     */
+    readonly toleratedFailurePercentagePath?: string;
+    /**
+     * ToleratedFailureCount
+     *
+     * Number of failed items to tolerate in a Map Run, as static number
+     *
+     * @default - No toleratedFailureCount
+     */
+    readonly toleratedFailureCount?: number;
+    /**
+     * ToleratedFailureCountPath
+     *
+     * Number of failed items to tolerate in a Map Run, as JsonPath
+     *
+     * @default - No toleratedFailureCountPath
+     */
+    readonly toleratedFailureCountPath?: string;
+    /**
+     * Label
+     *
+     * Unique name for the Distributed Map state added to each Map Run
+     *
+     * @default - No label
+     */
+    readonly label?: string;
+    /**
+     * Configuration for S3 location in which to save Map Run results
+     *
+     * @default - No resultWriter
+     */
+    readonly resultWriter?: ResultWriter;
+    /**
+     * Specifies to process a group of items in a single child workflow execution
+     *
+     * @default - No itemBatcher
+     */
+    readonly itemBatcher?: ItemBatcher;
+}
+/**
+ * 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
+ */
+export declare class DistributedMap extends MapBase implements INextable {
+    /**
+     * Return whether the given object is a DistributedMap.
+     */
+    static isDistributedMap(x: any): x is DistributedMap;
+    private readonly mapExecutionType?;
+    private readonly itemReader?;
+    private readonly toleratedFailurePercentage?;
+    private readonly toleratedFailurePercentagePath?;
+    private readonly toleratedFailureCount?;
+    private readonly toleratedFailureCountPath?;
+    private readonly label?;
+    private readonly resultWriter?;
+    private readonly itemBatcher?;
+    constructor(scope: Construct, id: string, props?: DistributedMapProps);
+    /**
+     * Validate this state
+     */
+    protected validateState(): string[];
+    protected whenBoundToGraph(graph: StateGraph): void;
+    /**
+     * Add retry configuration for this state
+     *
+     * This controls if and how the execution will be retried if a particular
+     * error occurs.
+     */
+    addRetry(props?: RetryProps): DistributedMap;
+    /**
+     * 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): DistributedMap;
+    /**
+     * Define item processor in a Distributed Map.
+     *
+     * A Distributed Map must have a non-empty item processor
+     */
+    itemProcessor(processor: IChainable, config?: ProcessorConfig): DistributedMap;
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(): object;
+    /**
+     * Render the ItemReader as JSON object
+     */
+    private renderItemReader;
+    /**
+     * Render ResultWriter in ASL JSON format
+     */
+    private renderResultWriter;
+    /**
+     * Render ItemBatcher in ASL JSON format
+     */
+    private renderItemBatcher;
+}