terraconstructs 0.0.10 → 0.0.12

package/lib/aws/compute/lb-shared/access-logs-accounts.js

@@ -0,0 +1,46 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/region-info/build-tools/fact-tables.ts#L120
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ELBV2_ACCOUNTS = void 0;
+exports.getElbv2Account = getElbv2Account;
+// https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#access-logging-bucket-permissions
+// https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-access-logs.html#attach-bucket-policy
+// Any not listed regions use the service principal "logdelivery.elasticloadbalancing.amazonaws.com"
+exports.ELBV2_ACCOUNTS = {
+    "af-south-1": "098369216593",
+    "ap-east-1": "754344448648",
+    "ap-northeast-1": "582318560864",
+    "ap-northeast-2": "600734575887",
+    "ap-northeast-3": "383597477331",
+    "ap-south-1": "718504428378",
+    "ap-southeast-1": "114774131450",
+    "ap-southeast-2": "783225319266",
+    "ap-southeast-3": "589379963580",
+    "ca-central-1": "985666609251",
+    "cn-north-1": "638102146993",
+    "cn-northwest-1": "037604701340",
+    "eu-central-1": "054676820928",
+    "eu-north-1": "897822967062",
+    "eu-south-1": "635631232127",
+    "eu-west-1": "156460612806",
+    "eu-west-2": "652711504416",
+    "eu-west-3": "009996457667",
+    "me-south-1": "076674570225",
+    "sa-east-1": "507241528517",
+    "us-east-1": "127311923021",
+    "us-east-2": "033677994240",
+    "us-gov-east-1": "190560391635",
+    "us-gov-west-1": "048591011584",
+    "us-iso-east-1": "770363063475",
+    "us-isob-east-1": "740734521339",
+    "us-iso-west-1": "121062877647",
+    "us-west-1": "027434742980",
+    "us-west-2": "797873946194",
+};
+/**
+ * The account ID for ELBv2 in this region
+ */
+function getElbv2Account(region) {
+    return exports.ELBV2_ACCOUNTS[region];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/lb-shared/base-listener.d.ts

@@ -0,0 +1,113 @@
+import { Construct } from "constructs";
+import { LoadBalancerType, LoadBalancerListenerProtocol } from "./grid-lookup-types";
+import { LbListenerConfig } from "./lb-listener-config.generated";
+import { IListenerAction } from "./listener-action";
+import { IAwsConstruct, AwsConstructBase } from "../../aws-construct";
+/**
+ * Options for listener lookup
+ */
+export interface BaseListenerLookupOptions {
+    /**
+     * Filter listeners by associated load balancer arn
+     * @default - does not filter by load balancer arn
+     */
+    readonly loadBalancerArn?: string;
+    /**
+     * Filter listeners by associated load balancer tags
+     * @default - does not filter by load balancer tags
+     */
+    readonly loadBalancerTags?: Record<string, string>;
+    /**
+     * Filter listeners by listener port
+     * @default - does not filter by listener port
+     */
+    readonly listenerPort?: number;
+}
+/**
+ * Options for querying the load balancer listener context provider
+ * @internal
+ */
+export interface ListenerQueryContextProviderOptions {
+    /**
+     * User's provided options
+     */
+    readonly userOptions: BaseListenerLookupOptions;
+    /**
+     * Type of load balancer expected
+     */
+    readonly loadBalancerType: LoadBalancerType;
+    /**
+     * ARN of the listener to look up
+     * @default - does not filter by listener arn
+     */
+    readonly listenerArn?: string;
+    /**
+     * Optional protocol of the listener to look up
+     */
+    readonly listenerProtocol?: LoadBalancerListenerProtocol;
+}
+/**
+ * Outputs which may be registered for output via the Grid.
+ */
+export interface ListenerOutputs {
+    /**
+     * ARN of the listener
+     * @attribute
+     */
+    readonly listenerArn: string;
+}
+/**
+ * Base interface for listeners
+ */
+export interface IListener extends IAwsConstruct {
+    /** Strongly typed outputs */
+    readonly listenerOutputs: ListenerOutputs;
+    /**
+     * ARN of the listener
+     * @attribute
+     */
+    readonly listenerArn: string;
+}
+/**
+ * Base class for listeners
+ */
+export declare abstract class BaseListener extends AwsConstructBase implements IListener {
+    /**
+     * Strongly typed outputs
+     */
+    get listenerOutputs(): ListenerOutputs;
+    get outputs(): Record<string, any>;
+    /**
+     * @attribute
+     */
+    readonly listenerArn: string;
+    /**
+     * Attributes set on this listener
+     */
+    private readonly attributes;
+    private defaultAction?;
+    constructor(scope: Construct, id: string, additionalProps: LbListenerConfig);
+    /**
+     * Set a non-standard attribute on the listener
+     *
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancingv2-listener-listenerattribute.html
+     */
+    setAttribute(key: string, value: string | undefined): void;
+    /**
+     * Remove an attribute from the listener
+     */
+    removeAttribute(key: string): void;
+    private lazyStringAttr;
+    private lazyBoolAttr;
+    private lazyNumberAttr;
+    /**
+     * Validate this listener
+     */
+    protected validateListener(): string[];
+    /**
+     * Configure the default action
+     *
+     * @internal
+     */
+    protected _setDefaultAction(action: IListenerAction): void;
+}

package/lib/aws/compute/lb-shared/base-listener.js

@@ -0,0 +1,181 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseListener = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancingv2/lib/shared/base-listener.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const util_1 = require("./util");
+const aws_construct_1 = require("../../aws-construct");
+/**
+ * Base class for listeners
+ */
+class BaseListener extends aws_construct_1.AwsConstructBase {
+    // /**
+    //  * Queries the load balancer listener context provider for load balancer
+    //  * listener info.
+    //  * @internal
+    //  */
+    // protected static _queryContextProvider(
+    //   scope: Construct,
+    //   options: ListenerQueryContextProviderOptions,
+    // ) {
+    //   if (
+    //     Token.isUnresolved(options.userOptions.loadBalancerArn) ||
+    //     Object.values(options.userOptions.loadBalancerTags ?? {}).some(
+    //       Token.isUnresolved,
+    //     ) ||
+    //     Token.isUnresolved(options.userOptions.listenerPort)
+    //   ) {
+    //     throw new Error(
+    //       "All arguments to look up a load balancer listener must be concrete (no Tokens)",
+    //     );
+    //   }
+    //   let cxschemaTags: cxschema.Tag[] | undefined;
+    //   if (options.userOptions.loadBalancerTags) {
+    //     cxschemaTags = mapTagMapToCxschema(options.userOptions.loadBalancerTags);
+    //   }
+    //   const props: cxapi.LoadBalancerListenerContextResponse =
+    //     ContextProvider.getValue(scope, {
+    //       provider: cxschema.ContextProvider.LOAD_BALANCER_LISTENER_PROVIDER,
+    //       props: {
+    //         listenerArn: options.listenerArn,
+    //         listenerPort: options.userOptions.listenerPort,
+    //         listenerProtocol: options.listenerProtocol,
+    //         loadBalancerArn: options.userOptions.loadBalancerArn,
+    //         loadBalancerTags: cxschemaTags,
+    //         loadBalancerType: options.loadBalancerType,
+    //       } as cxschema.LoadBalancerListenerContextQuery,
+    //       dummyValue: {
+    //         // eslint-disable-next-line @cdklabs/no-literal-partition
+    //         listenerArn: `arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/${options.loadBalancerType}/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2`,
+    //         listenerPort: 80,
+    //         securityGroupIds: ["sg-123456789012"],
+    //       } as cxapi.LoadBalancerListenerContextResponse,
+    //     }).value;
+    //   return props;
+    // }
+    /**
+     * Strongly typed outputs
+     */
+    get listenerOutputs() {
+        return {
+            listenerArn: this.listenerArn,
+        };
+    }
+    get outputs() {
+        return this.listenerOutputs;
+    }
+    constructor(scope, id, additionalProps) {
+        super(scope, id);
+        /**
+         * Attributes set on this listener
+         */
+        this.attributes = {};
+        const resource = new provider_aws_1.lbListener.LbListener(this, "Resource", {
+            // Reverse CFN LoadBalancerAttributes to Terraform Resource properties
+            // https://github.com/hashicorp/terraform-provider-aws/blob/v5.88.0/internal/service/elbv2/listener.go#L880
+            // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancingv2-listener-listenerattribute.html
+            // notice: https://github.com/hashicorp/terraform-provider-aws/issues/40986
+            routingHttpRequestXAmznMtlsClientcertHeaderName: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPRequestXAmznMtlsClientcertHeaderName),
+            routingHttpRequestXAmznMtlsClientcertIssuerHeaderName: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPRequestXAmznMtlsClientcertIssuerHeaderName),
+            routingHttpRequestXAmznMtlsClientcertLeafHeaderName: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPRequestXAmznMtlsClientcertLeafHeaderName),
+            routingHttpRequestXAmznMtlsClientcertSerialNumberHeaderName: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPRequestXAmznMtlsClientcertSerialNumberHeaderName),
+            routingHttpRequestXAmznMtlsClientcertSubjectHeaderName: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPRequestXAmznMtlsClientcertSubjectHeaderName),
+            routingHttpRequestXAmznMtlsClientcertValidityHeaderName: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPRequestXAmznMtlsClientcertValidityHeaderName),
+            routingHttpRequestXAmznTlsCipherSuiteHeaderName: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPRequestXAmznTlsCipherSuiteHeaderName),
+            routingHttpRequestXAmznTlsVersionHeaderName: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPRequestXAmznTlsVersionHeaderName),
+            routingHttpResponseAccessControlAllowCredentialsHeaderValue: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPResponseAccessControlAllowCredentialsHeaderValue),
+            routingHttpResponseAccessControlAllowHeadersHeaderValue: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPResponseAccessControlAllowHeadersHeaderValue),
+            routingHttpResponseAccessControlAllowMethodsHeaderValue: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPResponseAccessControlAllowMethodsHeaderValue),
+            routingHttpResponseAccessControlAllowOriginHeaderValue: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPResponseAccessControlAllowOriginHeaderValue),
+            routingHttpResponseAccessControlExposeHeadersHeaderValue: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPResponseAccessControlExposeHeadersHeaderValue),
+            routingHttpResponseAccessControlMaxAgeHeaderValue: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPResponseAccessControlMaxAgeHeaderValue),
+            routingHttpResponseContentSecurityPolicyHeaderValue: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPResponseContentSecurityPolicyHeaderValue),
+            routingHttpResponseServerEnabled: this.lazyBoolAttr(util_1.ListenerAttribute.routingHTTPResponseServerEnabled),
+            routingHttpResponseStrictTransportSecurityHeaderValue: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPResponseStrictTransportSecurityHeaderValue),
+            routingHttpResponseXContentTypeOptionsHeaderValue: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPResponseXContentTypeOptionsHeaderValue),
+            routingHttpResponseXFrameOptionsHeaderValue: this.lazyStringAttr(util_1.ListenerAttribute.routingHTTPResponseXFrameOptionsHeaderValue),
+            tcpIdleTimeoutSeconds: this.lazyNumberAttr(util_1.ListenerAttribute.tcpIdleTimeoutSeconds),
+            ...additionalProps,
+            defaultAction: cdktf_1.Lazy.anyValue({
+                produce: () => {
+                    const rendered = this.defaultAction?.renderActions() ?? [];
+                    return rendered.map(provider_aws_1.lbListener.lbListenerDefaultActionToTerraform);
+                },
+            }),
+            // listenerAttributes: Lazy.anyValue(
+            //   { produce: () => renderAttributes(this.attributes) },
+            //   { omitEmptyArray: true },
+            // ),
+        });
+        this.listenerArn = resource.arn;
+        this.node.addValidation({ validate: () => this.validateListener() });
+    }
+    /**
+     * Set a non-standard attribute on the listener
+     *
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancingv2-listener-listenerattribute.html
+     */
+    setAttribute(key, value) {
+        this.attributes[key] = value;
+    }
+    /**
+     * Remove an attribute from the listener
+     */
+    removeAttribute(key) {
+        this.setAttribute(key, undefined);
+    }
+    lazyStringAttr(key) {
+        return cdktf_1.Lazy.stringValue({
+            produce: () => this.attributes[key],
+        });
+    }
+    lazyBoolAttr(key) {
+        return cdktf_1.Lazy.anyValue({
+            produce: () => (0, util_1.lookupBoolAttribute)(this.attributes, key),
+        });
+    }
+    lazyNumberAttr(key) {
+        return cdktf_1.Lazy.numberValue({
+            produce: () => (0, util_1.lookupNumberAttribute)(this.attributes, key),
+        });
+    }
+    /**
+     * Validate this listener
+     */
+    validateListener() {
+        if (!this.defaultAction) {
+            return [
+                "Listener needs at least one default action or target group (call addTargetGroups or addAction)",
+            ];
+        }
+        return [];
+    }
+    /**
+     * Configure the default action
+     *
+     * @internal
+     */
+    _setDefaultAction(action) {
+        // It might make sense to 'throw' here.
+        //
+        // However, programs may already exist out there which configured an action twice,
+        // in which case the second action accidentally overwrite the initial action, and in some
+        // way ended up with a program that did what the author intended. If we were to add throw now,
+        // the previously working program would be broken.
+        //
+        // Instead, signal this through a warning.
+        // @deprecate: upon the next major version bump, replace this with a `throw`
+        if (this.defaultAction) {
+            // "@aws-cdk/aws-elbv2:listenerExistingDefaultActionReplaced",
+            cdktf_1.Annotations.of(this).addWarning("A default Action already existed on this Listener and was replaced. Configure exactly one default Action.");
+        }
+        this.defaultAction = action;
+    }
+}
+exports.BaseListener = BaseListener;
+_a = JSII_RTTI_SYMBOL_1;
+BaseListener[_a] = { fqn: "terraconstructs.aws.compute.BaseListener", version: "0.0.12" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-listener.js","sourceRoot":"","sources":["../../../../src/aws/compute/lb-shared/base-listener.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancingv2/lib/shared/base-listener.ts\n\nimport { lbListener as tfListener } from \"@cdktf/provider-aws\";\nimport {\n  Annotations,\n  // ContextProvider,\n  Lazy,\n  // Token,\n} from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  LoadBalancerType,\n  LoadBalancerListenerProtocol,\n} from \"./grid-lookup-types\";\nimport { LbListenerConfig } from \"./lb-listener-config.generated\";\nimport { IListenerAction } from \"./listener-action\";\nimport {\n  Attributes,\n  // mapTagMapToCxschema,\n  // renderAttributes,\n  ListenerAttribute as Attribute,\n  lookupBoolAttribute,\n  lookupNumberAttribute,\n} from \"./util\";\nimport { IAwsConstruct, AwsConstructBase } from \"../../aws-construct\";\n/**\n * Options for listener lookup\n */\nexport interface BaseListenerLookupOptions {\n  /**\n   * Filter listeners by associated load balancer arn\n   * @default - does not filter by load balancer arn\n   */\n  readonly loadBalancerArn?: string;\n\n  /**\n   * Filter listeners by associated load balancer tags\n   * @default - does not filter by load balancer tags\n   */\n  readonly loadBalancerTags?: Record<string, string>;\n\n  /**\n   * Filter listeners by listener port\n   * @default - does not filter by listener port\n   */\n  readonly listenerPort?: number;\n}\n\n/**\n * Options for querying the load balancer listener context provider\n * @internal\n */\nexport interface ListenerQueryContextProviderOptions {\n  /**\n   * User's provided options\n   */\n  readonly userOptions: BaseListenerLookupOptions;\n\n  /**\n   * Type of load balancer expected\n   */\n  readonly loadBalancerType: LoadBalancerType;\n\n  /**\n   * ARN of the listener to look up\n   * @default - does not filter by listener arn\n   */\n  readonly listenerArn?: string;\n\n  /**\n   * Optional protocol of the listener to look up\n   */\n  readonly listenerProtocol?: LoadBalancerListenerProtocol;\n}\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface ListenerOutputs {\n  /**\n   * ARN of the listener\n   * @attribute\n   */\n  readonly listenerArn: string;\n}\n\n/**\n * Base interface for listeners\n */\nexport interface IListener extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly listenerOutputs: ListenerOutputs;\n  /**\n   * ARN of the listener\n   * @attribute\n   */\n  readonly listenerArn: string;\n}\n\n/**\n * Base class for listeners\n */\nexport abstract class BaseListener\n  extends AwsConstructBase\n  implements IListener\n{\n  // /**\n  //  * Queries the load balancer listener context provider for load balancer\n  //  * listener info.\n  //  * @internal\n  //  */\n  // protected static _queryContextProvider(\n  //   scope: Construct,\n  //   options: ListenerQueryContextProviderOptions,\n  // ) {\n  //   if (\n  //     Token.isUnresolved(options.userOptions.loadBalancerArn) ||\n  //     Object.values(options.userOptions.loadBalancerTags ?? {}).some(\n  //       Token.isUnresolved,\n  //     ) ||\n  //     Token.isUnresolved(options.userOptions.listenerPort)\n  //   ) {\n  //     throw new Error(\n  //       \"All arguments to look up a load balancer listener must be concrete (no Tokens)\",\n  //     );\n  //   }\n\n  //   let cxschemaTags: cxschema.Tag[] | undefined;\n  //   if (options.userOptions.loadBalancerTags) {\n  //     cxschemaTags = mapTagMapToCxschema(options.userOptions.loadBalancerTags);\n  //   }\n\n  //   const props: cxapi.LoadBalancerListenerContextResponse =\n  //     ContextProvider.getValue(scope, {\n  //       provider: cxschema.ContextProvider.LOAD_BALANCER_LISTENER_PROVIDER,\n  //       props: {\n  //         listenerArn: options.listenerArn,\n  //         listenerPort: options.userOptions.listenerPort,\n  //         listenerProtocol: options.listenerProtocol,\n  //         loadBalancerArn: options.userOptions.loadBalancerArn,\n  //         loadBalancerTags: cxschemaTags,\n  //         loadBalancerType: options.loadBalancerType,\n  //       } as cxschema.LoadBalancerListenerContextQuery,\n  //       dummyValue: {\n  //         // eslint-disable-next-line @cdklabs/no-literal-partition\n  //         listenerArn: `arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/${options.loadBalancerType}/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2`,\n  //         listenerPort: 80,\n  //         securityGroupIds: [\"sg-123456789012\"],\n  //       } as cxapi.LoadBalancerListenerContextResponse,\n  //     }).value;\n\n  //   return props;\n  // }\n\n  /**\n   * Strongly typed outputs\n   */\n  public get listenerOutputs(): ListenerOutputs {\n    return {\n      listenerArn: this.listenerArn,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.listenerOutputs;\n  }\n\n  /**\n   * @attribute\n   */\n  public readonly listenerArn: string;\n\n  /**\n   * Attributes set on this listener\n   */\n  private readonly attributes: Attributes = {};\n\n  private defaultAction?: IListenerAction;\n\n  constructor(scope: Construct, id: string, additionalProps: LbListenerConfig) {\n    super(scope, id);\n\n    const resource = new tfListener.LbListener(this, \"Resource\", {\n      // Reverse CFN LoadBalancerAttributes to Terraform Resource properties\n      // https://github.com/hashicorp/terraform-provider-aws/blob/v5.88.0/internal/service/elbv2/listener.go#L880\n      // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancingv2-listener-listenerattribute.html\n      // notice: https://github.com/hashicorp/terraform-provider-aws/issues/40986\n      routingHttpRequestXAmznMtlsClientcertHeaderName: this.lazyStringAttr(\n        Attribute.routingHTTPRequestXAmznMtlsClientcertHeaderName,\n      ),\n      routingHttpRequestXAmznMtlsClientcertIssuerHeaderName:\n        this.lazyStringAttr(\n          Attribute.routingHTTPRequestXAmznMtlsClientcertIssuerHeaderName,\n        ),\n      routingHttpRequestXAmznMtlsClientcertLeafHeaderName: this.lazyStringAttr(\n        Attribute.routingHTTPRequestXAmznMtlsClientcertLeafHeaderName,\n      ),\n      routingHttpRequestXAmznMtlsClientcertSerialNumberHeaderName:\n        this.lazyStringAttr(\n          Attribute.routingHTTPRequestXAmznMtlsClientcertSerialNumberHeaderName,\n        ),\n      routingHttpRequestXAmznMtlsClientcertSubjectHeaderName:\n        this.lazyStringAttr(\n          Attribute.routingHTTPRequestXAmznMtlsClientcertSubjectHeaderName,\n        ),\n      routingHttpRequestXAmznMtlsClientcertValidityHeaderName:\n        this.lazyStringAttr(\n          Attribute.routingHTTPRequestXAmznMtlsClientcertValidityHeaderName,\n        ),\n      routingHttpRequestXAmznTlsCipherSuiteHeaderName: this.lazyStringAttr(\n        Attribute.routingHTTPRequestXAmznTlsCipherSuiteHeaderName,\n      ),\n      routingHttpRequestXAmznTlsVersionHeaderName: this.lazyStringAttr(\n        Attribute.routingHTTPRequestXAmznTlsVersionHeaderName,\n      ),\n      routingHttpResponseAccessControlAllowCredentialsHeaderValue:\n        this.lazyStringAttr(\n          Attribute.routingHTTPResponseAccessControlAllowCredentialsHeaderValue,\n        ),\n      routingHttpResponseAccessControlAllowHeadersHeaderValue:\n        this.lazyStringAttr(\n          Attribute.routingHTTPResponseAccessControlAllowHeadersHeaderValue,\n        ),\n      routingHttpResponseAccessControlAllowMethodsHeaderValue:\n        this.lazyStringAttr(\n          Attribute.routingHTTPResponseAccessControlAllowMethodsHeaderValue,\n        ),\n      routingHttpResponseAccessControlAllowOriginHeaderValue:\n        this.lazyStringAttr(\n          Attribute.routingHTTPResponseAccessControlAllowOriginHeaderValue,\n        ),\n      routingHttpResponseAccessControlExposeHeadersHeaderValue:\n        this.lazyStringAttr(\n          Attribute.routingHTTPResponseAccessControlExposeHeadersHeaderValue,\n        ),\n      routingHttpResponseAccessControlMaxAgeHeaderValue: this.lazyStringAttr(\n        Attribute.routingHTTPResponseAccessControlMaxAgeHeaderValue,\n      ),\n      routingHttpResponseContentSecurityPolicyHeaderValue: this.lazyStringAttr(\n        Attribute.routingHTTPResponseContentSecurityPolicyHeaderValue,\n      ),\n      routingHttpResponseServerEnabled: this.lazyBoolAttr(\n        Attribute.routingHTTPResponseServerEnabled,\n      ),\n      routingHttpResponseStrictTransportSecurityHeaderValue:\n        this.lazyStringAttr(\n          Attribute.routingHTTPResponseStrictTransportSecurityHeaderValue,\n        ),\n      routingHttpResponseXContentTypeOptionsHeaderValue: this.lazyStringAttr(\n        Attribute.routingHTTPResponseXContentTypeOptionsHeaderValue,\n      ),\n      routingHttpResponseXFrameOptionsHeaderValue: this.lazyStringAttr(\n        Attribute.routingHTTPResponseXFrameOptionsHeaderValue,\n      ),\n      tcpIdleTimeoutSeconds: this.lazyNumberAttr(\n        Attribute.tcpIdleTimeoutSeconds,\n      ),\n      ...additionalProps,\n      defaultAction: Lazy.anyValue({\n        produce: (): tfListener.LbListenerDefaultAction[] => {\n          const rendered = this.defaultAction?.renderActions() ?? [];\n          return rendered.map(tfListener.lbListenerDefaultActionToTerraform);\n        },\n      }),\n      // listenerAttributes: Lazy.anyValue(\n      //   { produce: () => renderAttributes(this.attributes) },\n      //   { omitEmptyArray: true },\n      // ),\n    });\n\n    this.listenerArn = resource.arn;\n    this.node.addValidation({ validate: () => this.validateListener() });\n  }\n\n  /**\n   * Set a non-standard attribute on the listener\n   *\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancingv2-listener-listenerattribute.html\n   */\n  public setAttribute(key: string, value: string | undefined) {\n    this.attributes[key] = value;\n  }\n\n  /**\n   * Remove an attribute from the listener\n   */\n  public removeAttribute(key: string) {\n    this.setAttribute(key, undefined);\n  }\n\n  private lazyStringAttr(key: string) {\n    return Lazy.stringValue({\n      produce: () => this.attributes[key],\n    });\n  }\n  private lazyBoolAttr(key: string) {\n    return Lazy.anyValue({\n      produce: () => lookupBoolAttribute(this.attributes, key),\n    });\n  }\n  private lazyNumberAttr(key: string) {\n    return Lazy.numberValue({\n      produce: () => lookupNumberAttribute(this.attributes, key),\n    });\n  }\n\n  /**\n   * Validate this listener\n   */\n  protected validateListener(): string[] {\n    if (!this.defaultAction) {\n      return [\n        \"Listener needs at least one default action or target group (call addTargetGroups or addAction)\",\n      ];\n    }\n    return [];\n  }\n\n  /**\n   * Configure the default action\n   *\n   * @internal\n   */\n  protected _setDefaultAction(action: IListenerAction) {\n    // It might make sense to 'throw' here.\n    //\n    // However, programs may already exist out there which configured an action twice,\n    // in which case the second action accidentally overwrite the initial action, and in some\n    // way ended up with a program that did what the author intended. If we were to add throw now,\n    // the previously working program would be broken.\n    //\n    // Instead, signal this through a warning.\n    // @deprecate: upon the next major version bump, replace this with a `throw`\n    if (this.defaultAction) {\n      // \"@aws-cdk/aws-elbv2:listenerExistingDefaultActionReplaced\",\n      Annotations.of(this).addWarning(\n        \"A default Action already existed on this Listener and was replaced. Configure exactly one default Action.\",\n      );\n    }\n\n    this.defaultAction = action;\n  }\n}\n"]}

