terraconstructs 0.0.8

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

@@ -0,0 +1,160 @@
+import { cloudfrontDistribution } from "@cdktf/provider-aws";
+import { Duration } from "../../";
+import { IBucket } from "../storage";
+/**
+ * Represents the concept of a CloudFront Origin.
+ * You provide one or more origins when creating a Distribution.
+ */
+export interface IOrigin {
+    /**
+     * The method called when a given Origin is added
+     * (for the first time) to a Distribution.
+     */
+    render(id: string): cloudfrontDistribution.CloudfrontDistributionOrigin;
+}
+/**
+ * Options to define an Origin.
+ */
+export interface OriginOptions {
+    /**
+     * The number of seconds that CloudFront waits when trying to establish a connection to the origin.
+     * Valid values are 1-10 seconds, inclusive.
+     *
+     * @default Duration.seconds(10)
+     */
+    readonly connectionTimeout?: Duration;
+    /**
+     * The number of times that CloudFront attempts to connect to the origin; valid values are 1, 2, or 3 attempts.
+     *
+     * @default 3
+     */
+    readonly connectionAttempts?: number;
+    /**
+     * A list of HTTP header names and values that CloudFront adds to requests it sends to the origin.
+     *
+     * @default {}
+     */
+    readonly customHeaders?: Record<string, string>;
+}
+/**
+ * Properties to define an Origin.
+ */
+export interface OriginProps extends OriginOptions {
+    /**
+     * An optional path that CloudFront appends to the origin domain name when CloudFront requests content from the origin.
+     * Must begin, but not end, with '/' (e.g., '/production/images').
+     *
+     * @default '/'
+     */
+    readonly originPath?: string;
+}
+/**
+ * Defines what protocols CloudFront will use to connect to an origin.
+ */
+export declare enum OriginProtocolPolicy {
+    /** Connect on HTTP only */
+    HTTP_ONLY = "http-only",
+    /** Connect with the same protocol as the viewer */
+    MATCH_VIEWER = "match-viewer",
+    /** Connect on HTTPS only */
+    HTTPS_ONLY = "https-only"
+}
+export declare enum OriginSslPolicy {
+    SSL_V3 = "SSLv3",
+    TLS_V1 = "TLSv1",
+    TLS_V1_1 = "TLSv1.1",
+    TLS_V1_2 = "TLSv1.2"
+}
+/**
+ * Represents a distribution origin, that describes the Amazon S3 bucket, HTTP server (for example, a web server),
+ * Amazon MediaStore, or other server from which CloudFront gets your files.
+ */
+export declare abstract class OriginBase implements IOrigin {
+    private readonly domainName;
+    private readonly originPath?;
+    private readonly connectionTimeout?;
+    private readonly connectionAttempts?;
+    private readonly customHeaders?;
+    protected constructor(domainName: string, props?: OriginProps);
+    /**
+     * Called internally by the Distribution to render the origin.
+     */
+    render(originId: string): cloudfrontDistribution.CloudfrontDistributionOrigin;
+    protected renderS3OriginConfig(): cloudfrontDistribution.CloudfrontDistributionOriginS3OriginConfig | undefined;
+    protected renderCustomOriginConfig(): cloudfrontDistribution.CloudfrontDistributionOriginCustomOriginConfig | undefined;
+    private renderCustomHeaders;
+    /**
+     * If the path is defined, it must start with a '/' and not end with a '/'.
+     * This method takes in the originPath, and returns it back (if undefined) or adds/removes the '/' as appropriate.
+     */
+    private validateOriginPath;
+}
+/**
+ * An Origin that is backed by an S3 bucket.
+ *
+ * If the bucket is configured for website hosting, this origin will be configured to use the bucket as an
+ * HTTP server origin and will use the bucket's configured website redirects and error handling. Otherwise,
+ * the origin is created as a bucket origin and will use CloudFront's redirect and error handling.
+ */
+export declare class S3Origin implements IOrigin {
+    private readonly origin;
+    constructor(bucket: IBucket, props?: OriginProps);
+    render(originId: string): cloudfrontDistribution.CloudfrontDistributionOrigin;
+}
+/**
+ * Properties for an Origin backed by an S3 website-configured bucket, load balancer, or custom HTTP server.
+ */
+export interface HttpOriginProps extends OriginProps {
+    /**
+     * Specifies the protocol (HTTP or HTTPS) that CloudFront uses to connect to the origin.
+     *
+     * @default OriginProtocolPolicy.HTTPS_ONLY
+     */
+    readonly protocolPolicy?: OriginProtocolPolicy;
+    /**
+     * The SSL versions to use when interacting with the origin.
+     *
+     * @default OriginSslPolicy.TLS_V1_2
+     */
+    readonly originSslProtocols?: OriginSslPolicy[];
+    /**
+     * The HTTP port that CloudFront uses to connect to the origin.
+     *
+     * @default 80
+     */
+    readonly httpPort?: number;
+    /**
+     * The HTTPS port that CloudFront uses to connect to the origin.
+     *
+     * @default 443
+     */
+    readonly httpsPort?: number;
+    /**
+     * Specifies how long, in seconds, CloudFront waits for a response from the origin, also known as the origin response timeout.
+     * The valid range is from 1 to 180 seconds, inclusive.
+     *
+     * Note that values over 60 seconds are possible only after a limit increase request for the origin response timeout quota
+     * has been approved in the target account; otherwise, values over 60 seconds will produce an error at deploy time.
+     *
+     * @default Duration.seconds(30)
+     */
+    readonly readTimeout?: Duration;
+    /**
+     * Specifies how long, in seconds, CloudFront persists its connection to the origin.
+     * The valid range is from 1 to 180 seconds, inclusive.
+     *
+     * Note that values over 60 seconds are possible only after a limit increase request for the origin response timeout quota
+     * has been approved in the target account; otherwise, values over 60 seconds will produce an error at deploy time.
+     *
+     * @default Duration.seconds(5)
+     */
+    readonly keepaliveTimeout?: Duration;
+}
+/**
+ * An Origin for an HTTP server or S3 bucket configured for website hosting.
+ */
+export declare class HttpOrigin extends OriginBase {
+    private readonly props;
+    constructor(domainName: string, props?: HttpOriginProps);
+    protected renderCustomOriginConfig(): cloudfrontDistribution.CloudfrontDistributionOriginCustomOriginConfig | undefined;
+}

