terraconstructs 0.0.8

package/lib/aws/compute/tasks/stepfunctions/start-execution.js

@@ -0,0 +1,123 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepFunctionsStartExecution = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const compute = require("../../");
+const arn_1 = require("../../../arn");
+const aws_stack_1 = require("../../../aws-stack");
+const iam = require("../../../iam");
+const task_utils_1 = require("../private/task-utils");
+/**
+ * A Step Functions Task to call StartExecution on another state machine.
+ *
+ * It supports three service integration patterns: REQUEST_RESPONSE, RUN_JOB, and WAIT_FOR_TASK_TOKEN.
+ */
+class StepFunctionsStartExecution extends compute.TaskStateBase {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        this.integrationPattern =
+            props.integrationPattern || compute.IntegrationPattern.REQUEST_RESPONSE;
+        (0, task_utils_1.validatePatternSupported)(this.integrationPattern, StepFunctionsStartExecution.SUPPORTED_INTEGRATION_PATTERNS);
+        if (this.integrationPattern ===
+            compute.IntegrationPattern.WAIT_FOR_TASK_TOKEN &&
+            !compute.FieldUtils.containsTaskToken(props.input)) {
+            throw new Error("Task Token is required in `input` for callback. Use JsonPath.taskToken to set the token.");
+        }
+        if (this.props.associateWithParent &&
+            props.input &&
+            props.input.type !== compute.InputType.OBJECT) {
+            throw new Error("Could not enable `associateWithParent` because `input` is taken directly from a JSON path. Use `sfn.TaskInput.fromObject` instead.");
+        }
+        this.taskPolicies = this.createScopedAccessPolicy();
+    }
+    /**
+     * @internal
+     */
+    _renderTask() {
+        // suffix of ':2' indicates that the output of the nested state machine should be JSON
+        // suffix is only applicable when waiting for a nested state machine to complete (RUN_JOB)
+        // https://docs.aws.amazon.com/step-functions/latest/dg/connect-stepfunctions.html
+        const suffix = this.integrationPattern === compute.IntegrationPattern.RUN_JOB
+            ? ":2"
+            : "";
+        let input;
+        if (this.props.associateWithParent) {
+            const associateWithParentEntry = {
+                AWS_STEP_FUNCTIONS_STARTED_BY_EXECUTION_ID: compute.JsonPath.stringAt("$$.Execution.Id"),
+            };
+            input = this.props.input
+                ? { ...this.props.input.value, ...associateWithParentEntry }
+                : associateWithParentEntry;
+        }
+        else {
+            input = this.props.input
+                ? this.props.input.value
+                : compute.TaskInput.fromJsonPathAt("$").value;
+        }
+        return {
+            Resource: `${(0, task_utils_1.integrationResourceArn)(this, "states", "startExecution", this.integrationPattern)}${suffix}`,
+            Parameters: compute.FieldUtils.renderObject({
+                Input: input,
+                StateMachineArn: this.props.stateMachine.stateMachineArn,
+                Name: this.props.name,
+            }),
+        };
+    }
+    /**
+     * As StateMachineArn is extracted automatically from the state machine object included in the constructor,
+     *
+     * the scoped access policy should be generated accordingly.
+     *
+     * This means the action of StartExecution should be restricted on the given state machine, instead of being granted to all the resources (*).
+     */
+    createScopedAccessPolicy() {
+        const stack = aws_stack_1.AwsStack.ofAwsConstruct(this);
+        const policyStatements = [
+            new iam.PolicyStatement({
+                actions: ["states:StartExecution"],
+                resources: [this.props.stateMachine.stateMachineArn],
+            }),
+        ];
+        // Step Functions use Cloud Watch managed rules to deal with synchronous tasks.
+        if (this.integrationPattern === compute.IntegrationPattern.RUN_JOB) {
+            policyStatements.push(new iam.PolicyStatement({
+                actions: ["states:DescribeExecution", "states:StopExecution"],
+                // https://docs.aws.amazon.com/step-functions/latest/dg/concept-create-iam-advanced.html#concept-create-iam-advanced-execution
+                resources: [
+                    stack.formatArn({
+                        service: "states",
+                        resource: "execution",
+                        arnFormat: arn_1.ArnFormat.COLON_RESOURCE_NAME,
+                        resourceName: `${stack.splitArn(this.props.stateMachine.stateMachineArn, arn_1.ArnFormat.COLON_RESOURCE_NAME).resourceName}*`,
+                    }),
+                ],
+            }));
+            policyStatements.push(new iam.PolicyStatement({
+                actions: [
+                    "events:PutTargets",
+                    "events:PutRule",
+                    "events:DescribeRule",
+                ],
+                resources: [
+                    stack.formatArn({
+                        service: "events",
+                        resource: "rule",
+                        resourceName: "StepFunctionsGetEventsForStepFunctionsExecutionRule",
+                    }),
+                ],
+            }));
+        }
+        return policyStatements;
+    }
+}
+exports.StepFunctionsStartExecution = StepFunctionsStartExecution;
+_a = JSII_RTTI_SYMBOL_1;
+StepFunctionsStartExecution[_a] = { fqn: "terraconstructs.aws.compute.tasks.StepFunctionsStartExecution", version: "0.0.8" };
+StepFunctionsStartExecution.SUPPORTED_INTEGRATION_PATTERNS = [
+    compute.IntegrationPattern.REQUEST_RESPONSE,
+    compute.IntegrationPattern.RUN_JOB,
+    compute.IntegrationPattern.WAIT_FOR_TASK_TOKEN,
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"start-execution.js","sourceRoot":"","sources":["../../../../../src/aws/compute/tasks/stepfunctions/start-execution.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport * as compute from \"../../\";\nimport { ArnFormat } from \"../../../arn\";\nimport { AwsStack } from \"../../../aws-stack\";\nimport * as iam from \"../../../iam\";\nimport {\n  integrationResourceArn,\n  validatePatternSupported,\n} from \"../private/task-utils\";\n\n/**\n * Properties for StartExecution\n */\nexport interface StepFunctionsStartExecutionProps\n  extends compute.TaskStateBaseProps {\n  /**\n   * The Step Functions state machine to start the execution on.\n   */\n  readonly stateMachine: compute.IStateMachine;\n\n  /**\n   * The JSON input for the execution, same as that of StartExecution.\n   *\n   * @see https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html\n   *\n   * @default - The state input (JSON path '$')\n   */\n  readonly input?: compute.TaskInput;\n\n  /**\n   * The name of the execution, same as that of StartExecution.\n   *\n   * @see https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html\n   *\n   * @default - None\n   */\n  readonly name?: string;\n\n  /**\n   * Pass the execution ID from the context object to the execution input.\n   * This allows the Step Functions UI to link child executions from parent executions, making it easier to trace execution flow across state machines.\n   *\n   * If you set this property to `true`, the `input` property must be an object (provided by `sfn.TaskInput.fromObject`) or omitted entirely.\n   *\n   * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-nested-workflows.html#nested-execution-startid\n   *\n   * @default - false\n   */\n  readonly associateWithParent?: boolean;\n}\n\n/**\n * A Step Functions Task to call StartExecution on another state machine.\n *\n * It supports three service integration patterns: REQUEST_RESPONSE, RUN_JOB, and WAIT_FOR_TASK_TOKEN.\n */\nexport class StepFunctionsStartExecution extends compute.TaskStateBase {\n  private static readonly SUPPORTED_INTEGRATION_PATTERNS = [\n    compute.IntegrationPattern.REQUEST_RESPONSE,\n    compute.IntegrationPattern.RUN_JOB,\n    compute.IntegrationPattern.WAIT_FOR_TASK_TOKEN,\n  ];\n\n  // protected readonly taskMetrics?: compute.TaskMetricsConfig;\n  protected readonly taskPolicies?: iam.PolicyStatement[];\n\n  private readonly integrationPattern: compute.IntegrationPattern;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    private readonly props: StepFunctionsStartExecutionProps,\n  ) {\n    super(scope, id, props);\n\n    this.integrationPattern =\n      props.integrationPattern || compute.IntegrationPattern.REQUEST_RESPONSE;\n    validatePatternSupported(\n      this.integrationPattern,\n      StepFunctionsStartExecution.SUPPORTED_INTEGRATION_PATTERNS,\n    );\n\n    if (\n      this.integrationPattern ===\n        compute.IntegrationPattern.WAIT_FOR_TASK_TOKEN &&\n      !compute.FieldUtils.containsTaskToken(props.input)\n    ) {\n      throw new Error(\n        \"Task Token is required in `input` for callback. Use JsonPath.taskToken to set the token.\",\n      );\n    }\n\n    if (\n      this.props.associateWithParent &&\n      props.input &&\n      props.input.type !== compute.InputType.OBJECT\n    ) {\n      throw new Error(\n        \"Could not enable `associateWithParent` because `input` is taken directly from a JSON path. Use `sfn.TaskInput.fromObject` instead.\",\n      );\n    }\n\n    this.taskPolicies = this.createScopedAccessPolicy();\n  }\n\n  /**\n   * @internal\n   */\n  protected _renderTask(): any {\n    // suffix of ':2' indicates that the output of the nested state machine should be JSON\n    // suffix is only applicable when waiting for a nested state machine to complete (RUN_JOB)\n    // https://docs.aws.amazon.com/step-functions/latest/dg/connect-stepfunctions.html\n    const suffix =\n      this.integrationPattern === compute.IntegrationPattern.RUN_JOB\n        ? \":2\"\n        : \"\";\n    let input: any;\n    if (this.props.associateWithParent) {\n      const associateWithParentEntry = {\n        AWS_STEP_FUNCTIONS_STARTED_BY_EXECUTION_ID:\n          compute.JsonPath.stringAt(\"$$.Execution.Id\"),\n      };\n      input = this.props.input\n        ? { ...this.props.input.value, ...associateWithParentEntry }\n        : associateWithParentEntry;\n    } else {\n      input = this.props.input\n        ? this.props.input.value\n        : compute.TaskInput.fromJsonPathAt(\"$\").value;\n    }\n\n    return {\n      Resource: `${integrationResourceArn(this, \"states\", \"startExecution\", this.integrationPattern)}${suffix}`,\n      Parameters: compute.FieldUtils.renderObject({\n        Input: input,\n        StateMachineArn: this.props.stateMachine.stateMachineArn,\n        Name: this.props.name,\n      }),\n    };\n  }\n\n  /**\n   * As StateMachineArn is extracted automatically from the state machine object included in the constructor,\n   *\n   * the scoped access policy should be generated accordingly.\n   *\n   * This means the action of StartExecution should be restricted on the given state machine, instead of being granted to all the resources (*).\n   */\n  private createScopedAccessPolicy(): iam.PolicyStatement[] {\n    const stack = AwsStack.ofAwsConstruct(this);\n    const policyStatements = [\n      new iam.PolicyStatement({\n        actions: [\"states:StartExecution\"],\n        resources: [this.props.stateMachine.stateMachineArn],\n      }),\n    ];\n\n    // Step Functions use Cloud Watch managed rules to deal with synchronous tasks.\n    if (this.integrationPattern === compute.IntegrationPattern.RUN_JOB) {\n      policyStatements.push(\n        new iam.PolicyStatement({\n          actions: [\"states:DescribeExecution\", \"states:StopExecution\"],\n          // https://docs.aws.amazon.com/step-functions/latest/dg/concept-create-iam-advanced.html#concept-create-iam-advanced-execution\n          resources: [\n            stack.formatArn({\n              service: \"states\",\n              resource: \"execution\",\n              arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n              resourceName: `${stack.splitArn(this.props.stateMachine.stateMachineArn, ArnFormat.COLON_RESOURCE_NAME).resourceName}*`,\n            }),\n          ],\n        }),\n      );\n\n      policyStatements.push(\n        new iam.PolicyStatement({\n          actions: [\n            \"events:PutTargets\",\n            \"events:PutRule\",\n            \"events:DescribeRule\",\n          ],\n          resources: [\n            stack.formatArn({\n              service: \"events\",\n              resource: \"rule\",\n              resourceName:\n                \"StepFunctionsGetEventsForStepFunctionsExecutionRule\",\n            }),\n          ],\n        }),\n      );\n    }\n\n    return policyStatements;\n  }\n}\n"]}

