terraconstructs 0.2.2 → 0.2.4

package/lib/aws/compute/vpn.js

@@ -57,7 +57,7 @@ class VpnGateway extends aws_construct_1.AwsConstructBase {
 }
 exports.VpnGateway = VpnGateway;
 _a = JSII_RTTI_SYMBOL_1;
-VpnGateway[_a] = { fqn: "terraconstructs.aws.compute.VpnGateway", version: "0.2.2" };
+VpnGateway[_a] = { fqn: "terraconstructs.aws.compute.VpnGateway", version: "0.2.4" };
 /**
  * Base class for Vpn connections.
  */
@@ -76,7 +76,7 @@ class VpnConnectionBase extends aws_construct_1.AwsConstructBase {
 }
 exports.VpnConnectionBase = VpnConnectionBase;
 _b = JSII_RTTI_SYMBOL_1;
-VpnConnectionBase[_b] = { fqn: "terraconstructs.aws.compute.VpnConnectionBase", version: "0.2.2" };
+VpnConnectionBase[_b] = { fqn: "terraconstructs.aws.compute.VpnConnectionBase", version: "0.2.4" };
 /**
  * Define a VPN Connection
  *
@@ -254,7 +254,7 @@ class VpnConnection extends VpnConnectionBase {
 }
 exports.VpnConnection = VpnConnection;
 _c = JSII_RTTI_SYMBOL_1;
-VpnConnection[_c] = { fqn: "terraconstructs.aws.compute.VpnConnection", version: "0.2.2" };
+VpnConnection[_c] = { fqn: "terraconstructs.aws.compute.VpnConnection", version: "0.2.4" };
 exports.RESERVED_TUNNEL_INSIDE_CIDR = [
     "169.254.0.0/30",
     "169.254.1.0/30",

package/lib/aws/context-provider.d.ts

@@ -0,0 +1,117 @@
+import { Construct } from "constructs";
+/**
+ */
+export interface GetContextKeyOptions {
+    /**
+     * The context provider to query.
+     */
+    readonly provider: string;
+    /**
+     * Provider-specific properties.
+     */
+    readonly props?: {
+        [key: string]: any;
+    };
+    /**
+     * Whether to include the stack's account and region automatically.
+     *
+     * @default false
+     */
+    readonly includeEnvironment?: boolean;
+    /**
+     * Adds an additional discriminator to the `cdk.context.json` cache key.
+     *
+     * @default - no additional cache key
+     */
+    readonly additionalCacheKey?: string;
+}
+/**
+ */
+export interface GetContextValueOptions extends GetContextKeyOptions {
+    /**
+     * The value to return if the lookup has not yet been performed.
+     *
+     * Upon first synthesis, the lookups has not yet been performed. The
+     * `getValue()` operation returns this value instead, so that synthesis can
+     * proceed. After synthesis completes the first time, the actual lookup will
+     * be performed and synthesis will run again with the *real* value.
+     *
+     * Dummy values should preferably have valid shapes so that downstream
+     * consumers of lookup values don't throw validation exceptions if they
+     * encounter a dummy value (or all possible downstream consumers need to
+     * effectively check for the well-known shape of the dummy value); throwing an
+     * exception would error out the synthesis operation and prevent the lookup
+     * and the second, real, synthesis from happening.
+     *
+     * ## Connection to mustExist
+     *
+     * `dummyValue` is also used as the official value to return if the lookup has
+     * failed and `mustExist == false`.
+     */
+    readonly dummyValue: any;
+    /**
+     * Whether the resource must exist
+     *
+     * If this is set (the default), the query fails if the value or resource we
+     * tried to look up doesn't exist.
+     *
+     * If this is `false` and the value we tried to look up could not be found, the
+     * failure is suppressed and `dummyValue` is officially returned instead.
+     *
+     * When this happens, `dummyValue` is encoded into cached context and it will
+     * never be refreshed anymore until the user runs `cdk context --reset <key>`.
+     *
+     * Note that it is not possible for the CDK app code to make a distinction
+     * between "the lookup has not been performed yet" and "the lookup didn't
+     * find anything and we returned a default value instead".
+     *
+     * ## Context providers
+     *
+     * This feature must explicitly be supported by context providers. It is
+     * currently supported by:
+     *
+     * - KMS key provider
+     * - SSM parameter provider
+     *
+     * ## Note to implementors
+     *
+     * The dummy value should not be returned for all SDK lookup failures. For
+     * example, "no network" or "no credentials" or "malformed query" should
+     * not lead to the dummy value being returned. Only the case of "no such
+     * resource" should.
+     *
+     * @default true
+     */
+    readonly mustExist?: boolean;
+}
+/**
+ */
+export interface GetContextKeyResult {
+    readonly key: string;
+    readonly props: {
+        [key: string]: any;
+    };
+}
+/**
+ */
+export interface GetContextValueResult {
+    readonly value?: any;
+}
+/**
+ * Base class for the model side of context providers
+ *
+ * Instances of this class communicate with context provider plugins in the 'cdk
+ * toolkit' via context variables (input), outputting specialized queries for
+ * more context variables (output).
+ *
+ * ContextProvider needs access to a Construct to hook into the context mechanism.
+ *
+ */
+export declare class ContextProvider {
+    /**
+     * @returns the context key or undefined if a key cannot be rendered (due to tokens used in any of the props)
+     */
+    static getKey(scope: Construct, options: GetContextKeyOptions): GetContextKeyResult;
+    static getValue(scope: Construct, options: GetContextValueOptions): GetContextValueResult;
+    private constructor();
+}

