terraconstructs 0.0.8

package/lib/aws/aws-stack.js

@@ -0,0 +1,303 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsStack = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const change_case_1 = require("change-case");
+const arn_1 = require("./arn");
+const terraform_dependables_aspect_1 = require("../private/terraform-dependables-aspect");
+const stack_base_1 = require("../stack-base");
+const AWS_STACK_SYMBOL = Symbol.for("terraconstructs/lib/aws.AwsStack");
+/**
+ * A Terraform stack constrained to a single AWS Account/Region to simulate CFN behavior.
+ */
+class AwsStack extends stack_base_1.StackBase {
+    // ref: https://github.com/aws/aws-cdk/blob/v2.150.0/packages/aws-cdk-lib/core/lib/stack.ts#L204
+    /**
+     * Return whether the given object is a Stack.
+     *
+     * attribute detection since as 'instanceof' potentially fails across Library releases.
+     */
+    static isAwsStack(x) {
+        return x !== null && typeof x === "object" && AWS_STACK_SYMBOL in x;
+    }
+    // ref: https://github.com/aws/aws-cdk/blob/v2.150.0/packages/aws-cdk-lib/core/lib/stack.ts#L212
+    /**
+     * Looks up the first stack scope in which `construct` is defined. Fails if there is no stack up the tree or the stack is not an AwsStack.
+     * @param construct The construct to start the search from.
+     */
+    static ofAwsConstruct(construct) {
+        const s = cdktf_1.TerraformStack.of(construct);
+        if (AwsStack.isAwsStack(s)) {
+            return s;
+        }
+        throw new Error(`Resource '${construct.constructor?.name}' at '${construct.node.path}' should be created in the scope of an AwsStack, but no AwsStack found`);
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.regionalAwsProviders = {};
+        this.lookup = {
+            awsProvider: new provider_aws_1.provider.AwsProvider(this, "defaultAwsProvider", props.providerConfig),
+            dataAwsServicePrincipals: {},
+        };
+        // these should never depend on anything (HACK to avoid cycles)
+        Object.defineProperty(this, AWS_STACK_SYMBOL, { value: true });
+    }
+    get provider() {
+        return this.lookup.awsProvider;
+    }
+    /**
+     * Get the Region of the AWS Stack
+     */
+    get region() {
+        if (this.lookup.awsProvider.region) {
+            return this.lookup.awsProvider.region;
+        }
+        if (!this.lookup.dataAwsRegion) {
+            const region = new provider_aws_1.dataAwsRegion.DataAwsRegion(this, "Region", {
+                provider: this.lookup.awsProvider,
+            });
+            // these should never depend on anything (HACK to avoid cycles)
+            Object.defineProperty(region, terraform_dependables_aspect_1.SKIP_DEPENDENCY_PROPAGATION, {
+                value: true,
+            });
+            this.lookup.dataAwsRegion = region;
+        }
+        return this.lookup.dataAwsRegion.name;
+    }
+    get dataAwsCallerIdentity() {
+        if (!this.lookup.dataAwsCallerIdentity) {
+            const identity = new provider_aws_1.dataAwsCallerIdentity.DataAwsCallerIdentity(this, "CallerIdentity", {
+                provider: this.lookup.awsProvider,
+            });
+            // these should never depend on anything (HACK to avoid cycles)
+            Object.defineProperty(identity, terraform_dependables_aspect_1.SKIP_DEPENDENCY_PROPAGATION, {
+                value: true,
+            });
+            this.lookup.dataAwsCallerIdentity = identity;
+        }
+        return this.lookup.dataAwsCallerIdentity;
+    }
+    get dataAwsAvailabilityZones() {
+        if (!this.lookup.dataAwsAvailabilityZones) {
+            const azs = new provider_aws_1.dataAwsAvailabilityZones.DataAwsAvailabilityZones(this, "AvailabilityZones", {
+                provider: this.lookup.awsProvider,
+            });
+            // these should never depend on anything (HACK to avoid cycles)
+            Object.defineProperty(azs, terraform_dependables_aspect_1.SKIP_DEPENDENCY_PROPAGATION, { value: true });
+            this.lookup.dataAwsAvailabilityZones = azs;
+        }
+        return this.lookup.dataAwsAvailabilityZones;
+    }
+    get dataAwsPartition() {
+        if (!this.lookup.dataAwsPartition) {
+            const partition = new provider_aws_1.dataAwsPartition.DataAwsPartition(this, "Partitition", {
+                provider: this.lookup.awsProvider,
+            });
+            // these should never depend on anything (HACK to avoid cycles)
+            Object.defineProperty(partition, terraform_dependables_aspect_1.SKIP_DEPENDENCY_PROPAGATION, {
+                value: true,
+            });
+            this.lookup.dataAwsPartition = partition;
+        }
+        return this.lookup.dataAwsPartition;
+    }
+    getRegionalAwsProvider(region) {
+        if (!this.regionalAwsProviders[region]) {
+            this.regionalAwsProviders[region] = new provider_aws_1.provider.AwsProvider(this, `aws_${toTerraformIdentifier(region)}`, {
+                region,
+                alias: toTerraformIdentifier(region),
+            });
+        }
+        return this.regionalAwsProviders[region];
+    }
+    /**
+     * Get the Account of the AWS Stack
+     */
+    get account() {
+        if (!this._accountIdToken) {
+            this._accountIdToken = this.dataAwsCallerIdentity.accountId;
+        }
+        return this._accountIdToken;
+    }
+    /**
+     * Get the Partition of the AWS Stack
+     */
+    get partition() {
+        if (!this._paritionToken) {
+            this._paritionToken = this.dataAwsPartition.partition;
+        }
+        return this._paritionToken;
+    }
+    /**
+     * Base DNS domain name for the current partition (e.g., amazonaws.com in AWS Commercial, amazonaws.com.cn in AWS China).
+     */
+    get urlSuffix() {
+        if (!this._urlSuffixToken) {
+            this._urlSuffixToken = this.dataAwsPartition.dnsSuffix;
+        }
+        return this._urlSuffixToken;
+    }
+    /**
+     * Return the service principal name based on the region it's used in.
+     *
+     * Some service principal names used to be different for different partitions,
+     * and some were not.
+     *
+     * These days all service principal names are standardized, and they are all
+     * of the form `<servicename>.amazonaws.com`.
+     *
+     * To avoid breaking changes, handling is provided for services added with the formats below,
+     * however, no additional handling will be added for new regions or partitions.
+     *   - s3
+     *   - s3.amazonaws.com
+     *   - s3.amazonaws.com.cn
+     *   - s3.c2s.ic.gov
+     *   - s3.sc2s.sgov.gov
+     *
+     * @param service The service name to get the service principal ID for
+     * @param region The region to get the service principal ID for
+     */
+    servicePrincipalName(service, region) {
+        const DEFAULT_REGION_KEY = "default_region";
+        if (!region) {
+            region = DEFAULT_REGION_KEY;
+        }
+        if (cdktf_1.Token.isUnresolved(region)) {
+            throw new Error("Cannot determine the service principal ID because the region is a token. " +
+                "You must specify the region explicitly.");
+        }
+        // if full service name is provided, extract just the service name
+        // for supported cases (as required by Terraform aws_service_principal Data Source)
+        const match = service.match(/^([^.]+)(?:(?:\.amazonaws\.com(?:\.cn)?)|(?:\.c2s\.ic\.gov)|(?:\.sc2s\.sgov\.gov))?$/);
+        const serviceName = match ? match[1] : service;
+        if (!this.lookup.dataAwsServicePrincipals[region]) {
+            this.lookup.dataAwsServicePrincipals[region] = {};
+        }
+        if (!this.lookup.dataAwsServicePrincipals[region][serviceName]) {
+            const svcp = new provider_aws_1.dataAwsServicePrincipal.DataAwsServicePrincipal(this, `aws_svcp_${toTerraformIdentifier(region)}_${serviceName}}`, {
+                serviceName,
+                provider: region === DEFAULT_REGION_KEY
+                    ? undefined
+                    : this.getRegionalAwsProvider(region),
+            });
+            // these should never depend on anything (HACK to avoid cycles)
+            Object.defineProperty(svcp, terraform_dependables_aspect_1.SKIP_DEPENDENCY_PROPAGATION, { value: true });
+            this.lookup.dataAwsServicePrincipals[region][serviceName] = svcp;
+        }
+        return this.lookup.dataAwsServicePrincipals[region][serviceName].name;
+    }
+    /**
+     * Creates an ARN from components.
+     *
+     * If `partition`, `region` or `account` are not specified, the stack's
+     * partition, region and account will be used.
+     *
+     * If any component is the empty string, an empty string will be inserted
+     * into the generated ARN at the location that component corresponds to.
+     *
+     * The ARN will be formatted as follows:
+     *
+     *   arn:{partition}:{service}:{region}:{account}:{resource}{sep}{resource-name}
+     *
+     * The required ARN pieces that are omitted will be taken from the stack that
+     * the 'scope' is attached to. If all ARN pieces are supplied, the supplied scope
+     * can be 'undefined'.
+     */
+    formatArn(components) {
+        return arn_1.Arn.format(components, this);
+    }
+    /**
+     * Given an ARN, parses it and returns components.
+     *
+     * IF THE ARN IS A CONCRETE STRING...
+     *
+     * ...it will be parsed and validated. The separator (`sep`) will be set to '/'
+     * if the 6th component includes a '/', in which case, `resource` will be set
+     * to the value before the '/' and `resourceName` will be the rest. In case
+     * there is no '/', `resource` will be set to the 6th components and
+     * `resourceName` will be set to the rest of the string.
+     *
+     * IF THE ARN IS A TOKEN...
+     *
+     * ...it cannot be validated, since we don't have the actual value yet at the
+     * time of this function call. You will have to supply `sepIfToken` and
+     * whether or not ARNs of the expected format usually have resource names
+     * in order to parse it properly. The resulting `ArnComponents` object will
+     * contain tokens for the subexpressions of the ARN, not string literals.
+     *
+     * If the resource name could possibly contain the separator char, the actual
+     * resource name cannot be properly parsed. This only occurs if the separator
+     * char is '/', and happens for example for S3 object ARNs, IAM Role ARNs,
+     * IAM OIDC Provider ARNs, etc. To properly extract the resource name from a
+     * Tokenized ARN, you must know the resource type and call
+     * `Arn.extractResourceName`.
+     *
+     * @param arn The ARN string to parse
+     * @param sepIfToken The separator used to separate resource from resourceName
+     * @param hasName Whether there is a name component in the ARN at all. For
+     * example, SNS Topics ARNs have the 'resource' component contain the topic
+     * name, and no 'resourceName' component.
+     *
+     * @returns an ArnComponents object which allows access to the various
+     * components of the ARN.
+     *
+     * @returns an ArnComponents object which allows access to the various
+     *      components of the ARN.
+     *
+     * @deprecated use splitArn instead
+     */
+    parseArn(arn, sepIfToken = "/", hasName = true) {
+        return arn_1.Arn.parse(arn, sepIfToken, hasName);
+    }
+    /**
+     * Splits the provided ARN into its components.
+     * Works both if 'arn' is a string like 'arn:aws:s3:::bucket',
+     * and a Token representing a dynamic CloudFormation expression
+     * (in which case the returned components will also be dynamic CloudFormation expressions,
+     * encoded as Tokens).
+     *
+     * @param arn the ARN to split into its components
+     * @param arnFormat the expected format of 'arn' - depends on what format the service 'arn' represents uses
+     */
+    splitArn(arn, arnFormat) {
+        return arn_1.Arn.split(arn, arnFormat);
+    }
+    /**
+     * Returns iterator for all AZs that are available in the AWS environment
+     * (account/region) associated with this stack (default or aliased provider).
+     *
+     * this will return a cdktf iterator
+     *
+     * https://developer.hashicorp.com/terraform/cdktf/concepts/iterators#define-iterators
+     *
+     * To specify a different strategy for selecting availability zones override this method.
+     */
+    get availabilityZoneIterator() {
+        const azs = this.dataAwsAvailabilityZones;
+        return cdktf_1.TerraformIterator.fromDataSources(azs);
+    }
+    /**
+     * Returns a Token as List of AZ names that are available in the stack's
+     * AWS environment (account/region).
+     *
+     * The list is slized by `maxCount` which defaults to 2.
+     *
+     * Note: Must use `Fn.element` to access the AZ names.
+     *
+     * @param maxCount the maximum number of AZs to return
+     */
+    availabilityZones(maxCount = 2) {
+        const azs = this.dataAwsAvailabilityZones;
+        return cdktf_1.Token.asList(cdktf_1.Fn.slice(azs.names, 0, maxCount));
+    }
+}
+exports.AwsStack = AwsStack;
+_a = JSII_RTTI_SYMBOL_1;
+AwsStack[_a] = { fqn: "terraconstructs.aws.AwsStack", version: "0.0.8" };
+function toTerraformIdentifier(identifier) {
+    return (0, change_case_1.snakeCase)(identifier).replace(/-/g, "_");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-stack.js","sourceRoot":"","sources":["../../src/aws/aws-stack.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  dataAwsAvailabilityZones,\n  dataAwsCallerIdentity,\n  dataAwsPartition,\n  dataAwsRegion,\n  dataAwsServicePrincipal,\n  provider,\n} from \"@cdktf/provider-aws\";\nimport {\n  TerraformStack,\n  TerraformIterator,\n  Token,\n  Fn,\n  ResourceTerraformIterator,\n} from \"cdktf\";\nimport { snakeCase } from \"change-case\";\nimport { Construct, IConstruct } from \"constructs\";\nimport { Arn, ArnComponents, ArnFormat } from \"./arn\";\nimport { AwsProviderConfig } from \"./provider-config.generated\";\nimport { SKIP_DEPENDENCY_PROPAGATION } from \"../private/terraform-dependables-aspect\";\nimport { StackBaseProps, StackBase, IStack } from \"../stack-base\";\n\nconst AWS_STACK_SYMBOL = Symbol.for(\"terraconstructs/lib/aws.AwsStack\");\n\nexport interface AwsStackProps extends StackBaseProps {\n  /**\n   * The AWS Provider configuration (without the alias field)\n   */\n  readonly providerConfig: AwsProviderConfig;\n}\n\nexport interface IAwsStack extends IStack {\n  /**\n   * The AWS Region for the TerraConstruct\n   */\n  readonly region: string;\n  /**\n   * The AWS Account for the TerraConstruct\n   */\n  readonly account: string;\n  /**\n   * The AWS Partition for the TerraConstruct\n   */\n  readonly partition: string;\n\n  /**\n   * The service Principal Id for a specific service\n   *\n   * @param serviceName The service name to get the service principal ID for\n   * @param region The region to get the service principal ID for\n   */\n  servicePrincipalName(serviceName: string, region?: string): string;\n  // /**\n  //  * Produce the Token's value at resolution time\n  //  */\n  // resolve<T>(obj: T): T;\n}\n\ninterface AwsLookup {\n  awsProvider: provider.AwsProvider;\n  dataAwsRegion?: dataAwsRegion.DataAwsRegion;\n  dataAwsCallerIdentity?: dataAwsCallerIdentity.DataAwsCallerIdentity;\n  dataAwsPartition?: dataAwsPartition.DataAwsPartition;\n  dataAwsAvailabilityZones?: dataAwsAvailabilityZones.DataAwsAvailabilityZones;\n  // AWS Service Principals by region and by service\n  dataAwsServicePrincipals: Record<\n    string,\n    Record<string, dataAwsServicePrincipal.DataAwsServicePrincipal>\n  >;\n}\n\n/**\n * A Terraform stack constrained to a single AWS Account/Region to simulate CFN behavior.\n */\nexport class AwsStack extends StackBase implements IAwsStack {\n  // ref: https://github.com/aws/aws-cdk/blob/v2.150.0/packages/aws-cdk-lib/core/lib/stack.ts#L204\n\n  /**\n   * Return whether the given object is a Stack.\n   *\n   * attribute detection since as 'instanceof' potentially fails across Library releases.\n   */\n  public static isAwsStack(x: any): x is AwsStack {\n    return x !== null && typeof x === \"object\" && AWS_STACK_SYMBOL in x;\n  }\n\n  // ref: https://github.com/aws/aws-cdk/blob/v2.150.0/packages/aws-cdk-lib/core/lib/stack.ts#L212\n\n  /**\n   * Looks up the first stack scope in which `construct` is defined. Fails if there is no stack up the tree or the stack is not an AwsStack.\n   * @param construct The construct to start the search from.\n   */\n  public static ofAwsConstruct(construct: IConstruct): AwsStack {\n    const s = TerraformStack.of(construct);\n    if (AwsStack.isAwsStack(s)) {\n      return s;\n    }\n    throw new Error(\n      `Resource '${construct.constructor?.name}' at '${construct.node.path}' should be created in the scope of an AwsStack, but no AwsStack found`,\n    );\n  }\n\n  private readonly lookup: AwsLookup;\n  private regionalAwsProviders: { [region: string]: provider.AwsProvider } = {};\n\n  /**\n   * Cache these tokens for reliable comparisons.\n   *\n   * Every call for the same Token will produce a new unique string, no\n   * attempt is made to deduplicate. Token objects should cache the\n   * value themselves, if required.\n   *\n   * dataSource.getSTringattribute -> Token.asString -> tokenMap.registerString\n   * ref:\n   * - https://github.com/hashicorp/terraform-cdk/blob/v0.20.10/packages/cdktf/lib/terraform-data-source.ts#L68\n   * - https://github.com/hashicorp/terraform-cdk/blob/v0.20.10/packages/cdktf/lib/tokens/private/token-map.ts#L50-L66\n   */\n  private _accountIdToken: string | undefined;\n  private _paritionToken: string | undefined;\n  private _urlSuffixToken: string | undefined;\n\n  constructor(scope: Construct, id: string, props: AwsStackProps) {\n    super(scope, id, props);\n    this.lookup = {\n      awsProvider: new provider.AwsProvider(\n        this,\n        \"defaultAwsProvider\",\n        props.providerConfig,\n      ),\n      dataAwsServicePrincipals: {},\n    };\n    // these should never depend on anything (HACK to avoid cycles)\n    Object.defineProperty(this, AWS_STACK_SYMBOL, { value: true });\n  }\n\n  public get provider(): provider.AwsProvider {\n    return this.lookup.awsProvider;\n  }\n\n  /**\n   * Get the Region of the AWS Stack\n   */\n  public get region(): string {\n    if (this.lookup.awsProvider.region) {\n      return this.lookup.awsProvider.region;\n    }\n    if (!this.lookup.dataAwsRegion) {\n      const region = new dataAwsRegion.DataAwsRegion(this, \"Region\", {\n        provider: this.lookup.awsProvider,\n      });\n      // these should never depend on anything (HACK to avoid cycles)\n      Object.defineProperty(region, SKIP_DEPENDENCY_PROPAGATION, {\n        value: true,\n      });\n      this.lookup.dataAwsRegion = region;\n    }\n    return this.lookup.dataAwsRegion.name;\n  }\n\n  private get dataAwsCallerIdentity(): dataAwsCallerIdentity.DataAwsCallerIdentity {\n    if (!this.lookup.dataAwsCallerIdentity) {\n      const identity = new dataAwsCallerIdentity.DataAwsCallerIdentity(\n        this,\n        \"CallerIdentity\",\n        {\n          provider: this.lookup.awsProvider,\n        },\n      );\n      // these should never depend on anything (HACK to avoid cycles)\n      Object.defineProperty(identity, SKIP_DEPENDENCY_PROPAGATION, {\n        value: true,\n      });\n      this.lookup.dataAwsCallerIdentity = identity;\n    }\n    return this.lookup.dataAwsCallerIdentity;\n  }\n\n  private get dataAwsAvailabilityZones(): dataAwsAvailabilityZones.DataAwsAvailabilityZones {\n    if (!this.lookup.dataAwsAvailabilityZones) {\n      const azs = new dataAwsAvailabilityZones.DataAwsAvailabilityZones(\n        this,\n        \"AvailabilityZones\",\n        {\n          provider: this.lookup.awsProvider,\n        },\n      );\n      // these should never depend on anything (HACK to avoid cycles)\n      Object.defineProperty(azs, SKIP_DEPENDENCY_PROPAGATION, { value: true });\n      this.lookup.dataAwsAvailabilityZones = azs;\n    }\n    return this.lookup.dataAwsAvailabilityZones;\n  }\n\n  private get dataAwsPartition(): dataAwsPartition.DataAwsPartition {\n    if (!this.lookup.dataAwsPartition) {\n      const partition = new dataAwsPartition.DataAwsPartition(\n        this,\n        \"Partitition\",\n        {\n          provider: this.lookup.awsProvider,\n        },\n      );\n      // these should never depend on anything (HACK to avoid cycles)\n      Object.defineProperty(partition, SKIP_DEPENDENCY_PROPAGATION, {\n        value: true,\n      });\n      this.lookup.dataAwsPartition = partition;\n    }\n    return this.lookup.dataAwsPartition;\n  }\n\n  private getRegionalAwsProvider(region: string): provider.AwsProvider {\n    if (!this.regionalAwsProviders[region]) {\n      this.regionalAwsProviders[region] = new provider.AwsProvider(\n        this,\n        `aws_${toTerraformIdentifier(region)}`,\n        {\n          region,\n          alias: toTerraformIdentifier(region),\n        },\n      );\n    }\n    return this.regionalAwsProviders[region];\n  }\n\n  /**\n   * Get the Account of the AWS Stack\n   */\n  public get account(): string {\n    if (!this._accountIdToken) {\n      this._accountIdToken = this.dataAwsCallerIdentity.accountId;\n    }\n    return this._accountIdToken;\n  }\n\n  /**\n   * Get the Partition of the AWS Stack\n   */\n  public get partition() {\n    if (!this._paritionToken) {\n      this._paritionToken = this.dataAwsPartition.partition;\n    }\n    return this._paritionToken;\n  }\n\n  /**\n   * Base DNS domain name for the current partition (e.g., amazonaws.com in AWS Commercial, amazonaws.com.cn in AWS China).\n   */\n  public get urlSuffix() {\n    if (!this._urlSuffixToken) {\n      this._urlSuffixToken = this.dataAwsPartition.dnsSuffix;\n    }\n    return this._urlSuffixToken;\n  }\n\n  /**\n   * Return the service principal name based on the region it's used in.\n   *\n   * Some service principal names used to be different for different partitions,\n   * and some were not.\n   *\n   * These days all service principal names are standardized, and they are all\n   * of the form `<servicename>.amazonaws.com`.\n   *\n   * To avoid breaking changes, handling is provided for services added with the formats below,\n   * however, no additional handling will be added for new regions or partitions.\n   *   - s3\n   *   - s3.amazonaws.com\n   *   - s3.amazonaws.com.cn\n   *   - s3.c2s.ic.gov\n   *   - s3.sc2s.sgov.gov\n   *\n   * @param service The service name to get the service principal ID for\n   * @param region The region to get the service principal ID for\n   */\n  public servicePrincipalName(service: string, region?: string): string {\n    const DEFAULT_REGION_KEY = \"default_region\";\n    if (!region) {\n      region = DEFAULT_REGION_KEY;\n    }\n\n    if (Token.isUnresolved(region)) {\n      throw new Error(\n        \"Cannot determine the service principal ID because the region is a token. \" +\n          \"You must specify the region explicitly.\",\n      );\n    }\n\n    // if full service name is provided, extract just the service name\n    // for supported cases (as required by Terraform aws_service_principal Data Source)\n    const match = service.match(\n      /^([^.]+)(?:(?:\\.amazonaws\\.com(?:\\.cn)?)|(?:\\.c2s\\.ic\\.gov)|(?:\\.sc2s\\.sgov\\.gov))?$/,\n    );\n    const serviceName = match ? match[1] : service;\n    if (!this.lookup.dataAwsServicePrincipals[region]) {\n      this.lookup.dataAwsServicePrincipals[region] = {};\n    }\n    if (!this.lookup.dataAwsServicePrincipals[region][serviceName]) {\n      const svcp = new dataAwsServicePrincipal.DataAwsServicePrincipal(\n        this,\n        `aws_svcp_${toTerraformIdentifier(region)}_${serviceName}}`,\n        {\n          serviceName,\n          provider:\n            region === DEFAULT_REGION_KEY\n              ? undefined\n              : this.getRegionalAwsProvider(region),\n        },\n      );\n      // these should never depend on anything (HACK to avoid cycles)\n      Object.defineProperty(svcp, SKIP_DEPENDENCY_PROPAGATION, { value: true });\n      this.lookup.dataAwsServicePrincipals[region][serviceName] = svcp;\n    }\n    return this.lookup.dataAwsServicePrincipals[region][serviceName].name;\n  }\n\n  /**\n   * Creates an ARN from components.\n   *\n   * If `partition`, `region` or `account` are not specified, the stack's\n   * partition, region and account will be used.\n   *\n   * If any component is the empty string, an empty string will be inserted\n   * into the generated ARN at the location that component corresponds to.\n   *\n   * The ARN will be formatted as follows:\n   *\n   *   arn:{partition}:{service}:{region}:{account}:{resource}{sep}{resource-name}\n   *\n   * The required ARN pieces that are omitted will be taken from the stack that\n   * the 'scope' is attached to. If all ARN pieces are supplied, the supplied scope\n   * can be 'undefined'.\n   */\n  public formatArn(components: ArnComponents): string {\n    return Arn.format(components, this);\n  }\n\n  /**\n   * Given an ARN, parses it and returns components.\n   *\n   * IF THE ARN IS A CONCRETE STRING...\n   *\n   * ...it will be parsed and validated. The separator (`sep`) will be set to '/'\n   * if the 6th component includes a '/', in which case, `resource` will be set\n   * to the value before the '/' and `resourceName` will be the rest. In case\n   * there is no '/', `resource` will be set to the 6th components and\n   * `resourceName` will be set to the rest of the string.\n   *\n   * IF THE ARN IS A TOKEN...\n   *\n   * ...it cannot be validated, since we don't have the actual value yet at the\n   * time of this function call. You will have to supply `sepIfToken` and\n   * whether or not ARNs of the expected format usually have resource names\n   * in order to parse it properly. The resulting `ArnComponents` object will\n   * contain tokens for the subexpressions of the ARN, not string literals.\n   *\n   * If the resource name could possibly contain the separator char, the actual\n   * resource name cannot be properly parsed. This only occurs if the separator\n   * char is '/', and happens for example for S3 object ARNs, IAM Role ARNs,\n   * IAM OIDC Provider ARNs, etc. To properly extract the resource name from a\n   * Tokenized ARN, you must know the resource type and call\n   * `Arn.extractResourceName`.\n   *\n   * @param arn The ARN string to parse\n   * @param sepIfToken The separator used to separate resource from resourceName\n   * @param hasName Whether there is a name component in the ARN at all. For\n   * example, SNS Topics ARNs have the 'resource' component contain the topic\n   * name, and no 'resourceName' component.\n   *\n   * @returns an ArnComponents object which allows access to the various\n   * components of the ARN.\n   *\n   * @returns an ArnComponents object which allows access to the various\n   *      components of the ARN.\n   *\n   * @deprecated use splitArn instead\n   */\n  public parseArn(\n    arn: string,\n    sepIfToken: string = \"/\",\n    hasName: boolean = true,\n  ): ArnComponents {\n    return Arn.parse(arn, sepIfToken, hasName);\n  }\n\n  /**\n   * Splits the provided ARN into its components.\n   * Works both if 'arn' is a string like 'arn:aws:s3:::bucket',\n   * and a Token representing a dynamic CloudFormation expression\n   * (in which case the returned components will also be dynamic CloudFormation expressions,\n   * encoded as Tokens).\n   *\n   * @param arn the ARN to split into its components\n   * @param arnFormat the expected format of 'arn' - depends on what format the service 'arn' represents uses\n   */\n  public splitArn(arn: string, arnFormat: ArnFormat): ArnComponents {\n    return Arn.split(arn, arnFormat);\n  }\n\n  /**\n   * Returns iterator for all AZs that are available in the AWS environment\n   * (account/region) associated with this stack (default or aliased provider).\n   *\n   * this will return a cdktf iterator\n   *\n   * https://developer.hashicorp.com/terraform/cdktf/concepts/iterators#define-iterators\n   *\n   * To specify a different strategy for selecting availability zones override this method.\n   */\n  public get availabilityZoneIterator(): ResourceTerraformIterator {\n    const azs = this.dataAwsAvailabilityZones;\n    return TerraformIterator.fromDataSources(azs);\n  }\n\n  /**\n   * Returns a Token as List of AZ names that are available in the stack's\n   * AWS environment (account/region).\n   *\n   * The list is slized by `maxCount` which defaults to 2.\n   *\n   * Note: Must use `Fn.element` to access the AZ names.\n   *\n   * @param maxCount the maximum number of AZs to return\n   */\n  public availabilityZones(maxCount: number = 2): string[] {\n    const azs = this.dataAwsAvailabilityZones;\n    return Token.asList(Fn.slice(azs.names, 0, maxCount));\n  }\n\n  // /**\n  //  * Resolve a tokenized value in the context of the current stack.\n  //  */\n  // public resolve<T>(obj: T): T {\n  //   // ref: https://github.com/hashicorp/terraform-cdk/blob/v0.20.7/packages/cdktf/lib/terraform-stack.ts#L151\n  //   // ref: https://github.com/aws/aws-cdk/blob/v2.150.0/packages/aws-cdk-lib/core/lib/stack.ts#L572\n  //   return resolve(this, obj);\n  // }\n}\n\nfunction toTerraformIdentifier(identifier: string) {\n  return snakeCase(identifier).replace(/-/g, \"_\");\n}\n"]}