package/lib/aws/compute/types.d.ts

@@ -0,0 +1,214 @@
+import { Chain } from "./chain";
+import { Duration } from "../..";
+import { State } from "./states/state";
+/**
+ * Interface for states that can have 'next' states
+ */
+export interface INextable {
+    /**
+     * Go to the indicated state after this state
+     *
+     * @returns The chain of states built up
+     */
+    next(state: IChainable): Chain;
+}
+/**
+ * Interface for objects that can be used in a Chain
+ */
+export interface IChainable {
+    /**
+     * Descriptive identifier for this chainable
+     */
+    readonly id: string;
+    /**
+     * The start state of this chainable
+     */
+    readonly startState: State;
+    /**
+     * The chainable end state(s) of this chainable
+     */
+    readonly endStates: INextable[];
+}
+/**
+ * Values allowed in the retrier JitterStrategy field
+ */
+export declare enum JitterType {
+    /**
+     * Calculates the delay to be a random number between 0 and the computed backoff for the given retry attempt count
+     */
+    FULL = "FULL",
+    /**
+     * Calculates the delay to be the computed backoff for the given retry attempt count (equivalent to if Jitter was not declared - i.e. the default value)
+     */
+    NONE = "NONE"
+}
+/**
+ * Predefined error strings
+ * Error names in Amazon States Language - https://states-language.net/spec.html#appendix-a
+ * Error handling in Step Functions - https://docs.aws.amazon.com/step-functions/latest/dg/concepts-error-handling.html
+ */
+export declare class Errors {
+    /**
+     * Matches any Error.
+     */
+    static readonly ALL = "States.ALL";
+    /**
+     * A Task State failed to heartbeat for a time longer than the “HeartbeatSeconds” value.
+     */
+    static readonly HEARTBEAT_TIMEOUT = "States.HeartbeatTimeout";
+    /**
+     * A Task State either ran longer than the “TimeoutSeconds” value, or
+     * failed to heartbeat for a time longer than the “HeartbeatSeconds” value.
+     */
+    static readonly TIMEOUT = "States.Timeout";
+    /**
+     * A Task State failed during the execution.
+     */
+    static readonly TASKS_FAILED = "States.TaskFailed";
+    /**
+     * A Task State failed because it had insufficient privileges to execute
+     * the specified code.
+     */
+    static readonly PERMISSIONS = "States.Permissions";
+    /**
+     * A Task State’s “ResultPath” field cannot be applied to the input the state received.
+     */
+    static readonly RESULT_PATH_MATCH_FAILURE = "States.ResultPathMatchFailure";
+    /**
+     * Within a state’s “Parameters” field, the attempt to replace a field whose
+     * name ends in “.$” using a Path failed.
+     */
+    static readonly PARAMETER_PATH_FAILURE = "States.ParameterPathFailure";
+    /**
+     * A branch of a Parallel state failed.
+     */
+    static readonly BRANCH_FAILED = "States.BranchFailed";
+    /**
+     * A Choice state failed to find a match for the condition field extracted
+     * from its input.
+     */
+    static readonly NO_CHOICE_MATCHED = "States.NoChoiceMatched";
+}
+/**
+ * Retry details
+ */
+export interface RetryProps {
+    /**
+     * Errors to retry
+     *
+     * A list of error strings to retry, which can be either predefined errors
+     * (for example Errors.NoChoiceMatched) or a self-defined error.
+     *
+     * @default All errors
+     */
+    readonly errors?: string[];
+    /**
+     * How many seconds to wait initially before retrying
+     *
+     * @default Duration.seconds(1)
+     */
+    readonly interval?: Duration;
+    /**
+     * How many times to retry this particular error.
+     *
+     * May be 0 to disable retry for specific errors (in case you have
+     * a catch-all retry policy).
+     *
+     * @default 3
+     */
+    readonly maxAttempts?: number;
+    /**
+     * Maximum limit on retry interval growth during exponential backoff.
+     *
+     * @default - No max delay
+     */
+    readonly maxDelay?: Duration;
+    /**
+     * Introduces a randomization over the retry interval.
+     *
+     * @default - No jitter strategy
+     */
+    readonly jitterStrategy?: JitterType;
+    /**
+     * Multiplication for how much longer the wait interval gets on every retry
+     *
+     * @default 2
+     */
+    readonly backoffRate?: number;
+}
+/**
+ * Error handler details
+ */
+export interface CatchProps {
+    /**
+     * Errors to recover from by going to the given state
+     *
+     * A list of error strings to retry, which can be either predefined errors
+     * (for example Errors.NoChoiceMatched) or a self-defined error.
+     *
+     * @default All errors
+     */
+    readonly errors?: string[];
+    /**
+     * JSONPath expression to indicate where to inject the error data
+     *
+     * May also be the special value JsonPath.DISCARD, which will cause the error
+     * data to be discarded.
+     *
+     * @default $
+     */
+    readonly resultPath?: string;
+}
+/**
+ * Mode of the Map workflow.
+ */
+export declare enum ProcessorMode {
+    /**
+     * Inline Map mode.
+     */
+    INLINE = "INLINE",
+    /**
+     * Distributed Map mode.
+     */
+    DISTRIBUTED = "DISTRIBUTED"
+}
+/**
+ * Execution type for the Map workflow.
+ */
+export declare enum ProcessorType {
+    /**
+     * Standard execution type.
+     */
+    STANDARD = "STANDARD",
+    /**
+     * Express execution type.
+     */
+    EXPRESS = "EXPRESS"
+}
+/**
+ * Specifies the configuration for the processor Map state.
+ */
+export interface ProcessorConfig {
+    /**
+     * Specifies the execution mode for the Map workflow.
+     *
+     * @default - ProcessorMode.INLINE if using the `Map` class, ProcessorMode.DISTRIBUTED if using the `DistributedMap` class
+     */
+    readonly mode?: ProcessorMode;
+    /**
+     * Specifies the execution type for the Map workflow.
+     *
+     * If you use the `Map` class, you must provide this field if you specified `DISTRIBUTED` for the `mode` sub-field.
+     *
+     * If you use the `DistributedMap` class, this property is ignored.
+     * Use the `mapExecutionType` in the `DistributedMap` class instead.
+     *
+     * @default - no execution type
+     */
+    readonly executionType?: ProcessorType;
+}
+/**
+ * Special string value to discard state input, output or result
+ * @deprecated use JsonPath.DISCARD
+ */
+export declare const DISCARD = "DISCARD";