package/lib/aws/context-provider.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextProvider = void 0;
+const cdktf_1 = require("cdktf");
+const constructs_1 = require("constructs");
+const errors_1 = require("../errors");
+const aws_stack_1 = require("./aws-stack");
+const cxapi = require("./cx-api");
+/**
+ * Base class for the model side of context providers
+ *
+ * Instances of this class communicate with context provider plugins in the 'cdk
+ * toolkit' via context variables (input), outputting specialized queries for
+ * more context variables (output).
+ *
+ * ContextProvider needs access to a Construct to hook into the context mechanism.
+ *
+ */
+class ContextProvider {
+    /**
+     * @returns the context key or undefined if a key cannot be rendered (due to tokens used in any of the props)
+     */
+    static getKey(scope, options) {
+        const stack = aws_stack_1.AwsStack.ofAwsConstruct(scope);
+        const props = {
+            // Defaults to false because we do not support static value for account
+            ...((options.includeEnvironment ?? false)
+                ? { account: stack.account, region: stack.region }
+                : {}),
+            ...(options.additionalCacheKey
+                ? { additionalCacheKey: options.additionalCacheKey }
+                : {}),
+            ...options.props,
+        };
+        if (Object.values(props).find((x) => cdktf_1.Token.isUnresolved(x))) {
+            throw new errors_1.ValidationError(`Cannot determine scope for context provider ${options.provider}.\n` +
+                "This usually happens when one or more of the provider props have unresolved tokens", scope);
+        }
+        const propStrings = propsToArray(props);
+        return {
+            key: `${options.provider}:${propStrings.join(":")}`,
+            props,
+        };
+    }
+    static getValue(scope, options) {
+        if (options.mustExist !== undefined) {
+            throw new errors_1.ValidationError("Only supply one of 'mustExist' and 'ignoreErrorOnMissingContext'", scope);
+        }
+        const stack = aws_stack_1.AwsStack.ofAwsConstruct(scope);
+        // TODO: re-enable whenever environment details can be set directly
+        // if (Token.isUnresolved(stack.account) || Token.isUnresolved(stack.region)) {
+        //   throw new ValidationError(
+        //     `Cannot retrieve value from context provider ${options.provider} since account/region ` +
+        //       'are not specified at the stack level. Configure "env" with an account and region when ' +
+        //       "you define your stack." +
+        //       "See https://docs.aws.amazon.com/cdk/latest/guide/environments.html for more details.",
+        //     scope,
+        //   );
+        // }
+        const { key, props } = this.getKey(scope, options);
+        const value = constructs_1.Node.of(scope).tryGetContext(key);
+        const providerError = extractProviderError(value);
+        // if context is missing or an error occurred during context retrieval,
+        // report and return a dummy value.
+        if (value === undefined || providerError !== undefined) {
+            // Render 'ignoreErrorOnMissingContext' iff one of the parameters is supplied.
+            const ignoreErrorOnMissingContext = options.mustExist !== undefined ? !options.mustExist : undefined;
+            // build a version of the props which includes the dummyValue and ignoreError flag
+            const extendedProps = {
+                dummyValue: options.dummyValue,
+                // Even though we renamed the user-facing property, the field in the
+                // cloud assembly still has the original name, which is somewhat wrong
+                // because it's not about missing context.
+                ignoreErrorOnMissingContext,
+                ...(options.additionalCacheKey
+                    ? { additionalCacheKey: options.additionalCacheKey }
+                    : {}),
+                ...props,
+            };
+            // We'll store the extendedProps in the missingContextKey report
+            // so that we can retrieve the dummyValue and ignoreError flag
+            // in the aws-cdk's ssm-context and kms key provider
+            stack.reportMissingContextKey({
+                key,
+                provider: options.provider,
+                props: extendedProps,
+            });
+            if (providerError !== undefined) {
+                cdktf_1.Annotations.of(scope).addError(providerError);
+            }
+            return { value: options.dummyValue };
+        }
+        return { value };
+    }
+    constructor() { }
+}
+exports.ContextProvider = ContextProvider;
+/**
+ * If the context value represents an error, return the error message
+ */
+function extractProviderError(value) {
+    if (typeof value === "object" && value !== null) {
+        return value[cxapi.PROVIDER_ERROR_KEY];
+    }
+    return undefined;
+}
+/**
+ * Quote colons in all strings so that we can undo the quoting at a later point
+ *
+ * We'll use $ as a quoting character, for no particularly good reason other
+ * than that \ is going to lead to quoting hell when the keys are stored in JSON.
+ */
+function colonQuote(xs) {
+    return xs.replace(/\$/g, "$$").replace(/:/g, "$:");
+}
+function propsToArray(props, keyPrefix = "") {
+    const ret = [];
+    for (const key of Object.keys(props)) {
+        // skip undefined values
+        if (props[key] === undefined) {
+            continue;
+        }
+        switch (typeof props[key]) {
+            case "object": {
+                ret.push(...propsToArray(props[key], `${keyPrefix}${key}.`));
+                break;
+            }
+            case "string": {
+                ret.push(`${keyPrefix}${key}=${colonQuote(props[key])}`);
+                break;
+            }
+            default: {
+                ret.push(`${keyPrefix}${key}=${JSON.stringify(props[key])}`);
+                break;
+            }
+        }
+    }
+    ret.sort();
+    return ret;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-provider.js","sourceRoot":"","sources":["../../src/aws/context-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cxschema from \"@aws-cdk/cloud-assembly-schema\";\nimport { Annotations, Token } from \"cdktf\";\nimport { Construct, Node } from \"constructs\";\nimport { ValidationError } from \"../errors\";\nimport { AwsStack } from \"./aws-stack\";\nimport * as cxapi from \"./cx-api\";\n\n/**\n */\nexport interface GetContextKeyOptions {\n  /**\n   * The context provider to query.\n   */\n  readonly provider: string;\n\n  /**\n   * Provider-specific properties.\n   */\n  readonly props?: { [key: string]: any };\n\n  /**\n   * Whether to include the stack's account and region automatically.\n   *\n   * @default false\n   */\n  readonly includeEnvironment?: boolean;\n\n  /**\n   * Adds an additional discriminator to the `cdk.context.json` cache key.\n   *\n   * @default - no additional cache key\n   */\n  readonly additionalCacheKey?: string;\n}\n\n/**\n */\nexport interface GetContextValueOptions extends GetContextKeyOptions {\n  /**\n   * The value to return if the lookup has not yet been performed.\n   *\n   * Upon first synthesis, the lookups has not yet been performed. The\n   * `getValue()` operation returns this value instead, so that synthesis can\n   * proceed. After synthesis completes the first time, the actual lookup will\n   * be performed and synthesis will run again with the *real* value.\n   *\n   * Dummy values should preferably have valid shapes so that downstream\n   * consumers of lookup values don't throw validation exceptions if they\n   * encounter a dummy value (or all possible downstream consumers need to\n   * effectively check for the well-known shape of the dummy value); throwing an\n   * exception would error out the synthesis operation and prevent the lookup\n   * and the second, real, synthesis from happening.\n   *\n   * ## Connection to mustExist\n   *\n   * `dummyValue` is also used as the official value to return if the lookup has\n   * failed and `mustExist == false`.\n   */\n  readonly dummyValue: any;\n\n  /**\n   * Whether the resource must exist\n   *\n   * If this is set (the default), the query fails if the value or resource we\n   * tried to look up doesn't exist.\n   *\n   * If this is `false` and the value we tried to look up could not be found, the\n   * failure is suppressed and `dummyValue` is officially returned instead.\n   *\n   * When this happens, `dummyValue` is encoded into cached context and it will\n   * never be refreshed anymore until the user runs `cdk context --reset <key>`.\n   *\n   * Note that it is not possible for the CDK app code to make a distinction\n   * between \"the lookup has not been performed yet\" and \"the lookup didn't\n   * find anything and we returned a default value instead\".\n   *\n   * ## Context providers\n   *\n   * This feature must explicitly be supported by context providers. It is\n   * currently supported by:\n   *\n   * - KMS key provider\n   * - SSM parameter provider\n   *\n   * ## Note to implementors\n   *\n   * The dummy value should not be returned for all SDK lookup failures. For\n   * example, \"no network\" or \"no credentials\" or \"malformed query\" should\n   * not lead to the dummy value being returned. Only the case of \"no such\n   * resource\" should.\n   *\n   * @default true\n   */\n  readonly mustExist?: boolean;\n}\n\n/**\n */\nexport interface GetContextKeyResult {\n  readonly key: string;\n  readonly props: { [key: string]: any };\n}\n\n/**\n */\nexport interface GetContextValueResult {\n  readonly value?: any;\n}\n\n/**\n * Base class for the model side of context providers\n *\n * Instances of this class communicate with context provider plugins in the 'cdk\n * toolkit' via context variables (input), outputting specialized queries for\n * more context variables (output).\n *\n * ContextProvider needs access to a Construct to hook into the context mechanism.\n *\n */\nexport class ContextProvider {\n  /**\n   * @returns the context key or undefined if a key cannot be rendered (due to tokens used in any of the props)\n   */\n  public static getKey(\n    scope: Construct,\n    options: GetContextKeyOptions,\n  ): GetContextKeyResult {\n    const stack = AwsStack.ofAwsConstruct(scope);\n\n    const props = {\n      // Defaults to false because we do not support static value for account\n      ...((options.includeEnvironment ?? false)\n        ? { account: stack.account, region: stack.region }\n        : {}),\n      ...(options.additionalCacheKey\n        ? { additionalCacheKey: options.additionalCacheKey }\n        : {}),\n      ...options.props,\n    };\n\n    if (Object.values(props).find((x) => Token.isUnresolved(x))) {\n      throw new ValidationError(\n        `Cannot determine scope for context provider ${options.provider}.\\n` +\n          \"This usually happens when one or more of the provider props have unresolved tokens\",\n        scope,\n      );\n    }\n\n    const propStrings = propsToArray(props);\n    return {\n      key: `${options.provider}:${propStrings.join(\":\")}`,\n      props,\n    };\n  }\n\n  public static getValue(\n    scope: Construct,\n    options: GetContextValueOptions,\n  ): GetContextValueResult {\n    if (options.mustExist !== undefined) {\n      throw new ValidationError(\n        \"Only supply one of 'mustExist' and 'ignoreErrorOnMissingContext'\",\n        scope,\n      );\n    }\n\n    const stack = AwsStack.ofAwsConstruct(scope);\n\n    // TODO: re-enable whenever environment details can be set directly\n    // if (Token.isUnresolved(stack.account) || Token.isUnresolved(stack.region)) {\n    //   throw new ValidationError(\n    //     `Cannot retrieve value from context provider ${options.provider} since account/region ` +\n    //       'are not specified at the stack level. Configure \"env\" with an account and region when ' +\n    //       \"you define your stack.\" +\n    //       \"See https://docs.aws.amazon.com/cdk/latest/guide/environments.html for more details.\",\n    //     scope,\n    //   );\n    // }\n\n    const { key, props } = this.getKey(scope, options);\n    const value = Node.of(scope).tryGetContext(key);\n    const providerError = extractProviderError(value);\n\n    // if context is missing or an error occurred during context retrieval,\n    // report and return a dummy value.\n    if (value === undefined || providerError !== undefined) {\n      // Render 'ignoreErrorOnMissingContext' iff one of the parameters is supplied.\n      const ignoreErrorOnMissingContext =\n        options.mustExist !== undefined ? !options.mustExist : undefined;\n\n      // build a version of the props which includes the dummyValue and ignoreError flag\n      const extendedProps: { [p: string]: any } = {\n        dummyValue: options.dummyValue,\n\n        // Even though we renamed the user-facing property, the field in the\n        // cloud assembly still has the original name, which is somewhat wrong\n        // because it's not about missing context.\n        ignoreErrorOnMissingContext,\n        ...(options.additionalCacheKey\n          ? { additionalCacheKey: options.additionalCacheKey }\n          : {}),\n        ...props,\n      };\n\n      // We'll store the extendedProps in the missingContextKey report\n      // so that we can retrieve the dummyValue and ignoreError flag\n      // in the aws-cdk's ssm-context and kms key provider\n      stack.reportMissingContextKey({\n        key,\n        provider: options.provider as cxschema.ContextProvider,\n        props: extendedProps as cxschema.ContextQueryProperties,\n      });\n\n      if (providerError !== undefined) {\n        Annotations.of(scope).addError(providerError);\n      }\n\n      return { value: options.dummyValue };\n    }\n\n    return { value };\n  }\n\n  private constructor() {}\n}\n\n/**\n * If the context value represents an error, return the error message\n */\nfunction extractProviderError(value: any): string | undefined {\n  if (typeof value === \"object\" && value !== null) {\n    return value[cxapi.PROVIDER_ERROR_KEY];\n  }\n  return undefined;\n}\n\n/**\n * Quote colons in all strings so that we can undo the quoting at a later point\n *\n * We'll use $ as a quoting character, for no particularly good reason other\n * than that \\ is going to lead to quoting hell when the keys are stored in JSON.\n */\nfunction colonQuote(xs: string): string {\n  return xs.replace(/\\$/g, \"$$\").replace(/:/g, \"$:\");\n}\n\nfunction propsToArray(props: { [key: string]: any }, keyPrefix = \"\"): string[] {\n  const ret: string[] = [];\n\n  for (const key of Object.keys(props)) {\n    // skip undefined values\n    if (props[key] === undefined) {\n      continue;\n    }\n\n    switch (typeof props[key]) {\n      case \"object\": {\n        ret.push(...propsToArray(props[key], `${keyPrefix}${key}.`));\n        break;\n      }\n      case \"string\": {\n        ret.push(`${keyPrefix}${key}=${colonQuote(props[key])}`);\n        break;\n      }\n      default: {\n        ret.push(`${keyPrefix}${key}=${JSON.stringify(props[key])}`);\n        break;\n      }\n    }\n  }\n\n  ret.sort();\n  return ret;\n}\n"]}