package/lib/aws/cloudwatch/actions/ec2.d.ts

@@ -0,0 +1,35 @@
+import { Construct } from "constructs";
+import { IAlarmAction, AlarmActionConfig } from "../alarm-action";
+import { IAlarm } from "../alarm-base";
+/**
+ * Types of EC2 actions available
+ */
+export declare enum Ec2InstanceAction {
+    /**
+     * Stop the instance
+     */
+    STOP = "stop",
+    /**
+     * Terminatethe instance
+     */
+    TERMINATE = "terminate",
+    /**
+     * Recover the instance
+     */
+    RECOVER = "recover",
+    /**
+     * Reboot the instance
+     */
+    REBOOT = "reboot"
+}
+/**
+ * Use an EC2 action as an Alarm action
+ */
+export declare class Ec2Action implements IAlarmAction {
+    private ec2Action;
+    constructor(instanceAction: Ec2InstanceAction);
+    /**
+     * Returns an alarm action configuration to use an EC2 action as an alarm action
+     */
+    bind(_scope: Construct, _alarm: IAlarm): AlarmActionConfig;
+}

package/lib/aws/cloudwatch/actions/ec2.js

@@ -0,0 +1,48 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ec2Action = exports.Ec2InstanceAction = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_stack_1 = require("../../aws-stack");
+/**
+ * Types of EC2 actions available
+ */
+var Ec2InstanceAction;
+(function (Ec2InstanceAction) {
+    /**
+     * Stop the instance
+     */
+    Ec2InstanceAction["STOP"] = "stop";
+    /**
+     * Terminatethe instance
+     */
+    Ec2InstanceAction["TERMINATE"] = "terminate";
+    /**
+     * Recover the instance
+     */
+    Ec2InstanceAction["RECOVER"] = "recover";
+    /**
+     * Reboot the instance
+     */
+    Ec2InstanceAction["REBOOT"] = "reboot";
+})(Ec2InstanceAction || (exports.Ec2InstanceAction = Ec2InstanceAction = {}));
+/**
+ * Use an EC2 action as an Alarm action
+ */
+class Ec2Action {
+    constructor(instanceAction) {
+        this.ec2Action = instanceAction;
+    }
+    /**
+     * Returns an alarm action configuration to use an EC2 action as an alarm action
+     */
+    bind(_scope, _alarm) {
+        return {
+            alarmActionArn: `arn:${aws_stack_1.AwsStack.ofAwsConstruct(_scope).partition}:automate:${aws_stack_1.AwsStack.ofAwsConstruct(_scope).region}:ec2:${this.ec2Action}`,
+        };
+    }
+}
+exports.Ec2Action = Ec2Action;
+_a = JSII_RTTI_SYMBOL_1;
+Ec2Action[_a] = { fqn: "terraconstructs.aws.cloudwatch.actions.Ec2Action", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/cloudwatch/actions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ec2";
+export * from "./lambda";

package/lib/aws/cloudwatch/actions/index.js

@@ -0,0 +1,24 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch-actions/lib/index.ts
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// export * from './appscaling';
+// export * from './autoscaling';
+// export * from './sns';
+__exportStar(require("./ec2"), exports);
+// export * from './ssm';
+__exportStar(require("./lambda"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXdzL2Nsb3Vkd2F0Y2gvYWN0aW9ucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsd0dBQXdHOzs7Ozs7Ozs7Ozs7Ozs7O0FBRXhHLGdDQUFnQztBQUNoQyxpQ0FBaUM7QUFDakMseUJBQXlCO0FBQ3pCLHdDQUFzQjtBQUN0Qix5QkFBeUI7QUFDekIsMkNBQXlCIiwic291cmNlc0NvbnRlbnQiOlsiLy8gaHR0cHM6Ly9naXRodWIuY29tL2F3cy9hd3MtY2RrL2Jsb2IvdjIuMTcwLjAvcGFja2FnZXMvYXdzLWNkay1saWIvYXdzLWNsb3Vkd2F0Y2gtYWN0aW9ucy9saWIvaW5kZXgudHNcblxuLy8gZXhwb3J0ICogZnJvbSAnLi9hcHBzY2FsaW5nJztcbi8vIGV4cG9ydCAqIGZyb20gJy4vYXV0b3NjYWxpbmcnO1xuLy8gZXhwb3J0ICogZnJvbSAnLi9zbnMnO1xuZXhwb3J0ICogZnJvbSBcIi4vZWMyXCI7XG4vLyBleHBvcnQgKiBmcm9tICcuL3NzbSc7XG5leHBvcnQgKiBmcm9tIFwiLi9sYW1iZGFcIjtcbiJdfQ==

package/lib/aws/cloudwatch/actions/lambda.d.ts

@@ -0,0 +1,16 @@
+import { Construct } from "constructs";
+import * as cloudwatch from "..";
+import * as lambda from "../../compute";
+/**
+ * Use a Lambda action as an Alarm action
+ */
+export declare class LambdaAction implements cloudwatch.IAlarmAction {
+    private lambdaFunction;
+    constructor(lambdaFunction: lambda.IAlias | lambda.IFunction);
+    /**
+     * Returns an alarm action configuration to use a Lambda action as an alarm action.
+     *
+     * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricAlarm.html
+     */
+    bind(scope: Construct, alarm: cloudwatch.IAlarm): cloudwatch.AlarmActionConfig;
+}

package/lib/aws/cloudwatch/actions/lambda.js

@@ -0,0 +1,48 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaAction = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_stack_1 = require("../../aws-stack");
+const iam = require("../../iam");
+/**
+ * Use a Lambda action as an Alarm action
+ */
+class LambdaAction {
+    constructor(lambdaFunction) {
+        this.lambdaFunction = lambdaFunction;
+    }
+    /**
+     * Returns an alarm action configuration to use a Lambda action as an alarm action.
+     *
+     * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricAlarm.html
+     */
+    bind(scope, alarm) {
+        // https://github.com/aws/aws-cdk/pull/28712
+        // const idPrefix = FeatureFlags.of(scope).isEnabled(
+        //   LAMBDA_PERMISSION_LOGICAL_ID_FOR_LAMBDA_ACTION,
+        // )
+        //   ? alarm.node.id
+        //   : "";
+        const permissionId = `${alarm.node.id}AlarmPermission`;
+        const permissionNode = this.lambdaFunction.permissionsNode.tryFindChild(permissionId);
+        // If the Lambda permission has already been added to this function
+        // we skip adding it to avoid an exception being thrown
+        // see https://github.com/aws/aws-cdk/issues/29514
+        if (permissionNode?.sourceArnInput !== alarm.alarmArn) {
+            this.lambdaFunction.addPermission(permissionId, {
+                sourceAccount: aws_stack_1.AwsStack.ofAwsConstruct(scope).account,
+                action: "lambda:InvokeFunction",
+                sourceArn: alarm.alarmArn,
+                principal: new iam.ServicePrincipal("lambda.alarms.cloudwatch.amazonaws.com"),
+            });
+        }
+        return {
+            alarmActionArn: this.lambdaFunction.functionArn,
+        };
+    }
+}
+exports.LambdaAction = LambdaAction;
+_a = JSII_RTTI_SYMBOL_1;
+LambdaAction[_a] = { fqn: "terraconstructs.aws.cloudwatch.actions.LambdaAction", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/cloudwatch/alarm-action.d.ts

@@ -0,0 +1,23 @@
+import { Construct } from "constructs";
+import { IAlarm } from "./alarm-base";
+/**
+ * Interface for objects that can be the targets of CloudWatch alarm actions
+ */
+export interface IAlarmAction {
+    /**
+     * Return the properties required to send alarm actions to this CloudWatch alarm.
+     *
+     * @param scope root Construct that allows creating new Constructs
+     * @param alarm CloudWatch alarm that the action will target
+     */
+    bind(scope: Construct, alarm: IAlarm): AlarmActionConfig;
+}
+/**
+ * Properties for an alarm action
+ */
+export interface AlarmActionConfig {
+    /**
+     * Return the ARN that should be used for a CloudWatch Alarm action
+     */
+    readonly alarmActionArn: string;
+}

package/lib/aws/cloudwatch/alarm-action.js

@@ -0,0 +1,4 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/alarm-action.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxhcm0tYWN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F3cy9jbG91ZHdhdGNoL2FsYXJtLWFjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsdUdBQXVHIiwic291cmNlc0NvbnRlbnQiOlsiLy8gaHR0cHM6Ly9naXRodWIuY29tL2F3cy9hd3MtY2RrL2Jsb2IvdjIuMTcwLjAvcGFja2FnZXMvYXdzLWNkay1saWIvYXdzLWNsb3Vkd2F0Y2gvbGliL2FsYXJtLWFjdGlvbi50c1xuXG5pbXBvcnQgeyBDb25zdHJ1Y3QgfSBmcm9tIFwiY29uc3RydWN0c1wiO1xuaW1wb3J0IHsgSUFsYXJtIH0gZnJvbSBcIi4vYWxhcm0tYmFzZVwiO1xuXG4vKipcbiAqIEludGVyZmFjZSBmb3Igb2JqZWN0cyB0aGF0IGNhbiBiZSB0aGUgdGFyZ2V0cyBvZiBDbG91ZFdhdGNoIGFsYXJtIGFjdGlvbnNcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBJQWxhcm1BY3Rpb24ge1xuICAvKipcbiAgICogUmV0dXJuIHRoZSBwcm9wZXJ0aWVzIHJlcXVpcmVkIHRvIHNlbmQgYWxhcm0gYWN0aW9ucyB0byB0aGlzIENsb3VkV2F0Y2ggYWxhcm0uXG4gICAqXG4gICAqIEBwYXJhbSBzY29wZSByb290IENvbnN0cnVjdCB0aGF0IGFsbG93cyBjcmVhdGluZyBuZXcgQ29uc3RydWN0c1xuICAgKiBAcGFyYW0gYWxhcm0gQ2xvdWRXYXRjaCBhbGFybSB0aGF0IHRoZSBhY3Rpb24gd2lsbCB0YXJnZXRcbiAgICovXG4gIGJpbmQoc2NvcGU6IENvbnN0cnVjdCwgYWxhcm06IElBbGFybSk6IEFsYXJtQWN0aW9uQ29uZmlnO1xufVxuXG4vKipcbiAqIFByb3BlcnRpZXMgZm9yIGFuIGFsYXJtIGFjdGlvblxuICovXG5leHBvcnQgaW50ZXJmYWNlIEFsYXJtQWN0aW9uQ29uZmlnIHtcbiAgLyoqXG4gICAqIFJldHVybiB0aGUgQVJOIHRoYXQgc2hvdWxkIGJlIHVzZWQgZm9yIGEgQ2xvdWRXYXRjaCBBbGFybSBhY3Rpb25cbiAgICovXG4gIHJlYWRvbmx5IGFsYXJtQWN0aW9uQXJuOiBzdHJpbmc7XG59XG4iXX0=