package/lib/aws/compute/types.js

@@ -0,0 +1,103 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DISCARD = exports.ProcessorType = exports.ProcessorMode = exports.Errors = exports.JitterType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Values allowed in the retrier JitterStrategy field
+ */
+var JitterType;
+(function (JitterType) {
+    /**
+     * Calculates the delay to be a random number between 0 and the computed backoff for the given retry attempt count
+     */
+    JitterType["FULL"] = "FULL";
+    /**
+     * Calculates the delay to be the computed backoff for the given retry attempt count (equivalent to if Jitter was not declared - i.e. the default value)
+     */
+    JitterType["NONE"] = "NONE";
+})(JitterType || (exports.JitterType = JitterType = {}));
+/**
+ * Predefined error strings
+ * Error names in Amazon States Language - https://states-language.net/spec.html#appendix-a
+ * Error handling in Step Functions - https://docs.aws.amazon.com/step-functions/latest/dg/concepts-error-handling.html
+ */
+class Errors {
+}
+exports.Errors = Errors;
+_a = JSII_RTTI_SYMBOL_1;
+Errors[_a] = { fqn: "terraconstructs.aws.compute.Errors", version: "0.0.8" };
+/**
+ * Matches any Error.
+ */
+Errors.ALL = "States.ALL";
+/**
+ * A Task State failed to heartbeat for a time longer than the “HeartbeatSeconds” value.
+ */
+Errors.HEARTBEAT_TIMEOUT = "States.HeartbeatTimeout";
+/**
+ * A Task State either ran longer than the “TimeoutSeconds” value, or
+ * failed to heartbeat for a time longer than the “HeartbeatSeconds” value.
+ */
+Errors.TIMEOUT = "States.Timeout";
+/**
+ * A Task State failed during the execution.
+ */
+Errors.TASKS_FAILED = "States.TaskFailed";
+/**
+ * A Task State failed because it had insufficient privileges to execute
+ * the specified code.
+ */
+Errors.PERMISSIONS = "States.Permissions";
+/**
+ * A Task State’s “ResultPath” field cannot be applied to the input the state received.
+ */
+Errors.RESULT_PATH_MATCH_FAILURE = "States.ResultPathMatchFailure";
+/**
+ * Within a state’s “Parameters” field, the attempt to replace a field whose
+ * name ends in “.$” using a Path failed.
+ */
+Errors.PARAMETER_PATH_FAILURE = "States.ParameterPathFailure";
+/**
+ * A branch of a Parallel state failed.
+ */
+Errors.BRANCH_FAILED = "States.BranchFailed";
+/**
+ * A Choice state failed to find a match for the condition field extracted
+ * from its input.
+ */
+Errors.NO_CHOICE_MATCHED = "States.NoChoiceMatched";
+/**
+ * Mode of the Map workflow.
+ */
+var ProcessorMode;
+(function (ProcessorMode) {
+    /**
+     * Inline Map mode.
+     */
+    ProcessorMode["INLINE"] = "INLINE";
+    /**
+     * Distributed Map mode.
+     */
+    ProcessorMode["DISTRIBUTED"] = "DISTRIBUTED";
+})(ProcessorMode || (exports.ProcessorMode = ProcessorMode = {}));
+/**
+ * Execution type for the Map workflow.
+ */
+var ProcessorType;
+(function (ProcessorType) {
+    /**
+     * Standard execution type.
+     */
+    ProcessorType["STANDARD"] = "STANDARD";
+    /**
+     * Express execution type.
+     */
+    ProcessorType["EXPRESS"] = "EXPRESS";
+})(ProcessorType || (exports.ProcessorType = ProcessorType = {}));
+/**
+ * Special string value to discard state input, output or result
+ * @deprecated use JsonPath.DISCARD
+ */
+exports.DISCARD = "DISCARD";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/aws/compute/types.ts"],"names":[],"mappings":";;;;;AAqCA;;GAEG;AACH,IAAY,UAUX;AAVD,WAAY,UAAU;IACpB;;OAEG;IACH,2BAAa,CAAA;IAEb;;OAEG;IACH,2BAAa,CAAA;AACf,CAAC,EAVW,UAAU,0BAAV,UAAU,QAUrB;AAED;;;;GAIG;AACH,MAAa,MAAM;;AAAnB,wBAkDC;;;AAjDC;;GAEG;AACoB,UAAG,GAAG,YAAY,CAAC;AAE1C;;GAEG;AACoB,wBAAiB,GAAG,yBAAyB,CAAC;AAErE;;;GAGG;AACoB,cAAO,GAAG,gBAAgB,CAAC;AAElD;;GAEG;AACoB,mBAAY,GAAG,mBAAmB,CAAC;AAE1D;;;GAGG;AACoB,kBAAW,GAAG,oBAAoB,CAAC;AAE1D;;GAEG;AACoB,gCAAyB,GAC9C,+BAA+B,CAAC;AAElC;;;GAGG;AACoB,6BAAsB,GAAG,6BAA6B,CAAC;AAE9E;;GAEG;AACoB,oBAAa,GAAG,qBAAqB,CAAC;AAE7D;;;GAGG;AACoB,wBAAiB,GAAG,wBAAwB,CAAC;AAiFtE;;GAEG;AACH,IAAY,aAUX;AAVD,WAAY,aAAa;IACvB;;OAEG;IACH,kCAAiB,CAAA;IAEjB;;OAEG;IACH,4CAA2B,CAAA;AAC7B,CAAC,EAVW,aAAa,6BAAb,aAAa,QAUxB;AAED;;GAEG;AACH,IAAY,aAUX;AAVD,WAAY,aAAa;IACvB;;OAEG;IACH,sCAAqB,CAAA;IAErB;;OAEG;IACH,oCAAmB,CAAA;AACrB,CAAC,EAVW,aAAa,6BAAb,aAAa,QAUxB;AA0BD;;;GAGG;AACU,QAAA,OAAO,GAAG,SAAS,CAAC","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-stepfunctions/lib/types.ts\nimport { Chain } from \"./chain\";\nimport { Duration } from \"../..\";\nimport { State } from \"./states/state\";\n\n/**\n * Interface for states that can have 'next' states\n */\nexport interface INextable {\n  /**\n   * Go to the indicated state after this state\n   *\n   * @returns The chain of states built up\n   */\n  next(state: IChainable): Chain;\n}\n\n/**\n * Interface for objects that can be used in a Chain\n */\nexport interface IChainable {\n  /**\n   * Descriptive identifier for this chainable\n   */\n  readonly id: string;\n\n  /**\n   * The start state of this chainable\n   */\n  readonly startState: State;\n\n  /**\n   * The chainable end state(s) of this chainable\n   */\n  readonly endStates: INextable[];\n}\n\n/**\n * Values allowed in the retrier JitterStrategy field\n */\nexport enum JitterType {\n  /**\n   * Calculates the delay to be a random number between 0 and the computed backoff for the given retry attempt count\n   */\n  FULL = \"FULL\",\n\n  /**\n   * Calculates the delay to be the computed backoff for the given retry attempt count (equivalent to if Jitter was not declared - i.e. the default value)\n   */\n  NONE = \"NONE\",\n}\n\n/**\n * Predefined error strings\n * Error names in Amazon States Language - https://states-language.net/spec.html#appendix-a\n * Error handling in Step Functions - https://docs.aws.amazon.com/step-functions/latest/dg/concepts-error-handling.html\n */\nexport class Errors {\n  /**\n   * Matches any Error.\n   */\n  public static readonly ALL = \"States.ALL\";\n\n  /**\n   * A Task State failed to heartbeat for a time longer than the “HeartbeatSeconds” value.\n   */\n  public static readonly HEARTBEAT_TIMEOUT = \"States.HeartbeatTimeout\";\n\n  /**\n   * A Task State either ran longer than the “TimeoutSeconds” value, or\n   * failed to heartbeat for a time longer than the “HeartbeatSeconds” value.\n   */\n  public static readonly TIMEOUT = \"States.Timeout\";\n\n  /**\n   * A Task State failed during the execution.\n   */\n  public static readonly TASKS_FAILED = \"States.TaskFailed\";\n\n  /**\n   * A Task State failed because it had insufficient privileges to execute\n   * the specified code.\n   */\n  public static readonly PERMISSIONS = \"States.Permissions\";\n\n  /**\n   * A Task State’s “ResultPath” field cannot be applied to the input the state received.\n   */\n  public static readonly RESULT_PATH_MATCH_FAILURE =\n    \"States.ResultPathMatchFailure\";\n\n  /**\n   * Within a state’s “Parameters” field, the attempt to replace a field whose\n   * name ends in “.$” using a Path failed.\n   */\n  public static readonly PARAMETER_PATH_FAILURE = \"States.ParameterPathFailure\";\n\n  /**\n   * A branch of a Parallel state failed.\n   */\n  public static readonly BRANCH_FAILED = \"States.BranchFailed\";\n\n  /**\n   * A Choice state failed to find a match for the condition field extracted\n   * from its input.\n   */\n  public static readonly NO_CHOICE_MATCHED = \"States.NoChoiceMatched\";\n}\n\n/**\n * Retry details\n */\nexport interface RetryProps {\n  /**\n   * Errors to retry\n   *\n   * A list of error strings to retry, which can be either predefined errors\n   * (for example Errors.NoChoiceMatched) or a self-defined error.\n   *\n   * @default All errors\n   */\n  readonly errors?: string[];\n\n  /**\n   * How many seconds to wait initially before retrying\n   *\n   * @default Duration.seconds(1)\n   */\n  readonly interval?: Duration;\n\n  /**\n   * How many times to retry this particular error.\n   *\n   * May be 0 to disable retry for specific errors (in case you have\n   * a catch-all retry policy).\n   *\n   * @default 3\n   */\n  readonly maxAttempts?: number;\n\n  /**\n   * Maximum limit on retry interval growth during exponential backoff.\n   *\n   * @default - No max delay\n   */\n  readonly maxDelay?: Duration;\n\n  /**\n   * Introduces a randomization over the retry interval.\n   *\n   * @default - No jitter strategy\n   */\n  readonly jitterStrategy?: JitterType;\n\n  /**\n   * Multiplication for how much longer the wait interval gets on every retry\n   *\n   * @default 2\n   */\n  readonly backoffRate?: number;\n}\n\n/**\n * Error handler details\n */\nexport interface CatchProps {\n  /**\n   * Errors to recover from by going to the given state\n   *\n   * A list of error strings to retry, which can be either predefined errors\n   * (for example Errors.NoChoiceMatched) or a self-defined error.\n   *\n   * @default All errors\n   */\n  readonly errors?: string[];\n\n  /**\n   * JSONPath expression to indicate where to inject the error data\n   *\n   * May also be the special value JsonPath.DISCARD, which will cause the error\n   * data to be discarded.\n   *\n   * @default $\n   */\n  readonly resultPath?: string;\n}\n\n/**\n * Mode of the Map workflow.\n */\nexport enum ProcessorMode {\n  /**\n   * Inline Map mode.\n   */\n  INLINE = \"INLINE\",\n\n  /**\n   * Distributed Map mode.\n   */\n  DISTRIBUTED = \"DISTRIBUTED\",\n}\n\n/**\n * Execution type for the Map workflow.\n */\nexport enum ProcessorType {\n  /**\n   * Standard execution type.\n   */\n  STANDARD = \"STANDARD\",\n\n  /**\n   * Express execution type.\n   */\n  EXPRESS = \"EXPRESS\",\n}\n\n/**\n * Specifies the configuration for the processor Map state.\n */\nexport interface ProcessorConfig {\n  /**\n   * Specifies the execution mode for the Map workflow.\n   *\n   * @default - ProcessorMode.INLINE if using the `Map` class, ProcessorMode.DISTRIBUTED if using the `DistributedMap` class\n   */\n  readonly mode?: ProcessorMode;\n\n  /**\n   * Specifies the execution type for the Map workflow.\n   *\n   * If you use the `Map` class, you must provide this field if you specified `DISTRIBUTED` for the `mode` sub-field.\n   *\n   * If you use the `DistributedMap` class, this property is ignored.\n   * Use the `mapExecutionType` in the `DistributedMap` class instead.\n   *\n   * @default - no execution type\n   */\n  readonly executionType?: ProcessorType;\n}\n\n/**\n * Special string value to discard state input, output or result\n * @deprecated use JsonPath.DISCARD\n */\nexport const DISCARD = \"DISCARD\";\n"]}