package/lib/aws/cx-api.d.ts

@@ -1 +1,172 @@
+/**
+ * If a context value is an object with this key, it indicates an error
+ */
+export declare const PROVIDER_ERROR_KEY = "$providerError";
 export declare const TARGET_PARTITIONS = "terraconstructs/core:target-partitions";
+/**
+ * The type of subnet group.
+ * Same as SubnetType in the aws-cdk-lib/aws-ec2 package,
+ * but we can't use that because of cyclical dependencies.
+ */
+export declare enum VpcSubnetGroupType {
+    /** Public subnet group type. */
+    PUBLIC = "Public",
+    /** Private subnet group type. */
+    PRIVATE = "Private",
+    /** Isolated subnet group type. */
+    ISOLATED = "Isolated"
+}
+/**
+ * A subnet representation that the VPC provider uses.
+ */
+export interface VpcSubnet {
+    /** The identifier of the subnet. */
+    readonly subnetId: string;
+    /**
+     * The code of the availability zone this subnet is in
+     * (for example, 'us-west-2a').
+     */
+    readonly availabilityZone: string;
+    /** The identifier of the route table for this subnet. */
+    readonly routeTableId: string;
+    /**
+     * CIDR range of the subnet
+     *
+     * @default - CIDR information not available
+     */
+    readonly cidr?: string;
+}
+/**
+ * A group of subnets returned by the VPC provider.
+ * The included subnets do NOT have to be symmetric!
+ */
+export interface VpcSubnetGroup {
+    /**
+     * The name of the subnet group,
+     * determined by looking at the tags of of the subnets
+     * that belong to it.
+     */
+    readonly name: string;
+    /** The type of the subnet group. */
+    readonly type: VpcSubnetGroupType;
+    /**
+     * The subnets that are part of this group.
+     * There is no condition that the subnets have to be symmetric
+     * in the group.
+     */
+    readonly subnets: VpcSubnet[];
+}
+/**
+ * Properties of a discovered VPC
+ */
+export interface VpcContextResponse {
+    /**
+     * VPC id
+     */
+    readonly vpcId: string;
+    /**
+     * VPC cidr
+     *
+     * @default - CIDR information not available
+     */
+    readonly vpcCidrBlock?: string;
+    /**
+     * AZs
+     */
+    readonly availabilityZones: string[];
+    /**
+     * IDs of all public subnets
+     *
+     * Element count: #(availabilityZones) · #(publicGroups)
+     */
+    readonly publicSubnetIds?: string[];
+    /**
+     * Name of public subnet groups
+     *
+     * Element count: #(publicGroups)
+     */
+    readonly publicSubnetNames?: string[];
+    /**
+     * Route Table IDs of public subnet groups.
+     *
+     * Element count: #(availabilityZones) · #(publicGroups)
+     */
+    readonly publicSubnetRouteTableIds?: string[];
+    /**
+     * IDs of all private subnets
+     *
+     * Element count: #(availabilityZones) · #(privateGroups)
+     */
+    readonly privateSubnetIds?: string[];
+    /**
+     * Name of private subnet groups
+     *
+     * Element count: #(privateGroups)
+     */
+    readonly privateSubnetNames?: string[];
+    /**
+     * Route Table IDs of private subnet groups.
+     *
+     * Element count: #(availabilityZones) · #(privateGroups)
+     */
+    readonly privateSubnetRouteTableIds?: string[];
+    /**
+     * IDs of all isolated subnets
+     *
+     * Element count: #(availabilityZones) · #(isolatedGroups)
+     */
+    readonly isolatedSubnetIds?: string[];
+    /**
+     * Name of isolated subnet groups
+     *
+     * Element count: #(isolatedGroups)
+     */
+    readonly isolatedSubnetNames?: string[];
+    /**
+     * Route Table IDs of isolated subnet groups.
+     *
+     * Element count: #(availabilityZones) · #(isolatedGroups)
+     */
+    readonly isolatedSubnetRouteTableIds?: string[];
+    /**
+     * The VPN gateway ID
+     */
+    readonly vpnGatewayId?: string;
+    /**
+     * The subnet groups discovered for the given VPC.
+     * Unlike the above properties, this will include asymmetric subnets,
+     * if the VPC has any.
+     * This property will only be populated if `VpcContextQuery.returnAsymmetricSubnets`
+     * is true.
+     *
+     * @default - no subnet groups will be returned unless `VpcContextQuery.returnAsymmetricSubnets` is true
+     */
+    readonly subnetGroups?: VpcSubnetGroup[];
+    /**
+     * The region in which the VPC is in.
+     *
+     * @default - Region of the parent stack
+     */
+    readonly region?: string;
+    /**
+     * The ID of the AWS account that owns the VPC.
+     *
+     * @default the account id of the parent stack
+     */
+    readonly ownerAccountId?: string;
+}
+/**
+ * Properties of a discovered SecurityGroup.
+ */
+export interface SecurityGroupContextResponse {
+    /**
+     * The security group's id.
+     */
+    readonly securityGroupId: string;
+    /**
+     * Whether the security group allows all outbound traffic. This will be true
+     * when the security group has all-protocol egress permissions to access both
+     * `0.0.0.0/0` and `::/0`.
+     */
+    readonly allowAllOutbound: boolean;
+}

