terraconstructs 0.0.8

package/lib/aws/compute/states/custom-state.d.ts

@@ -0,0 +1,55 @@
+import { Construct } from "constructs";
+import { Chain } from "..";
+import { State } from "./state";
+import { CatchProps, IChainable, INextable, RetryProps } from "../types";
+/**
+ * Properties for defining a custom state definition
+ */
+export interface CustomStateProps {
+    /**
+     * Amazon States Language (JSON-based) definition of the state
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html
+     */
+    readonly stateJson: {
+        [key: string]: any;
+    };
+}
+/**
+ * State defined by supplying Amazon States Language (ASL) in the state machine.
+ *
+ */
+export declare class CustomState extends State implements IChainable, INextable {
+    readonly endStates: INextable[];
+    /**
+     * Amazon States Language (JSON-based) definition of the state
+     */
+    private readonly stateJson;
+    constructor(scope: Construct, id: string, props: CustomStateProps);
+    /**
+     * Add retry configuration for this state
+     *
+     * This controls if and how the execution will be retried if a particular
+     * error occurs.
+     */
+    addRetry(props?: RetryProps): CustomState;
+    /**
+     * 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): CustomState;
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next: IChainable): Chain;
+    /**
+     * Returns the Amazon States Language object for this state
+     */
+    toStateJson(): object;
+    private hasMultipleRetrySources;
+    private hasMultipleCatchSources;
+    private addMultipleRetrySourcesWarning;
+    private addMultipleCatchSourcesWarning;
+}

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