package/lib/aws/compute/util.d.ts

@@ -0,0 +1,12 @@
+import { Construct } from "constructs";
+import { Alias, AliasOptions } from "./function-alias";
+import { IFunction } from "./function-base";
+export declare function addAlias(scope: Construct, lambda: IFunction, version: string, aliasName: string, options?: AliasOptions): Alias;
+/**
+ * Map a function over an array and concatenate the results
+ */
+export declare function flatMap<T, U>(xs: T[], fn: (x: T, i: number) => U[]): U[];
+/**
+ * Flatten a list of lists into a list of elements
+ */
+export declare function flatten<T>(xs: T[][]): T[];

package/lib/aws/compute/util.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatten = exports.flatMap = exports.addAlias = void 0;
+const function_alias_1 = require("./function-alias");
+// import { IVersion } from "./function-version";
+function addAlias(scope, lambda, version, aliasName, options = {}) {
+    return new function_alias_1.Alias(scope, `Alias${aliasName}`, {
+        aliasName,
+        version,
+        function: lambda,
+        ...options,
+    });
+}
+exports.addAlias = addAlias;
+/**
+ * Map a function over an array and concatenate the results
+ */
+function flatMap(xs, fn) {
+    return flatten(xs.map(fn));
+}
+exports.flatMap = flatMap;
+/**
+ * Flatten a list of lists into a list of elements
+ */
+function flatten(xs) {
+    return Array.prototype.concat.apply([], xs);
+}
+exports.flatten = flatten;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hd3MvY29tcHV0ZS91dGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNBLHFEQUF1RDtBQUV2RCxpREFBaUQ7QUFFakQsU0FBZ0IsUUFBUSxDQUN0QixLQUFnQixFQUNoQixNQUFpQixFQUNqQixPQUFlLEVBQ2YsU0FBaUIsRUFDakIsVUFBd0IsRUFBRTtJQUUxQixPQUFPLElBQUksc0JBQUssQ0FBQyxLQUFLLEVBQUUsUUFBUSxTQUFTLEVBQUUsRUFBRTtRQUMzQyxTQUFTO1FBQ1QsT0FBTztRQUNQLFFBQVEsRUFBRSxNQUFNO1FBQ2hCLEdBQUcsT0FBTztLQUNYLENBQUMsQ0FBQztBQUNMLENBQUM7QUFiRCw0QkFhQztBQUVEOztHQUVHO0FBQ0gsU0FBZ0IsT0FBTyxDQUFPLEVBQU8sRUFBRSxFQUE0QjtJQUNqRSxPQUFPLE9BQU8sQ0FBQyxFQUFFLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7QUFDN0IsQ0FBQztBQUZELDBCQUVDO0FBRUQ7O0dBRUc7QUFDSCxTQUFnQixPQUFPLENBQUksRUFBUztJQUNsQyxPQUFPLEtBQUssQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUM7QUFDOUMsQ0FBQztBQUZELDBCQUVDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29uc3RydWN0IH0gZnJvbSBcImNvbnN0cnVjdHNcIjtcbmltcG9ydCB7IEFsaWFzLCBBbGlhc09wdGlvbnMgfSBmcm9tIFwiLi9mdW5jdGlvbi1hbGlhc1wiO1xuaW1wb3J0IHsgSUZ1bmN0aW9uIH0gZnJvbSBcIi4vZnVuY3Rpb24tYmFzZVwiO1xuLy8gaW1wb3J0IHsgSVZlcnNpb24gfSBmcm9tIFwiLi9mdW5jdGlvbi12ZXJzaW9uXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiBhZGRBbGlhcyhcbiAgc2NvcGU6IENvbnN0cnVjdCxcbiAgbGFtYmRhOiBJRnVuY3Rpb24sXG4gIHZlcnNpb246IHN0cmluZyxcbiAgYWxpYXNOYW1lOiBzdHJpbmcsXG4gIG9wdGlvbnM6IEFsaWFzT3B0aW9ucyA9IHt9LFxuKSB7XG4gIHJldHVybiBuZXcgQWxpYXMoc2NvcGUsIGBBbGlhcyR7YWxpYXNOYW1lfWAsIHtcbiAgICBhbGlhc05hbWUsXG4gICAgdmVyc2lvbixcbiAgICBmdW5jdGlvbjogbGFtYmRhLFxuICAgIC4uLm9wdGlvbnMsXG4gIH0pO1xufVxuXG4vKipcbiAqIE1hcCBhIGZ1bmN0aW9uIG92ZXIgYW4gYXJyYXkgYW5kIGNvbmNhdGVuYXRlIHRoZSByZXN1bHRzXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBmbGF0TWFwPFQsIFU+KHhzOiBUW10sIGZuOiAoeDogVCwgaTogbnVtYmVyKSA9PiBVW10pOiBVW10ge1xuICByZXR1cm4gZmxhdHRlbih4cy5tYXAoZm4pKTtcbn1cblxuLyoqXG4gKiBGbGF0dGVuIGEgbGlzdCBvZiBsaXN0cyBpbnRvIGEgbGlzdCBvZiBlbGVtZW50c1xuICovXG5leHBvcnQgZnVuY3Rpb24gZmxhdHRlbjxUPih4czogVFtdW10pOiBUW10ge1xuICByZXR1cm4gQXJyYXkucHJvdG90eXBlLmNvbmNhdC5hcHBseShbXSwgeHMpO1xufVxuIl19