package/lib/aws/cx-api.js

@@ -1,6 +1,26 @@
 "use strict";
-// https://github.com/aws/aws-cdk/blob/v2.232.2/packages/aws-cdk-lib/cx-api/lib/features.ts
+// https://github.com/aws/aws-cdk/blob/v2.233.0/packages/aws-cdk-lib/cx-api/lib/cxapi.ts
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TARGET_PARTITIONS = void 0;
+exports.VpcSubnetGroupType = exports.TARGET_PARTITIONS = exports.PROVIDER_ERROR_KEY = void 0;
+/**
+ * If a context value is an object with this key, it indicates an error
+ */
+exports.PROVIDER_ERROR_KEY = "$providerError";
+// Ref: https://github.com/aws/aws-cdk/blob/v2.232.2/packages/aws-cdk-lib/cx-api/lib/features.ts
 exports.TARGET_PARTITIONS = "terraconstructs/core:target-partitions";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3gtYXBpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2F3cy9jeC1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLDJGQUEyRjs7O0FBRTlFLFFBQUEsaUJBQWlCLEdBQUcsd0NBQXdDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBodHRwczovL2dpdGh1Yi5jb20vYXdzL2F3cy1jZGsvYmxvYi92Mi4yMzIuMi9wYWNrYWdlcy9hd3MtY2RrLWxpYi9jeC1hcGkvbGliL2ZlYXR1cmVzLnRzXG5cbmV4cG9ydCBjb25zdCBUQVJHRVRfUEFSVElUSU9OUyA9IFwidGVycmFjb25zdHJ1Y3RzL2NvcmU6dGFyZ2V0LXBhcnRpdGlvbnNcIjtcbiJdfQ==