@@ -0,0 +1,114 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomState = 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/custom-state.ts
+const cdktf_1 = require("cdktf");
+const __1 = require("..");
+const state_1 = require("./state");
+/**
+ * State defined by supplying Amazon States Language (ASL) in the state machine.
+ *
+ */
+class CustomState extends state_1.State {
+    constructor(scope, id, props) {
+        super(scope, id, {});
+        this.endStates = [this];
+        this.stateJson = props.stateJson;
+    }
+    /**
+     * 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 __1.Chain.sequence(this, next);
+    }
+    /**
+     * Returns the Amazon States Language object for this state
+     */
+    toStateJson() {
+        const state = {
+            ...this.renderNextEnd(),
+            ...this.stateJson,
+            ...this.renderRetryCatch(),
+        };
+        if (this.hasMultipleRetrySources(state)) {
+            this.addMultipleRetrySourcesWarning();
+        }
+        if (this.hasMultipleCatchSources(state)) {
+            this.addMultipleCatchSourcesWarning();
+        }
+        // Retriers and Catchers can be specified directly in the stateJson or indirectly to the construct with addRetry() and addCatch().
+        // renderRetryCatch() only renders the indirectly supplied Retriers and Catchers, so we need to manually merge in those directly in the stateJson
+        if (Array.isArray(this.stateJson.Retry)) {
+            state.Retry = Array.isArray(state.Retry)
+                ? [...state.Retry, ...this.stateJson.Retry]
+                : [...this.stateJson.Retry];
+        }
+        if (Array.isArray(this.stateJson.Catch)) {
+            state.Catch = Array.isArray(state.Catch)
+                ? [...state.Catch, ...this.stateJson.Catch]
+                : [...this.stateJson.Catch];
+        }
+        return state;
+    }
+    hasMultipleRetrySources(state) {
+        if (!Array.isArray(state.Retry)) {
+            return false;
+        }
+        if (!Array.isArray(this.stateJson.Retry)) {
+            return false;
+        }
+        return state.Retry.length > 0 && this.stateJson.Retry.length > 0;
+    }
+    hasMultipleCatchSources(state) {
+        if (!Array.isArray(state.Catch)) {
+            return false;
+        }
+        if (!Array.isArray(this.stateJson.Catch)) {
+            return false;
+        }
+        return state.Catch.length > 0 && this.stateJson.Catch.length > 0;
+    }
+    addMultipleRetrySourcesWarning() {
+        // "@aws-cdk/aws-stepfunctions:multipleRetrySources", // TODO: CDKTF does not support acknowledgeable warnings
+        cdktf_1.Annotations.of(this).addWarning([
+            "CustomState constructs can configure state retries using the stateJson property or by using the addRetry() function.",
+            "When retries are configured using both of these, the state definition's Retry field is generated ",
+            "by first rendering retries from addRetry(), then rendering retries from the stateJson.",
+        ].join("\n"));
+    }
+    addMultipleCatchSourcesWarning() {
+        // "@aws-cdk/aws-stepfunctions:multipleCatchSources", // TODO: CDKTF does not support acknowledgeable warnings
+        cdktf_1.Annotations.of(this).addWarning([
+            "CustomState constructs can configure state catchers using the stateJson property or by using the addCatch() function.",
+            "When catchers are configured using both of these, the state definition's Catch field is generated ",
+            "by first rendering catchers from addCatch(), then rendering catchers from the stateJson.",
+        ].join("\n"));
+    }
+}
+exports.CustomState = CustomState;
+_a = JSII_RTTI_SYMBOL_1;
+CustomState[_a] = { fqn: "terraconstructs.aws.compute.CustomState", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-state.js","sourceRoot":"","sources":["../../../../src/aws/compute/states/custom-state.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-stepfunctions/lib/states/custom-state.ts\n\nimport { Annotations } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { Chain } from \"..\";\nimport { State } from \"./state\";\nimport { CatchProps, IChainable, INextable, RetryProps } from \"../types\";\n\n/**\n * Properties for defining a custom state definition\n */\nexport interface CustomStateProps {\n  /**\n   * Amazon States Language (JSON-based) definition of the state\n   *\n   * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html\n   */\n  readonly stateJson: { [key: string]: any };\n}\n\n/**\n * State defined by supplying Amazon States Language (ASL) in the state machine.\n *\n */\nexport class CustomState extends State implements IChainable, INextable {\n  public readonly endStates: INextable[];\n\n  /**\n   * Amazon States Language (JSON-based) definition of the state\n   */\n  private readonly stateJson: { [key: string]: any };\n\n  constructor(scope: Construct, id: string, props: CustomStateProps) {\n    super(scope, id, {});\n\n    this.endStates = [this];\n    this.stateJson = props.stateJson;\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 = {}): CustomState {\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 = {}): CustomState {\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   * Returns the Amazon States Language object for this state\n   */\n  public toStateJson(): object {\n    const state = {\n      ...this.renderNextEnd(),\n      ...this.stateJson,\n      ...this.renderRetryCatch(),\n    };\n\n    if (this.hasMultipleRetrySources(state)) {\n      this.addMultipleRetrySourcesWarning();\n    }\n\n    if (this.hasMultipleCatchSources(state)) {\n      this.addMultipleCatchSourcesWarning();\n    }\n\n    // Retriers and Catchers can be specified directly in the stateJson or indirectly to the construct with addRetry() and addCatch().\n    // renderRetryCatch() only renders the indirectly supplied Retriers and Catchers, so we need to manually merge in those directly in the stateJson\n    if (Array.isArray(this.stateJson.Retry)) {\n      state.Retry = Array.isArray(state.Retry)\n        ? [...state.Retry, ...this.stateJson.Retry]\n        : [...this.stateJson.Retry];\n    }\n\n    if (Array.isArray(this.stateJson.Catch)) {\n      state.Catch = Array.isArray(state.Catch)\n        ? [...state.Catch, ...this.stateJson.Catch]\n        : [...this.stateJson.Catch];\n    }\n\n    return state;\n  }\n\n  private hasMultipleRetrySources(state: any): boolean {\n    if (!Array.isArray(state.Retry)) {\n      return false;\n    }\n\n    if (!Array.isArray(this.stateJson.Retry)) {\n      return false;\n    }\n\n    return state.Retry.length > 0 && this.stateJson.Retry.length > 0;\n  }\n\n  private hasMultipleCatchSources(state: any): boolean {\n    if (!Array.isArray(state.Catch)) {\n      return false;\n    }\n\n    if (!Array.isArray(this.stateJson.Catch)) {\n      return false;\n    }\n\n    return state.Catch.length > 0 && this.stateJson.Catch.length > 0;\n  }\n\n  private addMultipleRetrySourcesWarning(): void {\n    // \"@aws-cdk/aws-stepfunctions:multipleRetrySources\", // TODO: CDKTF does not support acknowledgeable warnings\n    Annotations.of(this).addWarning(\n      [\n        \"CustomState constructs can configure state retries using the stateJson property or by using the addRetry() function.\",\n        \"When retries are configured using both of these, the state definition's Retry field is generated \",\n        \"by first rendering retries from addRetry(), then rendering retries from the stateJson.\",\n      ].join(\"\\n\"),\n    );\n  }\n\n  private addMultipleCatchSourcesWarning(): void {\n    // \"@aws-cdk/aws-stepfunctions:multipleCatchSources\", // TODO: CDKTF does not support acknowledgeable warnings\n    Annotations.of(this).addWarning(\n      [\n        \"CustomState constructs can configure state catchers using the stateJson property or by using the addCatch() function.\",\n        \"When catchers are configured using both of these, the state definition's Catch field is generated \",\n        \"by first rendering catchers from addCatch(), then rendering catchers from the stateJson.\",\n      ].join(\"\\n\"),\n    );\n  }\n}\n"]}

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