package/lib/aws/edge/certificate.d.ts

@@ -0,0 +1,144 @@
+import { acmCertificate } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { IDnsZone } from ".";
+import { AwsConstructBase, IAwsConstruct, AwsConstructProps } from "../aws-construct";
+export interface CertificateOutputs {
+    /**
+     * Status of the certificate.
+     */
+    readonly status: string;
+    /**
+     * The ARN of the certificate.
+     */
+    readonly arn: string;
+    /**
+     * Set of domain validation objects which can be used to complete certificate validation.
+     * Can have more than one element, e.g., if SANs are defined.
+     *
+     * Only set if DNS-validation was used.
+     */
+    readonly domainValidationOptions?: acmCertificate.AcmCertificateDomainValidationOptionsList;
+}
+export interface ICertificate extends IAwsConstruct {
+    /** Strongly typed outputs */
+    readonly certificateOutputs: CertificateOutputs;
+    /**
+     * Domain name of the certificate.
+     */
+    readonly domainName: string;
+    /**
+     * The ARN of the certificate.
+     */
+    readonly certificateArn: string;
+}
+export interface PublicCertificateProps extends AwsConstructProps {
+    /**
+     * Domain name of the certificate.
+     *
+     * Changing this property will force a new resource.
+     */
+    readonly domainName: string;
+    /**
+     * SANs for the domain.
+     *
+     * Changing this property will force a new resource.
+     */
+    readonly subjectAlternativeNames?: string[];
+    /**
+     * Specifies the algorithm of the public and private key pair that your Amazon issued
+     * certificate uses to encrypt data.
+     * See [ACM Certificate characteristics][acm-certificate-algorithms] for more details.
+     *
+     * @default RSA_2048
+     *
+     * [acm-certificate-algorithms]: https://docs.aws.amazon.com/acm/latest/userguide/acm-certificate-characteristics.html#algorithms
+     */
+    readonly keyAlgorithm?: string;
+    /**
+     * Validation configuration for the certificate.
+     */
+    readonly validation?: CertificateValidationOption;
+}
+export interface CertificateValidationOption {
+    /**
+     * How to validate this certificate
+     *
+     * To validate ownership by adding appropriate DNS records
+     *
+     * @default ValidationMethod.EMAIL
+     *
+     * @see https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-validate-dns.html
+     */
+    readonly method: ValidationMethod;
+    /**
+     * Hosted zone to use for DNS validation
+     *
+     * @default - use email validation
+     */
+    readonly hostedZone?: IDnsZone;
+    /**
+     * A map of hosted zones to use for DNS validation
+     *
+     * @default - use `hostedZone`
+     */
+    readonly hostedZones?: {
+        [domainName: string]: IDnsZone;
+    };
+    /**
+     * Validation domains to use for email validation
+     *
+     * @default - Apex domain
+     */
+    readonly validationDomains?: {
+        [domainName: string]: string;
+    };
+}
+/**
+ * Amazon issued certificate
+ */
+export declare class PublicCertificate extends AwsConstructBase implements ICertificate {
+    resource: acmCertificate.AcmCertificate;
+    private readonly _outputs;
+    get certificateOutputs(): CertificateOutputs;
+    get outputs(): Record<string, any>;
+    private readonly _domainName;
+    get domainName(): string;
+    private readonly _certificateArn;
+    get certificateArn(): string;
+    constructor(scope: Construct, id: string, props: PublicCertificateProps);
+}
+/**
+ * Method used to assert ownership of the domain
+ */
+export declare enum ValidationMethod {
+    /**
+     * Send email to a number of email addresses associated with the domain
+     *
+     * IMPORTANT: if you are creating a certificate as part of your stack, the stack
+     * will not complete creating until you read and follow the instructions in the
+     * email that you will receive.
+     *
+     * ACM will send validation emails to the following addresses:
+     *
+     *  admin@domain.com
+     *  administrator@domain.com
+     *  hostmaster@domain.com
+     *  postmaster@domain.com
+     *  webmaster@domain.com
+     *
+     * For every domain that you register.
+     *
+     * @see https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-validate-email.html
+     */
+    EMAIL = "EMAIL",
+    /**
+     * Validate ownership by adding appropriate DNS records
+     *
+     * IMPORTANT: If `hostedZone` is not specified, DNS records must be added
+     * manually and the stack will not complete creating until the records are
+     * added.
+     *
+     * @see https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-validate-dns.html
+     */
+    DNS = "DNS"
+}