+// Ref: https://github.com/aws/aws-cdk/blob/v2.232.2/packages/aws-cdk-lib/cx-api/lib/context/vpc.ts
+/**
+ * The type of subnet group.
+ * Same as SubnetType in the aws-cdk-lib/aws-ec2 package,
+ * but we can't use that because of cyclical dependencies.
+ */
+var VpcSubnetGroupType;
+(function (VpcSubnetGroupType) {
+    /** Public subnet group type. */
+    VpcSubnetGroupType["PUBLIC"] = "Public";
+    /** Private subnet group type. */
+    VpcSubnetGroupType["PRIVATE"] = "Private";
+    /** Isolated subnet group type. */
+    VpcSubnetGroupType["ISOLATED"] = "Isolated";
+})(VpcSubnetGroupType || (exports.VpcSubnetGroupType = VpcSubnetGroupType = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/edge/certificate.js

@@ -154,7 +154,7 @@ class PublicCertificate extends certificate_base_1.CertificateBase {
 }
 exports.PublicCertificate = PublicCertificate;
 _a = JSII_RTTI_SYMBOL_1;
-PublicCertificate[_a] = { fqn: "terraconstructs.aws.edge.PublicCertificate", version: "0.2.2" };
+PublicCertificate[_a] = { fqn: "terraconstructs.aws.edge.PublicCertificate", version: "0.2.4" };
 /**
  * Method used to assert ownership of the domain
  */

package/lib/aws/edge/distribution.js

@@ -242,7 +242,7 @@ class Distribution extends aws_construct_1.AwsConstructBase {
 }
 exports.Distribution = Distribution;
 _a = JSII_RTTI_SYMBOL_1;
-Distribution[_a] = { fqn: "terraconstructs.aws.edge.Distribution", version: "0.2.2" };
+Distribution[_a] = { fqn: "terraconstructs.aws.edge.Distribution", version: "0.2.4" };
 var GeoRestrictionType;
 (function (GeoRestrictionType) {
     GeoRestrictionType["NONE"] = "none";
@@ -320,7 +320,7 @@ class AllowedMethods {
 }
 exports.AllowedMethods = AllowedMethods;
 _b = JSII_RTTI_SYMBOL_1;
-AllowedMethods[_b] = { fqn: "terraconstructs.aws.edge.AllowedMethods", version: "0.2.2" };
+AllowedMethods[_b] = { fqn: "terraconstructs.aws.edge.AllowedMethods", version: "0.2.4" };
 /** HEAD and GET */
 AllowedMethods.ALLOW_GET_HEAD = new AllowedMethods(["GET", "HEAD"]);
 /** HEAD, GET, and OPTIONS */
@@ -349,7 +349,7 @@ class CachedMethods {
 }
 exports.CachedMethods = CachedMethods;
 _c = JSII_RTTI_SYMBOL_1;
-CachedMethods[_c] = { fqn: "terraconstructs.aws.edge.CachedMethods", version: "0.2.2" };
+CachedMethods[_c] = { fqn: "terraconstructs.aws.edge.CachedMethods", version: "0.2.4" };
 /** HEAD and GET */
 CachedMethods.CACHE_GET_HEAD = new CachedMethods(["GET", "HEAD"]);
 /** HEAD, GET, and OPTIONS */

package/lib/aws/edge/dns-alias-record-targets.js

@@ -21,7 +21,7 @@ class DistributionTarget {
 }
 exports.DistributionTarget = DistributionTarget;
 _a = JSII_RTTI_SYMBOL_1;
-DistributionTarget[_a] = { fqn: "terraconstructs.aws.edge.DistributionTarget", version: "0.2.2" };
+DistributionTarget[_a] = { fqn: "terraconstructs.aws.edge.DistributionTarget", version: "0.2.4" };
 /**
  * Use Bucket as an alias record target
  */
@@ -43,7 +43,7 @@ class BucketWebsiteTarget {
 }
 exports.BucketWebsiteTarget = BucketWebsiteTarget;
 _b = JSII_RTTI_SYMBOL_1;
-BucketWebsiteTarget[_b] = { fqn: "terraconstructs.aws.edge.BucketWebsiteTarget", version: "0.2.2" };
+BucketWebsiteTarget[_b] = { fqn: "terraconstructs.aws.edge.BucketWebsiteTarget", version: "0.2.4" };
 /**
  * Use an ELBv2 as an alias record target
  */
@@ -65,7 +65,7 @@ class LoadBalancerTarget {
 }
 exports.LoadBalancerTarget = LoadBalancerTarget;
 _c = JSII_RTTI_SYMBOL_1;
-LoadBalancerTarget[_c] = { fqn: "terraconstructs.aws.edge.LoadBalancerTarget", version: "0.2.2" };
+LoadBalancerTarget[_c] = { fqn: "terraconstructs.aws.edge.LoadBalancerTarget", version: "0.2.4" };
 /**
  * Defines an API Gateway domain name as the alias target.
  *
@@ -86,7 +86,7 @@ class ApiGatewayDomain {
 }
 exports.ApiGatewayDomain = ApiGatewayDomain;
 _d = JSII_RTTI_SYMBOL_1;
-ApiGatewayDomain[_d] = { fqn: "terraconstructs.aws.edge.ApiGatewayDomain", version: "0.2.2" };
+ApiGatewayDomain[_d] = { fqn: "terraconstructs.aws.edge.ApiGatewayDomain", version: "0.2.4" };
 /**
  * Defines an API Gateway REST API as the alias target. Requires that the domain
  * name will be defined through `RestApiProps.domainName`.
@@ -104,7 +104,7 @@ class ApiGatewayTarget extends ApiGatewayDomain {
 }
 exports.ApiGatewayTarget = ApiGatewayTarget;
 _e = JSII_RTTI_SYMBOL_1;
-ApiGatewayTarget[_e] = { fqn: "terraconstructs.aws.edge.ApiGatewayTarget", version: "0.2.2" };
+ApiGatewayTarget[_e] = { fqn: "terraconstructs.aws.edge.ApiGatewayTarget", version: "0.2.4" };
 /**
  * Defines an API Gateway V2 domain name as the alias target.
  */
@@ -127,5 +127,5 @@ class ApiGatewayv2DomainProperties {
 }
 exports.ApiGatewayv2DomainProperties = ApiGatewayv2DomainProperties;
 _f = JSII_RTTI_SYMBOL_1;
-ApiGatewayv2DomainProperties[_f] = { fqn: "terraconstructs.aws.edge.ApiGatewayv2DomainProperties", version: "0.2.2" };
+ApiGatewayv2DomainProperties[_f] = { fqn: "terraconstructs.aws.edge.ApiGatewayv2DomainProperties", version: "0.2.4" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dns-alias-record-targets.js","sourceRoot":"","sources":["../../../src/aws/edge/dns-alias-record-targets.ts"],"names":[],"mappings":";;;;;AAGA,gFAGiD;AAejD;;GAEG;AACH,MAAa,kBAAkB;IAC7B,YAA6B,YAA2B;QAA3B,iBAAY,GAAZ,YAAY,CAAe;IAAG,CAAC;IAErD,IAAI,CACT,OAAmB,EACnB,KAAgB;QAEhB,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,YAAY;YACtC,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,UAAU;YAClC,oBAAoB,EAAE,KAAK;SAC5B,CAAC;IACJ,CAAC;;AAZH,gDAaC;;;AAED;;GAEG;AACH,MAAa,mBAAmB;IAC9B,YAA6B,MAAe;QAAf,WAAM,GAAN,MAAM,CAAS;IAAG,CAAC;IAEzC,IAAI,CACT,OAAmB,EACnB,KAAgB;QAEhB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CACb,2DAA2D,CAC5D,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,iBAAiB,CAAC;QAE5C,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,YAAY;YAChC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,iBAAiB;YACnC,oBAAoB,EAAE,IAAI;SAC3B,CAAC;IACJ,CAAC;;AAnBH,kDAoBC;;;AAED;;GAEG;AACH,MAAa,kBAAkB;IACtB,MAAM,CAAC,cAAc,CAC1B,iCAAyC,EACzC,mBAA2B;QAE3B,MAAM,QAAQ,GAAG,IAAI,yCAAoB,CACvC,iCAAiC,EACjC,mBAAmB,CACpB,CAAC;QACF,OAAO,IAAI,kBAAkB,CAAC,QAAQ,CAAC,CAAC;IAC1C,CAAC;IACD,YAA6B,YAAiC;QAAjC,iBAAY,GAAZ,YAAY,CAAqB;IAAG,CAAC;IAE3D,IAAI,CACT,OAAmB,EACnB,KAAgB;QAEhB,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,iCAAiC;YAC3D,IAAI,EAAE,aAAa,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE;YAC1D,oBAAoB,EAAE,IAAI;SAC3B,CAAC;IACJ,CAAC;;AAtBH,gDAuBC;;;AAED;;;;;GAKG;AACH,MAAa,gBAAgB;IAC3B,YAA6B,UAAuB;QAAvB,eAAU,GAAV,UAAU,CAAa;IAAG,CAAC;IAEjD,IAAI,CACT,OAAmB,EACnB,KAAgB;QAEhB,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,2BAA2B;YACnD,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,yBAAyB;YAC/C,oBAAoB,EAAE,IAAI;SAC3B,CAAC;IACJ,CAAC;;AAZH,4CAaC;;;AAED;;;;;;GAMG;AACH,MAAa,gBAAiB,SAAQ,gBAAgB;IACpD,YAAY,GAAgB;QAC1B,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,8CAA8C,GAAG,EAAE,CAAC,CAAC;QACvE,CAAC;QAED,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IACxB,CAAC;;AAPH,4CAQC;;;AAED;;GAEG;AACH,MAAa,4BAA4B;IACvC;;;OAGG;IACH,YACmB,kBAA0B,EAC1B,oBAA4B;QAD5B,uBAAkB,GAAlB,kBAAkB,CAAQ;QAC1B,yBAAoB,GAApB,oBAAoB,CAAQ;IAC5C,CAAC;IAEG,IAAI,CACT,OAAmB,EACnB,KAAgB;QAEhB,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,kBAAkB;YAC7B,MAAM,EAAE,IAAI,CAAC,oBAAoB;YACjC,oBAAoB,EAAE,IAAI;SAC3B,CAAC;IACJ,CAAC;;AAnBH,oEAoBC","sourcesContent":["import { route53Record } from \"@cdktf/provider-aws\";\nimport { IRecordSet, IDnsZone, IDistribution } from \".\";\nimport { IDomainName } from \"../compute/domain-name\";\nimport {\n  ILoadBalancerBaseV2,\n  ImportedLoadBalancer,\n} from \"../compute/lb-shared/base-load-balancer\";\nimport { RestApiBase } from \"../compute/restapi\";\nimport { IBucket } from \"../storage\";\n\n/**\n * Classes that are valid alias record targets, like CloudFront distributions load\n * balancers, should implement this interface.\n */\nexport interface IAliasRecordTarget {\n  /**\n   * Return hosted zone ID and DNS name, usable for Route53 alias targets\n   */\n  bind(record: IRecordSet, zone?: IDnsZone): route53Record.Route53RecordAlias;\n}\n\n/**\n * Use a CloudFront Distribution as an alias record target\n */\nexport class DistributionTarget implements IAliasRecordTarget {\n  constructor(private readonly distribution: IDistribution) {}\n\n  public bind(\n    _record: IRecordSet,\n    _zone?: IDnsZone,\n  ): route53Record.Route53RecordAlias {\n    return {\n      zoneId: this.distribution.hostedZoneId,\n      name: this.distribution.domainName,\n      evaluateTargetHealth: false,\n    };\n  }\n}\n\n/**\n * Use Bucket as an alias record target\n */\nexport class BucketWebsiteTarget implements IAliasRecordTarget {\n  constructor(private readonly bucket: IBucket) {}\n\n  public bind(\n    _record: IRecordSet,\n    _zone?: IDnsZone,\n  ): route53Record.Route53RecordAlias {\n    if (!this.bucket.isWebsite()) {\n      throw new Error(\n        \"Cannot use a non-website bucket as an alias record target\",\n      );\n    }\n    this.bucket.bucketOutputs.websiteDomainName;\n\n    return {\n      zoneId: this.bucket.hostedZoneId,\n      name: this.bucket.websiteDomainName,\n      evaluateTargetHealth: true,\n    };\n  }\n}\n\n/**\n * Use an ELBv2 as an alias record target\n */\nexport class LoadBalancerTarget implements IAliasRecordTarget {\n  public static fromAttributes(\n    loadBalancerCanonicalHostedZoneId: string,\n    loadBalancerDnsName: string,\n  ) {\n    const imported = new ImportedLoadBalancer(\n      loadBalancerCanonicalHostedZoneId,\n      loadBalancerDnsName,\n    );\n    return new LoadBalancerTarget(imported);\n  }\n  constructor(private readonly loadBalancer: ILoadBalancerBaseV2) {}\n\n  public bind(\n    _record: IRecordSet,\n    _zone?: IDnsZone,\n  ): route53Record.Route53RecordAlias {\n    return {\n      zoneId: this.loadBalancer.loadBalancerCanonicalHostedZoneId,\n      name: `dualstack.${this.loadBalancer.loadBalancerDnsName}`,\n      evaluateTargetHealth: true,\n    };\n  }\n}\n\n/**\n * Defines an API Gateway domain name as the alias target.\n *\n * Use the `ApiGatewayTarget` class if you wish to map the alias to an REST API with a\n * domain name defined through the `RestApiProps.domainName` prop.\n */\nexport class ApiGatewayDomain implements IAliasRecordTarget {\n  constructor(private readonly domainName: IDomainName) {}\n\n  public bind(\n    _record: IRecordSet,\n    _zone?: IDnsZone,\n  ): route53Record.Route53RecordAlias {\n    return {\n      zoneId: this.domainName.domainNameAliasHostedZoneId,\n      name: this.domainName.domainNameAliasDomainName,\n      evaluateTargetHealth: true,\n    };\n  }\n}\n\n/**\n * Defines an API Gateway REST API as the alias target. Requires that the domain\n * name will be defined through `RestApiProps.domainName`.\n *\n * You can direct the alias to any `apigateway.DomainName` resource through the\n * `ApiGatewayDomain` class.\n */\nexport class ApiGatewayTarget extends ApiGatewayDomain {\n  constructor(api: RestApiBase) {\n    if (!api.domainName) {\n      throw new Error(`API does not define a default domain name: ${api}`);\n    }\n\n    super(api.domainName);\n  }\n}\n\n/**\n * Defines an API Gateway V2 domain name as the alias target.\n */\nexport class ApiGatewayv2DomainProperties implements IAliasRecordTarget {\n  /**\n   * @param regionalDomainName the domain name associated with the regional endpoint for this custom domain name.\n   * @param regionalHostedZoneId the region-specific Amazon Route 53 Hosted Zone ID of the regional endpoint.\n   */\n  constructor(\n    private readonly regionalDomainName: string,\n    private readonly regionalHostedZoneId: string,\n  ) {}\n\n  public bind(\n    _record: IRecordSet,\n    _zone?: IDnsZone,\n  ): route53Record.Route53RecordAlias {\n    return {\n      name: this.regionalDomainName,\n      zoneId: this.regionalHostedZoneId,\n      evaluateTargetHealth: true,\n    };\n  }\n}\n"]}