@@ -0,0 +1,64 @@
+/**
+ * Interface for ItemBatcher configuration properties
+ */
+export interface ItemBatcherProps {
+    /**
+     * MaxItemsPerBatch
+     *
+     * Specifies the maximum number of items that each child workflow execution processes, as static number
+     *
+     * @default - uses value of `maxItemsPerBatchPath` as the max items per batch,
+     *   no limits on the number of items in a batch under the 256KB limit if that property was also not provided
+     */
+    readonly maxItemsPerBatch?: number;
+    /**
+     * MaxItemsPerBatchPath
+     *
+     * Specifies the maximum number of items that each child workflow execution processes, as JsonPath
+     *
+     * @default - uses value of `maxItemsPerBatch` as the max items per batch,
+     *   no limits on the number of items in a batch under the 256KB limit if that property was also not provided
+     */
+    readonly maxItemsPerBatchPath?: string;
+    /**
+     * MaxInputBytesPerBatch
+     *
+     * Specifies the maximum number of bytes that each child workflow execution processes, as static number
+     *
+     * @default - uses value of `maxInputBytesPerBatchPath` as the max size per batch,
+     *   no limits on the batch size under the 256KB limit if that property was also not provided
+     */
+    readonly maxInputBytesPerBatch?: number;
+    /**
+     * MaxInputBytesPerBatchPath
+     *
+     * Specifies the maximum number of bytes that each child workflow execution processes, as JsonPath
+     *
+     * @default - uses value of `maxInputBytesPerBatch` as the max size per batch,
+     *   no limits on the batch size under the 256KB limit if that property was also not provided
+     */
+    readonly maxInputBytesPerBatchPath?: string;
+    /**
+     * BatchInput
+     *
+     * Fixed JSON input to include in each batch passed to each child workflow execution
+     *
+     * @default - No batchInput
+     */
+    readonly batchInput?: object;
+}
+/**
+ * Configuration for processing a group of items in a single child workflow execution
+ */
+export declare class ItemBatcher {
+    private props;
+    constructor(props: ItemBatcherProps);
+    /**
+     * Render ItemBatcher in ASL JSON format
+     */
+    render(): any;
+    /**
+     * Validate this ItemBatcher
+     */
+    validateItemBatcher(): string[];
+}

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