package/lib/aws/compute/lb-shared/base-load-balancer.d.ts

@@ -0,0 +1,212 @@
+import { lb as tfLoadBalancer } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import * as ec2 from "../";
+import { LoadBalancerType } from "./grid-lookup-types";
+import { IAwsConstruct, AwsConstructBase, AwsConstructProps } from "../../aws-construct";
+import * as iam from "../../iam";
+import * as s3 from "../../storage";
+/**
+ * Shared properties of both Application and Network Load Balancers
+ */
+export interface BaseLoadBalancerProps extends AwsConstructProps {
+    /**
+     * Name of the load balancer
+     *
+     * @default - Automatically generated name.
+     */
+    readonly loadBalancerName?: string;
+    /**
+     * The VPC network to place the load balancer in
+     */
+    readonly vpc: ec2.IVpc;
+    /**
+     * Whether the load balancer has an internet-routable address
+     *
+     * @default false
+     */
+    readonly internetFacing?: boolean;
+    /**
+     * Which subnets place the load balancer in
+     *
+     * @default - the Vpc default strategy.
+     *
+     */
+    readonly vpcSubnets?: ec2.SubnetSelection;
+    /**
+     * Indicates whether deletion protection is enabled.
+     *
+     * @default false
+     */
+    readonly deletionProtection?: boolean;
+    /**
+     * Indicates whether cross-zone load balancing is enabled.
+     *
+     * @default - false for Network Load Balancers and true for Application Load Balancers.
+     * This can not be `false` for Application Load Balancers.
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancingv2-loadbalancer-loadbalancerattribute.html
+     */
+    readonly crossZoneEnabled?: boolean;
+    /**
+     * Indicates whether the load balancer blocks traffic through the Internet Gateway (IGW).
+     *
+     * @default - false for internet-facing load balancers and true for internal load balancers
+     */
+    readonly denyAllIgwTraffic?: boolean;
+}
+/**
+ * Outputs which may be registered for output via the Grid.
+ */
+export interface LoadBalancerV2Outputs {
+    /**
+     * The canonical hosted zone ID of this load balancer
+     *
+     * Example value: `Z2P70J7EXAMPLE`
+     *
+     * @attribute
+     */
+    readonly loadBalancerCanonicalHostedZoneId: string;
+    /**
+     * The DNS name of this load balancer
+     *
+     * Example value: `my-load-balancer-424835706.us-west-2.elb.amazonaws.com`
+     *
+     * @attribute
+     */
+    readonly loadBalancerDnsName: string;
+}
+export interface ILoadBalancerV2 extends IAwsConstruct {
+    /** Strongly typed outputs */
+    readonly loadBalancerV2Outputs: LoadBalancerV2Outputs;
+    /**
+     * The canonical hosted zone ID of this load balancer
+     *
+     * Example value: `Z2P70J7EXAMPLE`
+     *
+     * @attribute
+     */
+    readonly loadBalancerCanonicalHostedZoneId: string;
+    /**
+     * The DNS name of this load balancer
+     *
+     * Example value: `my-load-balancer-424835706.us-west-2.elb.amazonaws.com`
+     *
+     * @attribute
+     */
+    readonly loadBalancerDnsName: string;
+}
+/**
+ * Options for looking up load balancers
+ */
+export interface BaseLoadBalancerLookupOptions {
+    /**
+     * Find by load balancer's ARN
+     * @default - does not search by load balancer arn
+     */
+    readonly loadBalancerArn?: string;
+    /**
+     * Match load balancer tags.
+     * @default - does not match load balancers by tags
+     */
+    readonly loadBalancerTags?: Record<string, string>;
+}
+/**
+ * Options for query context provider
+ * @internal
+ */
+export interface LoadBalancerQueryContextProviderOptions {
+    /**
+     * User's lookup options
+     */
+    readonly userOptions: BaseLoadBalancerLookupOptions;
+    /**
+     * Type of load balancer
+     */
+    readonly loadBalancerType: LoadBalancerType;
+}
+/**
+ * Base class for both Application and Network Load Balancers
+ */
+export declare abstract class BaseLoadBalancer extends AwsConstructBase {
+    get loadBalancerV2Outputs(): LoadBalancerV2Outputs;
+    get outputs(): Record<string, any>;
+    /**
+     * The canonical hosted zone ID of this load balancer
+     *
+     * Example value: `Z2P70J7EXAMPLE`
+     *
+     * @attribute
+     */
+    readonly loadBalancerCanonicalHostedZoneId: string;
+    /**
+     * The DNS name of this load balancer
+     *
+     * Example value: `my-load-balancer-424835706.us-west-2.elb.amazonaws.com`
+     *
+     * @attribute
+     */
+    readonly loadBalancerDnsName: string;
+    /**
+     * The full name of this load balancer
+     *
+     * Example value: `app/my-load-balancer/50dc6c495c0c9188`
+     *
+     * @attribute
+     */
+    readonly loadBalancerFullName: string;
+    /**
+     * The name of this load balancer
+     *
+     * Example value: `my-load-balancer`
+     *
+     * @attribute
+     */
+    readonly loadBalancerName: string;
+    /**
+     * The ARN of this load balancer
+     *
+     * Example value: `arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-internal-load-balancer/50dc6c495c0c9188`
+     *
+     * @attribute
+     */
+    readonly loadBalancerArn: string;
+    /**
+     * @attribute
+     */
+    readonly loadBalancerSecurityGroups: string[];
+    /**
+     * The VPC this load balancer has been created in.
+     *
+     * This property is always defined (not `null` or `undefined`) for sub-classes of `BaseLoadBalancer`.
+     */
+    readonly vpc?: ec2.IVpc;
+    /**
+     * Attributes set on this load balancer
+     */
+    private readonly attributes;
+    private readonly physicalName;
+    constructor(scope: Construct, id: string, baseProps: BaseLoadBalancerProps, additionalProps: tfLoadBalancer.LbConfig);
+    /**
+     * Enable access logging for this load balancer.
+     *
+     * A region must be specified on the stack containing the load balancer; you cannot enable logging on
+     * environment-agnostic stacks. See https://docs.aws.amazon.com/cdk/latest/guide/environments.html
+     */
+    logAccessLogs(bucket: s3.IBucket, prefix?: string): void;
+    /**
+     * Set a non-standard attribute on the load balancer
+     *
+     * Use the dedicated logAccessLogs() method intead of setAttribute if you want to setup access logging.
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/application-load-balancers.html#load-balancer-attributes
+     */
+    setAttribute(key: string, value: string | undefined): void;
+    /**
+     * Remove an attribute from the load balancer
+     */
+    removeAttribute(key: string): void;
+    protected lazyStringAttr(key: string): string;
+    protected lazyBoolAttr(key: string): import("cdktf").IResolvable;
+    protected lazyNumberAttr(key: string): number;
+    protected resourcePolicyPrincipal(): iam.IPrincipal;
+    protected validateLoadBalancer(): string[];
+}