package/lib/aws/edge/origin.js

@@ -0,0 +1,245 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpOrigin = exports.S3Origin = exports.OriginBase = exports.OriginSslPolicy = exports.OriginProtocolPolicy = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdktf_1 = require("cdktf");
+/**
+ * Defines what protocols CloudFront will use to connect to an origin.
+ */
+var OriginProtocolPolicy;
+(function (OriginProtocolPolicy) {
+    /** Connect on HTTP only */
+    OriginProtocolPolicy["HTTP_ONLY"] = "http-only";
+    /** Connect with the same protocol as the viewer */
+    OriginProtocolPolicy["MATCH_VIEWER"] = "match-viewer";
+    /** Connect on HTTPS only */
+    OriginProtocolPolicy["HTTPS_ONLY"] = "https-only";
+})(OriginProtocolPolicy || (exports.OriginProtocolPolicy = OriginProtocolPolicy = {}));
+var OriginSslPolicy;
+(function (OriginSslPolicy) {
+    OriginSslPolicy["SSL_V3"] = "SSLv3";
+    OriginSslPolicy["TLS_V1"] = "TLSv1";
+    OriginSslPolicy["TLS_V1_1"] = "TLSv1.1";
+    OriginSslPolicy["TLS_V1_2"] = "TLSv1.2";
+})(OriginSslPolicy || (exports.OriginSslPolicy = OriginSslPolicy = {}));
+/**
+ * Represents a distribution origin, that describes the Amazon S3 bucket, HTTP server (for example, a web server),
+ * Amazon MediaStore, or other server from which CloudFront gets your files.
+ */
+class OriginBase {
+    constructor(domainName, props = {}) {
+        validateIntInRangeOrUndefined("connectionTimeout", 1, 10, props.connectionTimeout?.toSeconds());
+        validateIntInRangeOrUndefined("connectionAttempts", 1, 3, props.connectionAttempts, false);
+        validateCustomHeaders(props.customHeaders);
+        this.domainName = domainName;
+        this.originPath = this.validateOriginPath(props.originPath);
+        this.connectionTimeout = props.connectionTimeout;
+        this.connectionAttempts = props.connectionAttempts;
+        this.customHeaders = props.customHeaders;
+    }
+    /**
+     * Called internally by the Distribution to render the origin.
+     */
+    render(originId) {
+        const s3OriginConfig = this.renderS3OriginConfig();
+        const customOriginConfig = this.renderCustomOriginConfig();
+        if (!s3OriginConfig && !customOriginConfig) {
+            throw new Error("Subclass must override and provide either s3OriginConfig or customOriginConfig");
+        }
+        return {
+            originId,
+            domainName: this.domainName,
+            originPath: this.originPath,
+            connectionAttempts: this.connectionAttempts,
+            connectionTimeout: this.connectionTimeout?.toSeconds(),
+            customHeader: this.renderCustomHeaders(),
+            s3OriginConfig,
+            customOriginConfig,
+        };
+    }
+    // Overridden by sub-classes to provide S3 origin config.
+    renderS3OriginConfig() {
+        return undefined;
+    }
+    // Overridden by sub-classes to provide custom origin config.
+    renderCustomOriginConfig() {
+        return undefined;
+    }
+    renderCustomHeaders() {
+        if (!this.customHeaders ||
+            Object.entries(this.customHeaders).length === 0) {
+            return undefined;
+        }
+        return Object.entries(this.customHeaders).map(([name, value]) => {
+            return { name, value };
+        });
+    }
+    /**
+     * If the path is defined, it must start with a '/' and not end with a '/'.
+     * This method takes in the originPath, and returns it back (if undefined) or adds/removes the '/' as appropriate.
+     */
+    validateOriginPath(originPath) {
+        if (cdktf_1.Token.isUnresolved(originPath)) {
+            return originPath;
+        }
+        if (originPath === undefined) {
+            return undefined;
+        }
+        let path = originPath;
+        if (!path.startsWith("/")) {
+            path = "/" + path;
+        }
+        if (path.endsWith("/")) {
+            path = path.slice(0, -1);
+        }
+        return path;
+    }
+}
+exports.OriginBase = OriginBase;
+_a = JSII_RTTI_SYMBOL_1;
+OriginBase[_a] = { fqn: "terraconstructs.aws.edge.OriginBase", version: "0.0.8" };
+/**
+ * Throws an error if a value is defined and not an integer or not in a range.
+ */
+function validateIntInRangeOrUndefined(name, min, max, value, isDuration = true) {
+    if (value === undefined) {
+        return;
+    }
+    if (!Number.isInteger(value) || value < min || value > max) {
+        const seconds = isDuration ? " seconds" : "";
+        throw new Error(`${name}: Must be an int between ${min} and ${max}${seconds} (inclusive); received ${value}.`);
+    }
+}
+/**
+ * Throws an error if custom header assignment is prohibited by CloudFront.
+ * @link: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/add-origin-custom-headers.html#add-origin-custom-headers-denylist
+ */
+function validateCustomHeaders(customHeaders) {
+    if (!customHeaders || Object.entries(customHeaders).length === 0) {
+        return;
+    }
+    const customHeaderKeys = Object.keys(customHeaders);
+    const prohibitedHeaderKeys = [
+        "Cache-Control",
+        "Connection",
+        "Content-Length",
+        "Cookie",
+        "Host",
+        "If-Match",
+        "If-Modified-Since",
+        "If-None-Match",
+        "If-Range",
+        "If-Unmodified-Since",
+        "Max-Forwards",
+        "Pragma",
+        "Proxy-Authorization",
+        "Proxy-Connection",
+        "Range",
+        "Request-Range",
+        "TE",
+        "Trailer",
+        "Transfer-Encoding",
+        "Upgrade",
+        "Via",
+        "X-Real-Ip",
+    ];
+    const prohibitedHeaderKeyPrefixes = ["X-Amz-", "X-Edge-"];
+    const prohibitedHeadersKeysMatches = customHeaderKeys.filter((customKey) => {
+        return prohibitedHeaderKeys
+            .map((prohibitedKey) => prohibitedKey.toLowerCase())
+            .includes(customKey.toLowerCase());
+    });
+    const prohibitedHeaderPrefixMatches = customHeaderKeys.filter((customKey) => {
+        return prohibitedHeaderKeyPrefixes.some((prohibitedKeyPrefix) => customKey.toLowerCase().startsWith(prohibitedKeyPrefix.toLowerCase()));
+    });
+    if (prohibitedHeadersKeysMatches.length !== 0) {
+        throw new Error(`The following headers cannot be configured as custom origin headers: ${prohibitedHeadersKeysMatches.join(", ")}`);
+    }
+    if (prohibitedHeaderPrefixMatches.length !== 0) {
+        throw new Error(`The following headers cannot be used as prefixes for custom origin headers: ${prohibitedHeaderPrefixMatches.join(", ")}`);
+    }
+}
+// ref: https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-cloudfront-origins/lib/s3-origin.ts
+/**
+ * An Origin that is backed by an S3 bucket.
+ *
+ * If the bucket is configured for website hosting, this origin will be configured to use the bucket as an
+ * HTTP server origin and will use the bucket's configured website redirects and error handling. Otherwise,
+ * the origin is created as a bucket origin and will use CloudFront's redirect and error handling.
+ */
+class S3Origin {
+    constructor(bucket, props = {}) {
+        this.origin = bucket.isWebsite()
+            ? new HttpOrigin(bucket.bucketOutputs.websiteDomainName, {
+                protocolPolicy: OriginProtocolPolicy.HTTP_ONLY, // S3 only supports HTTP for website buckets
+                ...props,
+            })
+            : new S3BucketOrigin(bucket, props);
+    }
+    render(originId) {
+        return this.origin.render(originId);
+    }
+}
+exports.S3Origin = S3Origin;
+_b = JSII_RTTI_SYMBOL_1;
+S3Origin[_b] = { fqn: "terraconstructs.aws.edge.S3Origin", version: "0.0.8" };
+/**
+ * An Origin specific to a S3 bucket (not configured for website hosting).
+ *
+ * Contains additional logic around bucket permissions and origin access identities.
+ */
+class S3BucketOrigin extends OriginBase {
+    constructor(bucket, props) {
+        super(bucket.bucketOutputs.regionalDomainName, props);
+        this.bucket = bucket;
+        if (!this.bucket.bucketOutputs.originAccessIdentity) {
+            throw new Error("The bucket must have an origin access identity to be used as a CloudFront origin.");
+        }
+    }
+    renderS3OriginConfig() {
+        return {
+            // constructor throws if undefined, so this is safe?
+            originAccessIdentity: this.bucket.bucketOutputs.originAccessIdentity,
+        };
+    }
+}
+/**
+ * An Origin for an HTTP server or S3 bucket configured for website hosting.
+ */
+class HttpOrigin extends OriginBase {
+    constructor(domainName, props = {}) {
+        super(domainName, props);
+        this.props = props;
+        validateSecondsInRangeOrUndefined("readTimeout", 1, 180, props.readTimeout);
+        validateSecondsInRangeOrUndefined("keepaliveTimeout", 1, 180, props.keepaliveTimeout);
+    }
+    renderCustomOriginConfig() {
+        return {
+            originSslProtocols: this.props.originSslProtocols ?? [
+                OriginSslPolicy.TLS_V1_2,
+            ],
+            originProtocolPolicy: this.props.protocolPolicy ?? OriginProtocolPolicy.HTTPS_ONLY,
+            httpPort: this.props.httpPort ?? 80,
+            httpsPort: this.props.httpsPort ?? 443,
+            originReadTimeout: this.props.readTimeout?.toSeconds(),
+            originKeepaliveTimeout: this.props.keepaliveTimeout?.toSeconds(),
+        };
+    }
+}
+exports.HttpOrigin = HttpOrigin;
+_c = JSII_RTTI_SYMBOL_1;
+HttpOrigin[_c] = { fqn: "terraconstructs.aws.edge.HttpOrigin", version: "0.0.8" };
+/**
+ * Throws an error if a duration is defined and not an integer number of seconds within a range.
+ */
+function validateSecondsInRangeOrUndefined(name, min, max, duration) {
+    if (duration === undefined) {
+        return;
+    }
+    const value = duration.toSeconds();
+    if (!Number.isInteger(value) || value < min || value > max) {
+        throw new Error(`${name}: Must be an int between ${min} and ${max} seconds (inclusive); received ${value}.`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"origin.js","sourceRoot":"","sources":["../../../src/aws/edge/origin.ts"],"names":[],"mappings":"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","sourcesContent":["// ref: https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-cloudfront/lib/origin.ts\n\nimport { cloudfrontDistribution } from \"@cdktf/provider-aws\";\nimport { Token } from \"cdktf\";\nimport { Duration } from \"../../\";\nimport { IBucket } from \"../storage\";\n\n//TODO: Add support for failover configuration used for Origin Groups\n\n/**\n * Represents the concept of a CloudFront Origin.\n * You provide one or more origins when creating a Distribution.\n */\nexport interface IOrigin {\n  /**\n   * The method called when a given Origin is added\n   * (for the first time) to a Distribution.\n   */\n  render(id: string): cloudfrontDistribution.CloudfrontDistributionOrigin;\n}\n\n/**\n * Options to define an Origin.\n */\nexport interface OriginOptions {\n  /**\n   * The number of seconds that CloudFront waits when trying to establish a connection to the origin.\n   * Valid values are 1-10 seconds, inclusive.\n   *\n   * @default Duration.seconds(10)\n   */\n  readonly connectionTimeout?: Duration;\n\n  /**\n   * The number of times that CloudFront attempts to connect to the origin; valid values are 1, 2, or 3 attempts.\n   *\n   * @default 3\n   */\n  readonly connectionAttempts?: number;\n\n  /**\n   * A list of HTTP header names and values that CloudFront adds to requests it sends to the origin.\n   *\n   * @default {}\n   */\n  readonly customHeaders?: Record<string, string>;\n}\n\n/**\n * Properties to define an Origin.\n */\nexport interface OriginProps extends OriginOptions {\n  /**\n   * An optional path that CloudFront appends to the origin domain name when CloudFront requests content from the origin.\n   * Must begin, but not end, with '/' (e.g., '/production/images').\n   *\n   * @default '/'\n   */\n  readonly originPath?: string;\n}\n\n/**\n * Defines what protocols CloudFront will use to connect to an origin.\n */\nexport enum OriginProtocolPolicy {\n  /** Connect on HTTP only */\n  HTTP_ONLY = \"http-only\",\n  /** Connect with the same protocol as the viewer */\n  MATCH_VIEWER = \"match-viewer\",\n  /** Connect on HTTPS only */\n  HTTPS_ONLY = \"https-only\",\n}\n\nexport enum OriginSslPolicy {\n  SSL_V3 = \"SSLv3\",\n  TLS_V1 = \"TLSv1\",\n  TLS_V1_1 = \"TLSv1.1\",\n  TLS_V1_2 = \"TLSv1.2\",\n}\n\n/**\n * Represents a distribution origin, that describes the Amazon S3 bucket, HTTP server (for example, a web server),\n * Amazon MediaStore, or other server from which CloudFront gets your files.\n */\nexport abstract class OriginBase implements IOrigin {\n  private readonly domainName: string;\n  private readonly originPath?: string;\n  private readonly connectionTimeout?: Duration;\n  private readonly connectionAttempts?: number;\n  private readonly customHeaders?: Record<string, string>;\n  protected constructor(domainName: string, props: OriginProps = {}) {\n    validateIntInRangeOrUndefined(\n      \"connectionTimeout\",\n      1,\n      10,\n      props.connectionTimeout?.toSeconds(),\n    );\n    validateIntInRangeOrUndefined(\n      \"connectionAttempts\",\n      1,\n      3,\n      props.connectionAttempts,\n      false,\n    );\n    validateCustomHeaders(props.customHeaders);\n\n    this.domainName = domainName;\n    this.originPath = this.validateOriginPath(props.originPath);\n    this.connectionTimeout = props.connectionTimeout;\n    this.connectionAttempts = props.connectionAttempts;\n    this.customHeaders = props.customHeaders;\n  }\n\n  /**\n   * Called internally by the Distribution to render the origin.\n   */\n  public render(\n    originId: string,\n  ): cloudfrontDistribution.CloudfrontDistributionOrigin {\n    const s3OriginConfig = this.renderS3OriginConfig();\n    const customOriginConfig = this.renderCustomOriginConfig();\n\n    if (!s3OriginConfig && !customOriginConfig) {\n      throw new Error(\n        \"Subclass must override and provide either s3OriginConfig or customOriginConfig\",\n      );\n    }\n\n    return {\n      originId,\n      domainName: this.domainName,\n      originPath: this.originPath,\n      connectionAttempts: this.connectionAttempts,\n      connectionTimeout: this.connectionTimeout?.toSeconds(),\n      customHeader: this.renderCustomHeaders(),\n      s3OriginConfig,\n      customOriginConfig,\n    };\n  }\n\n  // Overridden by sub-classes to provide S3 origin config.\n  protected renderS3OriginConfig():\n    | cloudfrontDistribution.CloudfrontDistributionOriginS3OriginConfig\n    | undefined {\n    return undefined;\n  }\n\n  // Overridden by sub-classes to provide custom origin config.\n  protected renderCustomOriginConfig():\n    | cloudfrontDistribution.CloudfrontDistributionOriginCustomOriginConfig\n    | undefined {\n    return undefined;\n  }\n\n  private renderCustomHeaders():\n    | cloudfrontDistribution.CloudfrontDistributionOriginCustomHeader[]\n    | undefined {\n    if (\n      !this.customHeaders ||\n      Object.entries(this.customHeaders).length === 0\n    ) {\n      return undefined;\n    }\n    return Object.entries(this.customHeaders).map(([name, value]) => {\n      return { name, value };\n    });\n  }\n\n  /**\n   * If the path is defined, it must start with a '/' and not end with a '/'.\n   * This method takes in the originPath, and returns it back (if undefined) or adds/removes the '/' as appropriate.\n   */\n  private validateOriginPath(originPath?: string): string | undefined {\n    if (Token.isUnresolved(originPath)) {\n      return originPath;\n    }\n    if (originPath === undefined) {\n      return undefined;\n    }\n    let path = originPath;\n    if (!path.startsWith(\"/\")) {\n      path = \"/\" + path;\n    }\n    if (path.endsWith(\"/\")) {\n      path = path.slice(0, -1);\n    }\n    return path;\n  }\n}\n\n/**\n * Throws an error if a value is defined and not an integer or not in a range.\n */\nfunction validateIntInRangeOrUndefined(\n  name: string,\n  min: number,\n  max: number,\n  value?: number,\n  isDuration: boolean = true,\n) {\n  if (value === undefined) {\n    return;\n  }\n  if (!Number.isInteger(value) || value < min || value > max) {\n    const seconds = isDuration ? \" seconds\" : \"\";\n    throw new Error(\n      `${name}: Must be an int between ${min} and ${max}${seconds} (inclusive); received ${value}.`,\n    );\n  }\n}\n\n/**\n * Throws an error if custom header assignment is prohibited by CloudFront.\n * @link: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/add-origin-custom-headers.html#add-origin-custom-headers-denylist\n */\nfunction validateCustomHeaders(customHeaders?: Record<string, string>) {\n  if (!customHeaders || Object.entries(customHeaders).length === 0) {\n    return;\n  }\n  const customHeaderKeys = Object.keys(customHeaders);\n  const prohibitedHeaderKeys = [\n    \"Cache-Control\",\n    \"Connection\",\n    \"Content-Length\",\n    \"Cookie\",\n    \"Host\",\n    \"If-Match\",\n    \"If-Modified-Since\",\n    \"If-None-Match\",\n    \"If-Range\",\n    \"If-Unmodified-Since\",\n    \"Max-Forwards\",\n    \"Pragma\",\n    \"Proxy-Authorization\",\n    \"Proxy-Connection\",\n    \"Range\",\n    \"Request-Range\",\n    \"TE\",\n    \"Trailer\",\n    \"Transfer-Encoding\",\n    \"Upgrade\",\n    \"Via\",\n    \"X-Real-Ip\",\n  ];\n  const prohibitedHeaderKeyPrefixes = [\"X-Amz-\", \"X-Edge-\"];\n\n  const prohibitedHeadersKeysMatches = customHeaderKeys.filter((customKey) => {\n    return prohibitedHeaderKeys\n      .map((prohibitedKey) => prohibitedKey.toLowerCase())\n      .includes(customKey.toLowerCase());\n  });\n  const prohibitedHeaderPrefixMatches = customHeaderKeys.filter((customKey) => {\n    return prohibitedHeaderKeyPrefixes.some((prohibitedKeyPrefix) =>\n      customKey.toLowerCase().startsWith(prohibitedKeyPrefix.toLowerCase()),\n    );\n  });\n\n  if (prohibitedHeadersKeysMatches.length !== 0) {\n    throw new Error(\n      `The following headers cannot be configured as custom origin headers: ${prohibitedHeadersKeysMatches.join(\", \")}`,\n    );\n  }\n  if (prohibitedHeaderPrefixMatches.length !== 0) {\n    throw new Error(\n      `The following headers cannot be used as prefixes for custom origin headers: ${prohibitedHeaderPrefixMatches.join(\", \")}`,\n    );\n  }\n}\n\n// ref: https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-cloudfront-origins/lib/s3-origin.ts\n\n/**\n * An Origin that is backed by an S3 bucket.\n *\n * If the bucket is configured for website hosting, this origin will be configured to use the bucket as an\n * HTTP server origin and will use the bucket's configured website redirects and error handling. Otherwise,\n * the origin is created as a bucket origin and will use CloudFront's redirect and error handling.\n */\nexport class S3Origin implements IOrigin {\n  private readonly origin: IOrigin;\n\n  constructor(bucket: IBucket, props: OriginProps = {}) {\n    this.origin = bucket.isWebsite()\n      ? new HttpOrigin(bucket.bucketOutputs.websiteDomainName, {\n          protocolPolicy: OriginProtocolPolicy.HTTP_ONLY, // S3 only supports HTTP for website buckets\n          ...props,\n        })\n      : new S3BucketOrigin(bucket, props);\n  }\n\n  public render(\n    originId: string,\n  ): cloudfrontDistribution.CloudfrontDistributionOrigin {\n    return this.origin.render(originId);\n  }\n}\n\n/**\n * An Origin specific to a S3 bucket (not configured for website hosting).\n *\n * Contains additional logic around bucket permissions and origin access identities.\n */\nclass S3BucketOrigin extends OriginBase {\n  constructor(\n    private readonly bucket: IBucket,\n    props: OriginProps,\n  ) {\n    super(bucket.bucketOutputs.regionalDomainName, props);\n    if (!this.bucket.bucketOutputs.originAccessIdentity) {\n      throw new Error(\n        \"The bucket must have an origin access identity to be used as a CloudFront origin.\",\n      );\n    }\n  }\n\n  protected renderS3OriginConfig():\n    | cloudfrontDistribution.CloudfrontDistributionOriginS3OriginConfig\n    | undefined {\n    return {\n      // constructor throws if undefined, so this is safe?\n      originAccessIdentity: this.bucket.bucketOutputs.originAccessIdentity!,\n    };\n  }\n}\n\n/**\n * Properties for an Origin backed by an S3 website-configured bucket, load balancer, or custom HTTP server.\n */\nexport interface HttpOriginProps extends OriginProps {\n  /**\n   * Specifies the protocol (HTTP or HTTPS) that CloudFront uses to connect to the origin.\n   *\n   * @default OriginProtocolPolicy.HTTPS_ONLY\n   */\n  readonly protocolPolicy?: OriginProtocolPolicy;\n\n  /**\n   * The SSL versions to use when interacting with the origin.\n   *\n   * @default OriginSslPolicy.TLS_V1_2\n   */\n  readonly originSslProtocols?: OriginSslPolicy[];\n\n  /**\n   * The HTTP port that CloudFront uses to connect to the origin.\n   *\n   * @default 80\n   */\n  readonly httpPort?: number;\n\n  /**\n   * The HTTPS port that CloudFront uses to connect to the origin.\n   *\n   * @default 443\n   */\n  readonly httpsPort?: number;\n\n  /**\n   * Specifies how long, in seconds, CloudFront waits for a response from the origin, also known as the origin response timeout.\n   * The valid range is from 1 to 180 seconds, inclusive.\n   *\n   * Note that values over 60 seconds are possible only after a limit increase request for the origin response timeout quota\n   * has been approved in the target account; otherwise, values over 60 seconds will produce an error at deploy time.\n   *\n   * @default Duration.seconds(30)\n   */\n  readonly readTimeout?: Duration;\n\n  /**\n   * Specifies how long, in seconds, CloudFront persists its connection to the origin.\n   * The valid range is from 1 to 180 seconds, inclusive.\n   *\n   * Note that values over 60 seconds are possible only after a limit increase request for the origin response timeout quota\n   * has been approved in the target account; otherwise, values over 60 seconds will produce an error at deploy time.\n   *\n   * @default Duration.seconds(5)\n   */\n  readonly keepaliveTimeout?: Duration;\n}\n\n/**\n * An Origin for an HTTP server or S3 bucket configured for website hosting.\n */\nexport class HttpOrigin extends OriginBase {\n  constructor(\n    domainName: string,\n    private readonly props: HttpOriginProps = {},\n  ) {\n    super(domainName, props);\n\n    validateSecondsInRangeOrUndefined(\"readTimeout\", 1, 180, props.readTimeout);\n    validateSecondsInRangeOrUndefined(\n      \"keepaliveTimeout\",\n      1,\n      180,\n      props.keepaliveTimeout,\n    );\n  }\n\n  protected renderCustomOriginConfig():\n    | cloudfrontDistribution.CloudfrontDistributionOriginCustomOriginConfig\n    | undefined {\n    return {\n      originSslProtocols: this.props.originSslProtocols ?? [\n        OriginSslPolicy.TLS_V1_2,\n      ],\n      originProtocolPolicy:\n        this.props.protocolPolicy ?? OriginProtocolPolicy.HTTPS_ONLY,\n      httpPort: this.props.httpPort ?? 80,\n      httpsPort: this.props.httpsPort ?? 443,\n      originReadTimeout: this.props.readTimeout?.toSeconds(),\n      originKeepaliveTimeout: this.props.keepaliveTimeout?.toSeconds(),\n    };\n  }\n}\n\n/**\n * Throws an error if a duration is defined and not an integer number of seconds within a range.\n */\nfunction validateSecondsInRangeOrUndefined(\n  name: string,\n  min: number,\n  max: number,\n  duration?: Duration,\n) {\n  if (duration === undefined) {\n    return;\n  }\n  const value = duration.toSeconds();\n  if (!Number.isInteger(value) || value < min || value > max) {\n    throw new Error(\n      `${name}: Must be an int between ${min} and ${max} seconds (inclusive); received ${value}.`,\n    );\n  }\n}\n"]}

package/lib/aws/encryption/alias.d.ts

@@ -0,0 +1,137 @@
+import { kmsAlias } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { AwsConstructProps, AwsConstructBase } from "../aws-construct";
+import { IKey, KeyOutputs } from "./key";
+import * as iam from "../iam";
+/**
+ * Outputs which may be registered for output via the Grid.
+ */
+export interface AliasOutputs {
+    /**
+     * The name of the alias.
+     *
+     * @attribute
+     */
+    readonly aliasName: string;
+    /**
+     * The Key to which the Alias refers.
+     *
+     * @attribute
+     */
+    readonly aliasTargetKey: KeyOutputs;
+}
+/**
+ * A KMS Key alias.
+ * An alias can be used in all places that expect a key.
+ */
+export interface IAlias extends IKey {
+    /** Strongly typed outputs */
+    readonly aliasOutputs: AliasOutputs;
+    /**
+     * The name of the alias.
+     *
+     * @attribute
+     */
+    readonly aliasName: string;
+    /**
+     * The Key to which the Alias refers.
+     *
+     * @attribute
+     */
+    readonly aliasTargetKey: IKey;
+}
+/**
+ * Construction properties for a KMS Key Alias object.
+ */
+export interface AliasProps extends AwsConstructProps {
+    /**
+     * The name of the alias. The name must start with alias followed by a
+     * forward slash, such as alias/. You can't specify aliases that begin with
+     * alias/AWS. These aliases are reserved.
+     */
+    readonly aliasName: string;
+    /**
+     * The ID of the key for which you are creating the alias. Specify the key's
+     * globally unique identifier or Amazon Resource Name (ARN). You can't
+     * specify another alias.
+     */
+    readonly targetKey: IKey;
+}
+declare abstract class AliasBase extends AwsConstructBase implements IAlias {
+    abstract readonly aliasName: string;
+    abstract readonly aliasTargetKey: IKey;
+    get aliasOutputs(): AliasOutputs;
+    get keyOutputs(): KeyOutputs;
+    get outputs(): Record<string, any>;
+    /**
+     * The ARN of the alias.
+     *
+     * @attribute
+     * @deprecated use `aliasArn` instead
+     */
+    get keyArn(): string;
+    /**
+     * The ARN of the alias.
+     *
+     * @attribute
+     */
+    get aliasArn(): string;
+    get keyId(): string;
+    addAlias(alias: string): Alias;
+    addToResourcePolicy(statement: iam.PolicyStatement, allowNoOp?: boolean): iam.AddToResourcePolicyResult;
+    grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;
+    grantDecrypt(grantee: iam.IGrantable): iam.Grant;
+    grantEncrypt(grantee: iam.IGrantable): iam.Grant;
+    grantEncryptDecrypt(grantee: iam.IGrantable): iam.Grant;
+    grantGenerateMac(grantee: iam.IGrantable): iam.Grant;
+    grantVerifyMac(grantee: iam.IGrantable): iam.Grant;
+}
+/**
+ * Properties of a reference to an existing KMS Alias
+ */
+export interface AliasAttributes {
+    /**
+     * Specifies the alias name. This value must begin with alias/ followed by a name (i.e. alias/ExampleAlias)
+     */
+    readonly aliasName: string;
+    /**
+     * The customer master key (CMK) to which the Alias refers.
+     */
+    readonly aliasTargetKey: IKey;
+}
+/**
+ * Defines a display name for a customer master key (CMK) in AWS Key Management
+ * Service (AWS KMS). Using an alias to refer to a key can help you simplify key
+ * management. For example, when rotating keys, you can just update the alias
+ * mapping instead of tracking and changing key IDs. For more information, see
+ * Working with Aliases in the AWS Key Management Service Developer Guide.
+ *
+ * You can also add an alias for a key by calling `key.addAlias(alias)`.
+ *
+ * @resource AWS::KMS::Alias
+ */
+export declare class Alias extends AliasBase {
+    /**
+     * Import an existing KMS Alias defined outside the CDK app.
+     *
+     * @param scope The parent creating construct (usually `this`).
+     * @param id The construct's name.
+     * @param attrs the properties of the referenced KMS Alias
+     */
+    static fromAliasAttributes(scope: Construct, id: string, attrs: AliasAttributes): IAlias;
+    /**
+     * Import an existing KMS Alias defined outside the CDK app, by the alias name. This method should be used
+     * instead of 'fromAliasAttributes' when the underlying KMS Key ARN is not available.
+     * This Alias will not have a direct reference to the KMS Key, so addAlias and grant* methods are not supported.
+     *
+     * @param scope The parent creating construct (usually `this`).
+     * @param id The construct's name.
+     * @param aliasName The full name of the KMS Alias (e.g., 'alias/aws/s3', 'alias/myKeyAlias').
+     */
+    static fromAliasName(scope: Construct, id: string, aliasName: string): IAlias;
+    readonly aliasName: string;
+    readonly aliasTargetKey: IKey;
+    readonly resource: kmsAlias.KmsAlias;
+    constructor(scope: Construct, id: string, props: AliasProps);
+}
+export {};