@@ -0,0 +1,58 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemBatcher = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Configuration for processing a group of items in a single child workflow execution
+ */
+class ItemBatcher {
+    constructor(props) {
+        this.props = props;
+    }
+    /**
+     * Render ItemBatcher in ASL JSON format
+     */
+    render() {
+        return {
+            ...(this.props.maxItemsPerBatch && {
+                MaxItemsPerBatch: this.props.maxItemsPerBatch,
+            }),
+            ...(this.props.maxItemsPerBatchPath && {
+                MaxItemsPerBatchPath: this.props.maxItemsPerBatchPath,
+            }),
+            ...(this.props.maxInputBytesPerBatch && {
+                MaxInputBytesPerBatch: this.props.maxInputBytesPerBatch,
+            }),
+            ...(this.props.maxInputBytesPerBatchPath && {
+                MaxInputBytesPerBatchPath: this.props.maxInputBytesPerBatchPath,
+            }),
+            ...(this.props.batchInput && { BatchInput: this.props.batchInput }),
+        };
+    }
+    /**
+     * Validate this ItemBatcher
+     */
+    validateItemBatcher() {
+        const errors = [];
+        if (this.props.maxItemsPerBatch && this.props.maxItemsPerBatchPath) {
+            errors.push("Provide either `maxItemsPerBatch` or `maxItemsPerBatchPath`, but not both");
+        }
+        if (this.props.maxInputBytesPerBatch &&
+            this.props.maxInputBytesPerBatchPath) {
+            errors.push("Provide either `maxInputBytesPerBatch` or `maxInputBytesPerBatchPath`, but not both");
+        }
+        if (!this.props.maxItemsPerBatch &&
+            !this.props.maxItemsPerBatchPath &&
+            !this.props.maxInputBytesPerBatch &&
+            !this.props.maxInputBytesPerBatchPath &&
+            !this.props.batchInput) {
+            errors.push("Provide at least one value to the ItemBatcher");
+        }
+        return errors;
+    }
+}
+exports.ItemBatcher = ItemBatcher;
+_a = JSII_RTTI_SYMBOL_1;
+ItemBatcher[_a] = { fqn: "terraconstructs.aws.compute.ItemBatcher", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,256 @@
+import { Construct } from "constructs";
+import * as iam from "../../../iam";
+import { IBucket } from "../../../storage";
+/**
+ * Base interface for Item Reader configurations
+ */
+export interface IItemReader {
+    /**
+     * S3 Bucket containing objects to iterate over or a file with a list to iterate over
+     */
+    readonly bucket?: IBucket;
+    /**
+     * S3 bucket name containing objects to iterate over or a file with a list to iterate over, as JsonPath
+     */
+    readonly bucketNamePath?: string;
+    /**
+     * The Amazon S3 API action that Step Functions must invoke depending on the specified dataset.
+     */
+    readonly resource: string;
+    /**
+     * Limits the number of items passed to the Distributed Map state
+     *
+     * @default - Distributed Map state will iterate over all items provided by the ItemReader
+     */
+    readonly maxItems?: number;
+    /**
+     * Render the ItemReader as JSON object
+     */
+    render(): any;
+    /**
+     * Compile policy statements to provide relevent permissions to the state machine
+     */
+    providePolicyStatements(): iam.PolicyStatement[];
+    /**
+     * Validate that ItemReader contains exactly either @see bucket or @see bucketNamePath
+     */
+    validateItemReader(): string[];
+}
+/**
+ * Base interface for Item Reader configuration properties
+ */
+export interface ItemReaderProps {
+    /**
+     * S3 Bucket containing objects to iterate over or a file with a list to iterate over
+     *
+     * @default - S3 bucket will be determined from @see bucketNamePath
+     */
+    readonly bucket?: IBucket;
+    /**
+     * S3 bucket name containing objects to iterate over or a file with a list to iterate over, as JsonPath
+     *
+     * @default - S3 bucket will be determined from @see bucket
+     */
+    readonly bucketNamePath?: string;
+    /**
+     * S3 bucket name scope, only required if @see bucketNamePath is provided
+     */
+    readonly bucketNameScope?: Construct;
+    /**
+     * Limits the number of items passed to the Distributed Map state
+     *
+     * @default - Distributed Map state will iterate over all items provided by the ItemReader
+     */
+    readonly maxItems?: number;
+}
+/**
+ * Properties for configuring an Item Reader that iterates over objects in an S3 bucket
+ */
+export interface S3ObjectsItemReaderProps extends ItemReaderProps {
+    /**
+     * S3 prefix used to limit objects to iterate over
+     *
+     * @default - No prefix
+     */
+    readonly prefix?: string;
+}
+/**
+ * Item Reader configuration for iterating over objects in an S3 bucket
+ */
+export declare class S3ObjectsItemReader implements IItemReader {
+    /**
+     * S3 Bucket containing objects to iterate over
+     */
+    readonly bucket?: IBucket;
+    /**
+     * S3 bucket name containing objects to iterate over or a file with a list to iterate over, as JsonPath
+     */
+    readonly bucketNamePath?: string;
+    /**
+     * ARN for the `listObjectsV2` method of the S3 API
+     * This API method is used to iterate all objects in the S3 bucket/prefix
+     */
+    readonly resource: string;
+    /**
+     * S3 prefix used to limit objects to iterate over
+     *
+     * @default - No prefix
+     */
+    readonly prefix?: string;
+    /**
+     * Limits the number of items passed to the Distributed Map state
+     *
+     * @default - Distributed Map state will iterate over all items provided by the ItemReader
+     */
+    readonly maxItems?: number;
+    /**
+     * S3 bucket name scope
+     */
+    readonly bucketNameScope?: Construct;
+    protected get partition(): string;
+    constructor(props: S3ObjectsItemReaderProps);
+    /**
+     * Renders the ItemReader configuration as JSON object
+     * @returns - JSON object
+     */
+    render(): any;
+    /**
+     * Compile policy statements to provide relevent permissions to the state machine
+     */
+    providePolicyStatements(): iam.PolicyStatement[];
+    /**
+     * Validate that ItemReader contains exactly either @see bucket or @see bucketNamePath
+     */
+    validateItemReader(): string[];
+}
+/**
+ * Base interface for Item Reader configuration properties the iterate over entries in a S3 file
+ */
+export interface S3FileItemReaderProps extends ItemReaderProps {
+    /**
+     * Key of file stored in S3 bucket containing an array to iterate over
+     */
+    readonly key: string;
+}
+/**
+ * Base Item Reader configuration for iterating over entries in a S3 file
+ */
+declare abstract class S3FileItemReader implements IItemReader {
+    /**
+     * S3 Bucket containing a file with a list to iterate over
+     */
+    readonly bucket?: IBucket;
+    /**
+     * S3 bucket name containing objects to iterate over or a file with a list to iterate over, as JsonPath
+     */
+    readonly bucketNamePath?: string;
+    /**
+     * S3 key of a file with a list to iterate over
+     */
+    readonly key: string;
+    /**
+     * ARN for the `getObject` method of the S3 API
+     * This API method is used to iterate all objects in the S3 bucket/prefix
+     */
+    readonly resource: string;
+    /**
+     * Limits the number of items passed to the Distributed Map state
+     *
+     * @default - No maxItems
+     */
+    readonly maxItems?: number;
+    /**
+     * S3 bucket name scope
+     */
+    readonly bucketNameScope?: Construct;
+    protected get partition(): string;
+    protected abstract readonly inputType: string;
+    constructor(props: S3FileItemReaderProps);
+    /**
+     * Renders the ItemReader configuration as JSON object
+     * @returns - JSON object
+     */
+    render(): any;
+    /**
+     * Compile policy statements to provide relevent permissions to the state machine
+     */
+    providePolicyStatements(): iam.PolicyStatement[];
+    /**
+     * Validate that ItemReader contains exactly either @see bucket or @see bucketNamePath and @see bucketNameScope
+     */
+    validateItemReader(): string[];
+}
+/**
+ * Item Reader configuration for iterating over items in a JSON array stored in a S3 file
+ */
+export declare class S3JsonItemReader extends S3FileItemReader {
+    protected readonly inputType: string;
+}
+/**
+ * CSV header location options
+ */
+export declare enum CsvHeaderLocation {
+    /**
+     * Headers will be read from first row of CSV file
+     */
+    FIRST_ROW = "FIRST_ROW",
+    /**
+     * Headers are provided in CSVHeaders property
+     */
+    GIVEN = "GIVEN"
+}
+/**
+ * Configuration for CSV header options for a CSV Item Reader
+ */
+export declare class CsvHeaders {
+    /**
+     * Configures S3CsvItemReader to read headers from the first row of the CSV file
+     * @returns - CsvHeaders
+     */
+    static useFirstRow(): CsvHeaders;
+    /**
+     * Configures S3CsvItemReader to use the headers provided in the `headers` parameter
+     * @param headers - List of headers
+     * @returns - CsvHeaders
+     */
+    static use(headers: string[]): CsvHeaders;
+    /**
+     * Location of headers in CSV file
+     */
+    readonly headerLocation: CsvHeaderLocation;
+    /**
+     * List of headers if `headerLocation` is `GIVEN`
+     */
+    readonly headers?: string[];
+    private constructor();
+}
+/**
+ * Properties for configuring an Item Reader that iterates over items in a CSV file in S3
+ */
+export interface S3CsvItemReaderProps extends S3FileItemReaderProps {
+    /**
+     * CSV file header configuration
+     *
+     * @default - CsvHeaders with CsvHeadersLocation.FIRST_ROW
+     */
+    readonly csvHeaders?: CsvHeaders;
+}
+/**
+ * Item Reader configuration for iterating over items in a CSV file stored in S3
+ */
+export declare class S3CsvItemReader extends S3FileItemReader {
+    /**
+     * CSV headers configuration
+     */
+    readonly csvHeaders: CsvHeaders;
+    protected readonly inputType: string;
+    constructor(props: S3CsvItemReaderProps);
+    render(): any;
+}
+/**
+ * Item Reader configuration for iterating over items in a S3 inventory manifest file stored in S3
+ */
+export declare class S3ManifestItemReader extends S3FileItemReader {
+    protected readonly inputType: string;
+}
+export {};