terraconstructs 0.0.8

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

@@ -0,0 +1,532 @@
+"use strict";
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineFullyQualifiedDomainName = exports.ZoneDelegationRecord = exports.DsRecord = exports.NsRecord = exports.MxRecord = exports.CaaAmazonRecord = exports.CaaRecord = exports.CaaTag = exports.SrvRecord = exports.TxtRecord = exports.CnameRecord = exports.AaaaRecord = exports.ARecord = exports.RecordTarget = exports.RecordType = exports.RecordSet = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const __1 = require("../");
+const __2 = require("../..");
+/**
+ * A record set.
+ */
+class RecordSet extends __1.AwsConstructBase {
+    get recordSetOutputs() {
+        return this._outputs;
+    }
+    get outputs() {
+        return this.recordSetOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        if (props.weight && (props.weight < 0 || props.weight > 255)) {
+            throw new Error(`weight must be between 0 and 255 inclusive, got: ${props.weight}`);
+        }
+        if (props.setIdentifier &&
+            (props.setIdentifier.length < 1 || props.setIdentifier.length > 128)) {
+            throw new Error(`setIdentifier must be between 1 and 128 characters long, got: ${props.setIdentifier.length}`);
+        }
+        if (props.setIdentifier &&
+            props.weight === undefined &&
+            // !props.geoLocation &&
+            !props.region &&
+            !props.multiValueAnswer) {
+            throw new Error("setIdentifier can only be specified for non-simple routing policies");
+        }
+        if (props.multiValueAnswer && props.target.aliasTarget) {
+            throw new Error("multiValueAnswer cannot be specified for alias record");
+        }
+        const nonSimpleRoutingPolicies = [
+            // props.geoLocation,
+            props.region,
+            props.weight,
+            props.multiValueAnswer,
+        ].filter((variable) => variable !== undefined).length;
+        if (nonSimpleRoutingPolicies > 1) {
+            throw new Error("Only one of region, weight, multiValueAnswer or geoLocation can be defined");
+        }
+        // this.geoLocation = props.geoLocation;
+        this.weight = props.weight;
+        this.region = props.region;
+        this.multiValueAnswer = props.multiValueAnswer;
+        const ttl = props.target.aliasTarget
+            ? undefined
+            : ((props.ttl && props.ttl.toSeconds()) ?? 1800);
+        const recordName = determineFullyQualifiedDomainName(props.zone, props.recordName);
+        this.resource = new provider_aws_1.route53Record.Route53Record(this, "Resource", {
+            ...props, // copy all MetaArguments
+            zoneId: props.zone.zoneId,
+            name: recordName,
+            type: props.recordType,
+            records: props.target.values,
+            alias: props.target.aliasTarget &&
+                props.target.aliasTarget.bind(this, props.zone),
+            ttl,
+            setIdentifier: props.setIdentifier ?? this.configureSetIdentifier(),
+            // geoLocation: props.geoLocation
+            //   ? {
+            //       continentCode: props.geoLocation.continentCode,
+            //       countryCode: props.geoLocation.countryCode,
+            //       subdivisionCode: props.geoLocation.subdivisionCode,
+            //     }
+            //   : undefined,
+            multivalueAnswerRoutingPolicy: props.multiValueAnswer,
+            weightedRoutingPolicy: props.weight
+                ? {
+                    weight: props.weight,
+                }
+                : undefined,
+            latencyRoutingPolicy: props.region
+                ? {
+                    region: props.region,
+                }
+                : undefined,
+            allowOverwrite: props.allowOverwrite,
+        });
+        this.fqdn = this.resource.fqdn;
+        this.domainName = this.resource.name;
+        this._outputs = {
+            domainName: this.domainName,
+            fqdn: this.fqdn,
+        };
+    }
+    configureSetIdentifier() {
+        // if (this.geoLocation) {
+        //   let identifier = "GEO";
+        //   if (this.geoLocation.continentCode) {
+        //     identifier = identifier.concat(
+        //       "_CONTINENT_",
+        //       this.geoLocation.continentCode,
+        //     );
+        //   }
+        //   if (this.geoLocation.countryCode) {
+        //     identifier = identifier.concat(
+        //       "_COUNTRY_",
+        //       this.geoLocation.countryCode,
+        //     );
+        //   }
+        //   if (this.geoLocation.subdivisionCode) {
+        //     identifier = identifier.concat(
+        //       "_SUBDIVISION_",
+        //       this.geoLocation.subdivisionCode,
+        //     );
+        //   }
+        //   return identifier;
+        // }
+        if (this.weight !== undefined) {
+            const idPrefix = `WEIGHT_${this.weight}_ID_`;
+            return this.createIdentifier(idPrefix);
+        }
+        if (this.region) {
+            const idPrefix = `REGION_${this.region}_ID_`;
+            return this.createIdentifier(idPrefix);
+        }
+        if (this.multiValueAnswer) {
+            const idPrefix = "MVA_ID_";
+            return this.createIdentifier(idPrefix);
+        }
+        return undefined;
+    }
+    createIdentifier(prefix) {
+        return this.stack.uniqueResourceName(this, { maxLength: 64, prefix });
+    }
+}
+exports.RecordSet = RecordSet;
+_a = JSII_RTTI_SYMBOL_1;
+RecordSet[_a] = { fqn: "terraconstructs.aws.edge.RecordSet", version: "0.0.8" };
+/**
+ * The record type.
+ */
+var RecordType;
+(function (RecordType) {
+    /**
+     * route traffic to a resource, such as a web server, using an IPv4 address in dotted decimal
+     * notation
+     *
+     * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#AFormat
+     */
+    RecordType["A"] = "A";
+    /**
+     * route traffic to a resource, such as a web server, using an IPv6 address in colon-separated
+     * hexadecimal format
+     *
+     * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#AAAAFormat
+     */
+    RecordType["AAAA"] = "AAAA";
+    /**
+     * A CAA record specifies which certificate authorities (CAs) are allowed to issue certificates
+     * for a domain or subdomain
+     *
+     * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#CAAFormat
+     */
+    RecordType["CAA"] = "CAA";
+    /**
+     * A CNAME record maps DNS queries for the name of the current record, such as acme.example.com,
+     * to another domain (example.com or example.net) or subdomain (acme.example.com or zenith.example.org).
+     *
+     * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#CNAMEFormat
+     */
+    RecordType["CNAME"] = "CNAME";
+    /**
+     * A delegation signer (DS) record refers a zone key for a delegated subdomain zone.
+     *
+     * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#DSFormat
+     */
+    RecordType["DS"] = "DS";
+    /**
+     * An MX record specifies the names of your mail servers and, if you have two or more mail servers,
+     * the priority order.
+     *
+     * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#MXFormat
+     */
+    RecordType["MX"] = "MX";
+    /**
+     * A Name Authority Pointer (NAPTR) is a type of record that is used by Dynamic Delegation Discovery
+     * System (DDDS) applications to convert one value to another or to replace one value with another.
+     * For example, one common use is to convert phone numbers into SIP URIs.
+     *
+     * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#NAPTRFormat
+     */
+    RecordType["NAPTR"] = "NAPTR";
+    /**
+     * An NS record identifies the name servers for the hosted zone
+     *
+     * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#NSFormat
+     */
+    RecordType["NS"] = "NS";
+    /**
+     * A PTR record maps an IP address to the corresponding domain name.
+     *
+     * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#PTRFormat
+     */
+    RecordType["PTR"] = "PTR";
+    /**
+     * A start of authority (SOA) record provides information about a domain and the corresponding Amazon
+     * Route 53 hosted zone
+     *
+     * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#SOAFormat
+     */
+    RecordType["SOA"] = "SOA";
+    /**
+     * SPF records were formerly used to verify the identity of the sender of email messages.
+     * Instead of an SPF record, we recommend that you create a TXT record that contains the applicable value.
+     *
+     * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#SPFFormat
+     */
+    RecordType["SPF"] = "SPF";
+    /**
+     * An SRV record Value element consists of four space-separated values. The first three values are
+     * decimal numbers representing priority, weight, and port. The fourth value is a domain name.
+     *
+     * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#SRVFormat
+     */
+    RecordType["SRV"] = "SRV";
+    /**
+     * A TXT record contains one or more strings that are enclosed in double quotation marks (").
+     *
+     * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#TXTFormat
+     */
+    RecordType["TXT"] = "TXT";
+})(RecordType || (exports.RecordType = RecordType = {}));
+/**
+ * Type union for a record that accepts multiple types of target.
+ */
+class RecordTarget {
+    /**
+     * Use string values as target.
+     *
+     * These can be IP addresses or domain names.
+     */
+    static fromValues(...values) {
+        return new RecordTarget(values);
+    }
+    /**
+     * Use an alias as target.
+     */
+    static fromAlias(aliasTarget) {
+        return new RecordTarget(undefined, aliasTarget);
+    }
+    /**
+     *
+     * @param values correspond with the chosen record type (e.g. for 'A' Type, specify one or more IP addresses)
+     * @param aliasTarget alias for targets such as CloudFront distribution to route traffic to
+     */
+    constructor(values, aliasTarget) {
+        this.values = values;
+        this.aliasTarget = aliasTarget;
+    }
+}
+exports.RecordTarget = RecordTarget;
+_b = JSII_RTTI_SYMBOL_1;
+RecordTarget[_b] = { fqn: "terraconstructs.aws.edge.RecordTarget", version: "0.0.8" };
+/**
+ * A DNS A record
+ *
+ * @resource aws_route53_record
+ */
+class ARecord extends RecordSet {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            ...props,
+            recordType: RecordType.A,
+            target: props.target,
+        });
+    }
+}
+exports.ARecord = ARecord;
+_c = JSII_RTTI_SYMBOL_1;
+ARecord[_c] = { fqn: "terraconstructs.aws.edge.ARecord", version: "0.0.8" };
+/**
+ * A DNS AAAA record
+ *
+ * @resource aws_route53_record
+ */
+class AaaaRecord extends RecordSet {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            ...props,
+            recordType: RecordType.AAAA,
+            target: props.target,
+        });
+    }
+}
+exports.AaaaRecord = AaaaRecord;
+_d = JSII_RTTI_SYMBOL_1;
+AaaaRecord[_d] = { fqn: "terraconstructs.aws.edge.AaaaRecord", version: "0.0.8" };
+/**
+ * A DNS CNAME record
+ *
+ * @resource aws_route53_record
+ */
+class CnameRecord extends RecordSet {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            ...props,
+            recordType: RecordType.CNAME,
+            target: RecordTarget.fromValues(props.domainName),
+        });
+    }
+}
+exports.CnameRecord = CnameRecord;
+_e = JSII_RTTI_SYMBOL_1;
+CnameRecord[_e] = { fqn: "terraconstructs.aws.edge.CnameRecord", version: "0.0.8" };
+/**
+ * A DNS TXT record
+ *
+ * @resource aws_route53_record
+ */
+class TxtRecord extends RecordSet {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            ...props,
+            recordType: RecordType.TXT,
+            target: RecordTarget.fromValues(...props.values.map((v) => formatTxt(v))),
+        });
+    }
+}
+exports.TxtRecord = TxtRecord;
+_f = JSII_RTTI_SYMBOL_1;
+TxtRecord[_f] = { fqn: "terraconstructs.aws.edge.TxtRecord", version: "0.0.8" };
+/**
+ * Formats a text value for use in a TXT record
+ *
+ * Use `JSON.stringify` to correctly escape and enclose in double quotes ("").
+ *
+ * DNS TXT records can contain up to 255 characters in a single string. TXT
+ * record strings over 255 characters must be split into multiple text strings
+ * within the same record.
+ *
+ * @see https://aws.amazon.com/premiumsupport/knowledge-center/route53-resolve-dkim-text-record-error/
+ */
+function formatTxt(string) {
+    const result = [];
+    let idx = 0;
+    while (idx < string.length) {
+        result.push(string.slice(idx, (idx += 255))); // chunks of 255 characters long
+    }
+    return result.map((r) => JSON.stringify(r)).join("");
+}
+/**
+ * A DNS SRV record
+ *
+ * @resource aws_route53_record
+ */
+class SrvRecord extends RecordSet {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            ...props,
+            recordType: RecordType.SRV,
+            target: RecordTarget.fromValues(...props.values.map((v) => `${v.priority} ${v.weight} ${v.port} ${v.hostName}`)),
+        });
+    }
+}
+exports.SrvRecord = SrvRecord;
+_g = JSII_RTTI_SYMBOL_1;
+SrvRecord[_g] = { fqn: "terraconstructs.aws.edge.SrvRecord", version: "0.0.8" };
+/**
+ * The CAA tag.
+ */
+var CaaTag;
+(function (CaaTag) {
+    /**
+     * Explicity authorizes a single certificate authority to issue a
+     * certificate (any type) for the hostname.
+     */
+    CaaTag["ISSUE"] = "issue";
+    /**
+     * Explicity authorizes a single certificate authority to issue a
+     * wildcard certificate (and only wildcard) for the hostname.
+     */
+    CaaTag["ISSUEWILD"] = "issuewild";
+    /**
+     * Specifies a URL to which a certificate authority may report policy
+     * violations.
+     */
+    CaaTag["IODEF"] = "iodef";
+})(CaaTag || (exports.CaaTag = CaaTag = {}));
+/**
+ * A DNS CAA record
+ *
+ * @resource aws_route53_record
+ */
+class CaaRecord extends RecordSet {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            ...props,
+            recordType: RecordType.CAA,
+            target: RecordTarget.fromValues(...props.values.map((v) => `${v.flag} ${v.tag} "${v.value}"`)),
+        });
+    }
+}
+exports.CaaRecord = CaaRecord;
+_h = JSII_RTTI_SYMBOL_1;
+CaaRecord[_h] = { fqn: "terraconstructs.aws.edge.CaaRecord", version: "0.0.8" };
+/**
+ * A DNS Amazon CAA record.
+ *
+ * A CAA record to restrict certificate authorities allowed
+ * to issue certificates for a domain to Amazon only.
+ *
+ * @resource aws_route53_record
+ */
+class CaaAmazonRecord extends CaaRecord {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            ...props,
+            values: [
+                {
+                    flag: 0,
+                    tag: CaaTag.ISSUE,
+                    value: "amazon.com",
+                },
+            ],
+        });
+    }
+}
+exports.CaaAmazonRecord = CaaAmazonRecord;
+_j = JSII_RTTI_SYMBOL_1;
+CaaAmazonRecord[_j] = { fqn: "terraconstructs.aws.edge.CaaAmazonRecord", version: "0.0.8" };
+/**
+ * A DNS MX record
+ *
+ * @resource aws_route53_record
+ */
+class MxRecord extends RecordSet {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            ...props,
+            recordType: RecordType.MX,
+            target: RecordTarget.fromValues(...props.values.map((v) => `${v.priority} ${v.hostName}`)),
+        });
+    }
+}
+exports.MxRecord = MxRecord;
+_k = JSII_RTTI_SYMBOL_1;
+MxRecord[_k] = { fqn: "terraconstructs.aws.edge.MxRecord", version: "0.0.8" };
+/**
+ * A DNS NS record
+ *
+ * @resource aws_route53_record
+ */
+class NsRecord extends RecordSet {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            ...props,
+            recordType: RecordType.NS,
+            target: RecordTarget.fromValues(...props.values),
+        });
+    }
+}
+exports.NsRecord = NsRecord;
+_l = JSII_RTTI_SYMBOL_1;
+NsRecord[_l] = { fqn: "terraconstructs.aws.edge.NsRecord", version: "0.0.8" };
+/**
+ * A DNS DS record
+ *
+ * @resource aws_route53_record
+ */
+class DsRecord extends RecordSet {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            ...props,
+            recordType: RecordType.DS,
+            target: RecordTarget.fromValues(...props.values),
+        });
+    }
+}
+exports.DsRecord = DsRecord;
+_m = JSII_RTTI_SYMBOL_1;
+DsRecord[_m] = { fqn: "terraconstructs.aws.edge.DsRecord", version: "0.0.8" };
+/**
+ * A record to delegate further lookups to a different set of name servers.
+ */
+class ZoneDelegationRecord extends RecordSet {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            ...props,
+            recordType: RecordType.NS,
+            target: RecordTarget.fromValues(...(cdktf_1.Token.isUnresolved(props.nameServers)
+                ? props.nameServers // Can't map a string-array token!
+                : props.nameServers.map((ns) => cdktf_1.Token.isUnresolved(ns) || ns.endsWith(".") ? ns : `${ns}.`))),
+            ttl: props.ttl || __2.Duration.days(2),
+        });
+    }
+}
+exports.ZoneDelegationRecord = ZoneDelegationRecord;
+_o = JSII_RTTI_SYMBOL_1;
+ZoneDelegationRecord[_o] = { fqn: "terraconstructs.aws.edge.ZoneDelegationRecord", version: "0.0.8" };
+// ref https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-route53/lib/util.ts
+/**
+ * Route53 requires the record names are specified as fully qualified names, but this
+ * forces lots of redundant work on the user (repeating the zone name over and over).
+ * This function allows the user to be lazier and offers a nicer experience, by
+ * qualifying relative names appropriately:
+ *
+ * @param providedName the user-specified name of the record.
+ * @param dnsZone      the zone the record will be created in.
+ *
+ * @returns <ul>
+ *        <li>If +providedName+ ends with a +.+, use it as-is</li>
+ *        <li>If +dnsZone.zoneName+ is a token, use +providedName+ as-is</li>
+ *        <li>If +providedName+ ends with or equals +zoneName+, append a trailing +.+</li>
+ *        <li>Otherwise, append +.+, +zoneName+ and a trailing +.+</li>
+ *      </ul>
+ */
+function determineFullyQualifiedDomainName(dnsZone, recordName) {
+    if (!recordName) {
+        return `${dnsZone.zoneName}`;
+    }
+    if (recordName.endsWith(".") || cdktf_1.Token.isUnresolved(dnsZone.zoneName)) {
+        return recordName;
+    }
+    const zoneName = dnsZone.zoneName.endsWith(".")
+        ? dnsZone.zoneName.substring(0, dnsZone.zoneName.length - 1)
+        : dnsZone.zoneName;
+    const suffix = `.${zoneName}`;
+    if (recordName.endsWith(suffix) || recordName === zoneName) {
+        return `${recordName}.`;
+    }
+    return `${recordName}${suffix}.`;
+}
+exports.determineFullyQualifiedDomainName = determineFullyQualifiedDomainName;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dns-record.js","sourceRoot":"","sources":["../../../src/aws/edge/dns-record.ts"],"names":[],"mappings":"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","sourcesContent":["import { route53Record } from \"@cdktf/provider-aws\";\nimport { Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\n// import { GeoLocation } from \"./geo-location\";\nimport { IDnsZone, IAliasRecordTarget } from \".\";\nimport { IAwsConstruct, AwsConstructProps, AwsConstructBase } from \"../\";\nimport { Duration } from \"../..\";\n\n// ref: https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-route53/lib/record-set.ts\n\n/**\n * Options for a RecordSet.\n */\nexport interface RecordSetOptions {\n  /**\n   * The hosted zone in which to define the new record.\n   */\n  readonly zone: IDnsZone;\n\n  /**\n   * The subdomain name for this record. This should be relative to the zone root name.\n   *\n   * For example, if you want to create a record for acme.example.com, specify\n   * \"acme\".\n   *\n   * You can also specify the fully qualified domain name which terminates with a\n   * \".\". For example, \"acme.example.com.\".\n   *\n   * @default zone root\n   */\n  readonly recordName?: string;\n\n  /**\n   * The resource record cache time to live (TTL).\n   *\n   * @default Duration.minutes(30)\n   */\n  readonly ttl?: Duration;\n\n  /**\n   * Whether to delete the same record set in the hosted zone if it already exists (dangerous!)\n   *\n   * This allows to deploy a new record set while minimizing the downtime because the\n   * new record set will be created immediately after the existing one is deleted. It\n   * also avoids \"manual\" actions to delete existing record sets.\n   *\n   * > **N.B.:** this feature is dangerous, use with caution!\n   *\n   * @default false\n   */\n  readonly allowOverwrite?: boolean;\n\n  /**\n   * Among resource record sets that have the same combination of DNS name and type,\n   * a value that determines the proportion of DNS queries that Amazon Route 53 responds to using the current resource record set.\n   *\n   * Route 53 calculates the sum of the weights for the resource record sets that have the same combination of DNS name and type.\n   * Route 53 then responds to queries based on the ratio of a resource's weight to the total.\n   *\n   * This value can be a number between 0 and 255.\n   *\n   * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html\n   *\n   * @default - Do not set weighted routing\n   */\n  readonly weight?: number;\n\n  /**\n   * The Amazon EC2 Region where you created the resource that this resource record set refers to.\n   * The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer,\n   * and is referred to by an IP address or a DNS domain name, depending on the record type.\n   *\n   * When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets,\n   * Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region.\n   * Route 53 then returns the value that is associated with the selected resource record set.\n   *\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-route53-recordset.html#cfn-route53-recordset-region\n   *\n   * @default - Do not set latency based routing\n   */\n  readonly region?: string;\n\n  /**\n   * Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries.\n   * Set to true to indicate a multivalue answer routing policy. Conflicts with any other routing policy.\n   *\n   * @default false\n   */\n  readonly multiValueAnswer?: boolean;\n\n  /**\n   * A string used to distinguish between different records with the same combination of DNS name and type.\n   * It can only be set when either weight or geoLocation is defined.\n   *\n   * This parameter must be between 1 and 128 characters in length.\n   *\n   * @default - Auto generated string\n   */\n  readonly setIdentifier?: string;\n\n  // R53 record comment is hardcoded for terraform-provider-aws\n  // https://github.com/hashicorp/terraform-provider-aws/blob/v5.68.0/internal/service/route53/record.go#L363\n  // /**\n  //  * A comment to add on the record.\n  //  *\n  //  * @default \"Managed by Terraform\"\n  //  */\n  // readonly comment?: string;\n}\n\n/**\n * Construction properties for a RecordSet.\n */\nexport interface RecordSetProps extends RecordSetOptions, AwsConstructProps {\n  /**\n   * The record type.\n   */\n  readonly recordType: RecordType;\n\n  /**\n   * The target for this record, either `RecordTarget.fromValues()` or\n   * `RecordTarget.fromAlias()`.\n   */\n  readonly target: RecordTarget;\n}\n\nexport interface RecordSetOutputs {\n  /**\n   * The domain name of the record\n   */\n  readonly domainName: string;\n  /**\n   * The FQDN[fqn] built using the zone domain and name\n   *\n   * [fqn]: https://en.wikipedia.org/wiki/Fully_qualified_domain_name\n   */\n  readonly fqdn: string;\n}\n\n/**\n * A record set Attributes\n */\nexport interface IRecordSet extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly recordSetOutputs: RecordSetOutputs;\n\n  /**\n   * The domain name of the record\n   */\n  readonly domainName: string;\n  /**\n   * The [FQDN][fqdn] built using the zone domain and name\n   *\n   * [fqdn]: https://en.wikipedia.org/wiki/Fully_qualified_domain_name\n   */\n  readonly fqdn: string;\n}\n\n/**\n * A record set.\n */\nexport class RecordSet extends AwsConstructBase implements IRecordSet {\n  public readonly resource: route53Record.Route53Record;\n  private readonly _outputs: RecordSetOutputs;\n  public get recordSetOutputs(): RecordSetOutputs {\n    return this._outputs;\n  }\n  public get outputs(): Record<string, any> {\n    return this.recordSetOutputs;\n  }\n  public readonly domainName: string;\n  public readonly fqdn: string;\n  // private readonly geoLocation?: GeoLocation;\n  private readonly weight?: number;\n  private readonly region?: string;\n  private readonly multiValueAnswer?: boolean;\n\n  constructor(scope: Construct, id: string, props: RecordSetProps) {\n    super(scope, id, props);\n\n    if (props.weight && (props.weight < 0 || props.weight > 255)) {\n      throw new Error(\n        `weight must be between 0 and 255 inclusive, got: ${props.weight}`,\n      );\n    }\n    if (\n      props.setIdentifier &&\n      (props.setIdentifier.length < 1 || props.setIdentifier.length > 128)\n    ) {\n      throw new Error(\n        `setIdentifier must be between 1 and 128 characters long, got: ${props.setIdentifier.length}`,\n      );\n    }\n    if (\n      props.setIdentifier &&\n      props.weight === undefined &&\n      // !props.geoLocation &&\n      !props.region &&\n      !props.multiValueAnswer\n    ) {\n      throw new Error(\n        \"setIdentifier can only be specified for non-simple routing policies\",\n      );\n    }\n    if (props.multiValueAnswer && props.target.aliasTarget) {\n      throw new Error(\"multiValueAnswer cannot be specified for alias record\");\n    }\n\n    const nonSimpleRoutingPolicies = [\n      // props.geoLocation,\n      props.region,\n      props.weight,\n      props.multiValueAnswer,\n    ].filter((variable) => variable !== undefined).length;\n    if (nonSimpleRoutingPolicies > 1) {\n      throw new Error(\n        \"Only one of region, weight, multiValueAnswer or geoLocation can be defined\",\n      );\n    }\n\n    // this.geoLocation = props.geoLocation;\n    this.weight = props.weight;\n    this.region = props.region;\n    this.multiValueAnswer = props.multiValueAnswer;\n\n    const ttl = props.target.aliasTarget\n      ? undefined\n      : ((props.ttl && props.ttl.toSeconds()) ?? 1800);\n\n    const recordName = determineFullyQualifiedDomainName(\n      props.zone,\n      props.recordName,\n    );\n\n    this.resource = new route53Record.Route53Record(this, \"Resource\", {\n      ...props, // copy all MetaArguments\n      zoneId: props.zone.zoneId,\n      name: recordName,\n      type: props.recordType,\n      records: props.target.values,\n      alias:\n        props.target.aliasTarget &&\n        props.target.aliasTarget.bind(this, props.zone),\n      ttl,\n      setIdentifier: props.setIdentifier ?? this.configureSetIdentifier(),\n      // geoLocation: props.geoLocation\n      //   ? {\n      //       continentCode: props.geoLocation.continentCode,\n      //       countryCode: props.geoLocation.countryCode,\n      //       subdivisionCode: props.geoLocation.subdivisionCode,\n      //     }\n      //   : undefined,\n      multivalueAnswerRoutingPolicy: props.multiValueAnswer,\n      weightedRoutingPolicy: props.weight\n        ? {\n            weight: props.weight,\n          }\n        : undefined,\n      latencyRoutingPolicy: props.region\n        ? {\n            region: props.region,\n          }\n        : undefined,\n      allowOverwrite: props.allowOverwrite,\n    });\n\n    this.fqdn = this.resource.fqdn;\n    this.domainName = this.resource.name;\n    this._outputs = {\n      domainName: this.domainName,\n      fqdn: this.fqdn,\n    };\n  }\n\n  private configureSetIdentifier(): string | undefined {\n    // if (this.geoLocation) {\n    //   let identifier = \"GEO\";\n    //   if (this.geoLocation.continentCode) {\n    //     identifier = identifier.concat(\n    //       \"_CONTINENT_\",\n    //       this.geoLocation.continentCode,\n    //     );\n    //   }\n    //   if (this.geoLocation.countryCode) {\n    //     identifier = identifier.concat(\n    //       \"_COUNTRY_\",\n    //       this.geoLocation.countryCode,\n    //     );\n    //   }\n    //   if (this.geoLocation.subdivisionCode) {\n    //     identifier = identifier.concat(\n    //       \"_SUBDIVISION_\",\n    //       this.geoLocation.subdivisionCode,\n    //     );\n    //   }\n    //   return identifier;\n    // }\n\n    if (this.weight !== undefined) {\n      const idPrefix = `WEIGHT_${this.weight}_ID_`;\n      return this.createIdentifier(idPrefix);\n    }\n\n    if (this.region) {\n      const idPrefix = `REGION_${this.region}_ID_`;\n      return this.createIdentifier(idPrefix);\n    }\n\n    if (this.multiValueAnswer) {\n      const idPrefix = \"MVA_ID_\";\n      return this.createIdentifier(idPrefix);\n    }\n\n    return undefined;\n  }\n\n  private createIdentifier(prefix: string): string {\n    return this.stack.uniqueResourceName(this, { maxLength: 64, prefix });\n  }\n}\n\n/**\n * The record type.\n */\nexport enum RecordType {\n  /**\n   * route traffic to a resource, such as a web server, using an IPv4 address in dotted decimal\n   * notation\n   *\n   * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#AFormat\n   */\n  A = \"A\",\n\n  /**\n   * route traffic to a resource, such as a web server, using an IPv6 address in colon-separated\n   * hexadecimal format\n   *\n   * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#AAAAFormat\n   */\n  AAAA = \"AAAA\",\n\n  /**\n   * A CAA record specifies which certificate authorities (CAs) are allowed to issue certificates\n   * for a domain or subdomain\n   *\n   * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#CAAFormat\n   */\n  CAA = \"CAA\",\n\n  /**\n   * A CNAME record maps DNS queries for the name of the current record, such as acme.example.com,\n   * to another domain (example.com or example.net) or subdomain (acme.example.com or zenith.example.org).\n   *\n   * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#CNAMEFormat\n   */\n  CNAME = \"CNAME\",\n\n  /**\n   * A delegation signer (DS) record refers a zone key for a delegated subdomain zone.\n   *\n   * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#DSFormat\n   */\n  DS = \"DS\",\n\n  /**\n   * An MX record specifies the names of your mail servers and, if you have two or more mail servers,\n   * the priority order.\n   *\n   * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#MXFormat\n   */\n  MX = \"MX\",\n\n  /**\n   * A Name Authority Pointer (NAPTR) is a type of record that is used by Dynamic Delegation Discovery\n   * System (DDDS) applications to convert one value to another or to replace one value with another.\n   * For example, one common use is to convert phone numbers into SIP URIs.\n   *\n   * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#NAPTRFormat\n   */\n  NAPTR = \"NAPTR\",\n\n  /**\n   * An NS record identifies the name servers for the hosted zone\n   *\n   * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#NSFormat\n   */\n  NS = \"NS\",\n\n  /**\n   * A PTR record maps an IP address to the corresponding domain name.\n   *\n   * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#PTRFormat\n   */\n  PTR = \"PTR\",\n\n  /**\n   * A start of authority (SOA) record provides information about a domain and the corresponding Amazon\n   * Route 53 hosted zone\n   *\n   * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#SOAFormat\n   */\n  SOA = \"SOA\",\n\n  /**\n   * SPF records were formerly used to verify the identity of the sender of email messages.\n   * Instead of an SPF record, we recommend that you create a TXT record that contains the applicable value.\n   *\n   * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#SPFFormat\n   */\n  SPF = \"SPF\",\n\n  /**\n   * An SRV record Value element consists of four space-separated values. The first three values are\n   * decimal numbers representing priority, weight, and port. The fourth value is a domain name.\n   *\n   * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#SRVFormat\n   */\n  SRV = \"SRV\",\n\n  /**\n   * A TXT record contains one or more strings that are enclosed in double quotation marks (\").\n   *\n   * @see https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html#TXTFormat\n   */\n  TXT = \"TXT\",\n}\n\n/**\n * Type union for a record that accepts multiple types of target.\n */\nexport class RecordTarget {\n  /**\n   * Use string values as target.\n   *\n   * These can be IP addresses or domain names.\n   */\n  public static fromValues(...values: string[]) {\n    return new RecordTarget(values);\n  }\n\n  /**\n   * Use an alias as target.\n   */\n  public static fromAlias(aliasTarget: IAliasRecordTarget) {\n    return new RecordTarget(undefined, aliasTarget);\n  }\n\n  /**\n   *\n   * @param values correspond with the chosen record type (e.g. for 'A' Type, specify one or more IP addresses)\n   * @param aliasTarget alias for targets such as CloudFront distribution to route traffic to\n   */\n  protected constructor(\n    public readonly values?: string[],\n    public readonly aliasTarget?: IAliasRecordTarget,\n  ) {}\n}\n\n/**\n * Construction properties for a ARecord.\n */\nexport interface ARecordProps extends RecordSetOptions, AwsConstructProps {\n  /**\n   * The target.\n   */\n  readonly target: RecordTarget;\n}\n\n/**\n * A DNS A record\n *\n * @resource aws_route53_record\n */\nexport class ARecord extends RecordSet {\n  constructor(scope: Construct, id: string, props: ARecordProps) {\n    super(scope, id, {\n      ...props,\n      recordType: RecordType.A,\n      target: props.target,\n    });\n  }\n}\n\n/**\n * Construction properties for a AaaaRecord.\n */\nexport interface AaaaRecordProps extends RecordSetOptions, AwsConstructProps {\n  /**\n   * The target.\n   */\n  readonly target: RecordTarget;\n}\n\n/**\n * A DNS AAAA record\n *\n * @resource aws_route53_record\n */\nexport class AaaaRecord extends RecordSet {\n  constructor(scope: Construct, id: string, props: AaaaRecordProps) {\n    super(scope, id, {\n      ...props,\n      recordType: RecordType.AAAA,\n      target: props.target,\n    });\n  }\n}\n\n/**\n * Construction properties for a CnameRecord.\n */\nexport interface CnameRecordProps extends RecordSetOptions {\n  /**\n   * The domain name of the target that this record should point to.\n   */\n  readonly domainName: string;\n}\n\n/**\n * A DNS CNAME record\n *\n * @resource aws_route53_record\n */\nexport class CnameRecord extends RecordSet {\n  constructor(scope: Construct, id: string, props: CnameRecordProps) {\n    super(scope, id, {\n      ...props,\n      recordType: RecordType.CNAME,\n      target: RecordTarget.fromValues(props.domainName),\n    });\n  }\n}\n\n/**\n * Construction properties for a TxtRecord.\n */\nexport interface TxtRecordProps extends RecordSetOptions {\n  /**\n   * The text values.\n   */\n  readonly values: string[];\n}\n\n/**\n * A DNS TXT record\n *\n * @resource aws_route53_record\n */\nexport class TxtRecord extends RecordSet {\n  constructor(scope: Construct, id: string, props: TxtRecordProps) {\n    super(scope, id, {\n      ...props,\n      recordType: RecordType.TXT,\n      target: RecordTarget.fromValues(...props.values.map((v) => formatTxt(v))),\n    });\n  }\n}\n\n/**\n * Formats a text value for use in a TXT record\n *\n * Use `JSON.stringify` to correctly escape and enclose in double quotes (\"\").\n *\n * DNS TXT records can contain up to 255 characters in a single string. TXT\n * record strings over 255 characters must be split into multiple text strings\n * within the same record.\n *\n * @see https://aws.amazon.com/premiumsupport/knowledge-center/route53-resolve-dkim-text-record-error/\n */\nfunction formatTxt(string: string): string {\n  const result = [];\n  let idx = 0;\n  while (idx < string.length) {\n    result.push(string.slice(idx, (idx += 255))); // chunks of 255 characters long\n  }\n  return result.map((r) => JSON.stringify(r)).join(\"\");\n}\n\n/**\n * Properties for a SRV record value.\n */\nexport interface SrvRecordValue {\n  /**\n   * The priority.\n   */\n  readonly priority: number;\n\n  /**\n   * The weight.\n   */\n  readonly weight: number;\n\n  /**\n   * The port.\n   */\n  readonly port: number;\n\n  /**\n   * The server host name.\n   */\n  readonly hostName: string;\n}\n/**\n * Construction properties for a SrvRecord.\n */\nexport interface SrvRecordProps extends RecordSetOptions {\n  /**\n   * The values.\n   */\n  readonly values: SrvRecordValue[];\n}\n\n/**\n * A DNS SRV record\n *\n * @resource aws_route53_record\n */\nexport class SrvRecord extends RecordSet {\n  constructor(scope: Construct, id: string, props: SrvRecordProps) {\n    super(scope, id, {\n      ...props,\n      recordType: RecordType.SRV,\n      target: RecordTarget.fromValues(\n        ...props.values.map(\n          (v) => `${v.priority} ${v.weight} ${v.port} ${v.hostName}`,\n        ),\n      ),\n    });\n  }\n}\n\n/**\n * The CAA tag.\n */\nexport enum CaaTag {\n  /**\n   * Explicity authorizes a single certificate authority to issue a\n   * certificate (any type) for the hostname.\n   */\n  ISSUE = \"issue\",\n\n  /**\n   * Explicity authorizes a single certificate authority to issue a\n   * wildcard certificate (and only wildcard) for the hostname.\n   */\n  ISSUEWILD = \"issuewild\",\n\n  /**\n   * Specifies a URL to which a certificate authority may report policy\n   * violations.\n   */\n  IODEF = \"iodef\",\n}\n\n/**\n * Properties for a CAA record value.\n */\nexport interface CaaRecordValue {\n  /**\n   * The flag.\n   */\n  readonly flag: number;\n\n  /**\n   * The tag.\n   */\n  readonly tag: CaaTag;\n\n  /**\n   * The value associated with the tag.\n   */\n  readonly value: string;\n}\n\n/**\n * Construction properties for a CaaRecord.\n */\nexport interface CaaRecordProps extends RecordSetOptions {\n  /**\n   * The values.\n   */\n  readonly values: CaaRecordValue[];\n}\n\n/**\n * A DNS CAA record\n *\n * @resource aws_route53_record\n */\nexport class CaaRecord extends RecordSet {\n  constructor(scope: Construct, id: string, props: CaaRecordProps) {\n    super(scope, id, {\n      ...props,\n      recordType: RecordType.CAA,\n      target: RecordTarget.fromValues(\n        ...props.values.map((v) => `${v.flag} ${v.tag} \"${v.value}\"`),\n      ),\n    });\n  }\n}\n\n/**\n * Construction properties for a CaaAmazonRecord.\n */\nexport interface CaaAmazonRecordProps extends RecordSetOptions {}\n\n/**\n * A DNS Amazon CAA record.\n *\n * A CAA record to restrict certificate authorities allowed\n * to issue certificates for a domain to Amazon only.\n *\n * @resource aws_route53_record\n */\nexport class CaaAmazonRecord extends CaaRecord {\n  constructor(scope: Construct, id: string, props: CaaAmazonRecordProps) {\n    super(scope, id, {\n      ...props,\n      values: [\n        {\n          flag: 0,\n          tag: CaaTag.ISSUE,\n          value: \"amazon.com\",\n        },\n      ],\n    });\n  }\n}\n\n/**\n * Properties for a MX record value.\n */\nexport interface MxRecordValue {\n  /**\n   * The priority.\n   */\n  readonly priority: number;\n\n  /**\n   * The mail server host name.\n   */\n  readonly hostName: string;\n}\n\n/**\n * Construction properties for a MxRecord.\n */\nexport interface MxRecordProps extends RecordSetOptions {\n  /**\n   * The values.\n   */\n  readonly values: MxRecordValue[];\n}\n\n/**\n * A DNS MX record\n *\n * @resource aws_route53_record\n */\nexport class MxRecord extends RecordSet {\n  constructor(scope: Construct, id: string, props: MxRecordProps) {\n    super(scope, id, {\n      ...props,\n      recordType: RecordType.MX,\n      target: RecordTarget.fromValues(\n        ...props.values.map((v) => `${v.priority} ${v.hostName}`),\n      ),\n    });\n  }\n}\n\n/**\n * Construction properties for a NSRecord.\n */\nexport interface NsRecordProps extends RecordSetOptions {\n  /**\n   * The NS values.\n   */\n  readonly values: string[];\n}\n\n/**\n * A DNS NS record\n *\n * @resource aws_route53_record\n */\nexport class NsRecord extends RecordSet {\n  constructor(scope: Construct, id: string, props: NsRecordProps) {\n    super(scope, id, {\n      ...props,\n      recordType: RecordType.NS,\n      target: RecordTarget.fromValues(...props.values),\n    });\n  }\n}\n\n/**\n * Construction properties for a DSRecord.\n */\nexport interface DsRecordProps extends RecordSetOptions {\n  /**\n   * The DS values.\n   */\n  readonly values: string[];\n}\n\n/**\n * A DNS DS record\n *\n * @resource aws_route53_record\n */\nexport class DsRecord extends RecordSet {\n  constructor(scope: Construct, id: string, props: DsRecordProps) {\n    super(scope, id, {\n      ...props,\n      recordType: RecordType.DS,\n      target: RecordTarget.fromValues(...props.values),\n    });\n  }\n}\n\n/**\n * Construction properties for a ZoneDelegationRecord\n */\nexport interface ZoneDelegationRecordProps extends RecordSetOptions {\n  /**\n   * The name servers to report in the delegation records.\n   */\n  readonly nameServers: string[];\n}\n\n/**\n * A record to delegate further lookups to a different set of name servers.\n */\nexport class ZoneDelegationRecord extends RecordSet {\n  constructor(scope: Construct, id: string, props: ZoneDelegationRecordProps) {\n    super(scope, id, {\n      ...props,\n      recordType: RecordType.NS,\n      target: RecordTarget.fromValues(\n        ...(Token.isUnresolved(props.nameServers)\n          ? props.nameServers // Can't map a string-array token!\n          : props.nameServers.map((ns) =>\n              Token.isUnresolved(ns) || ns.endsWith(\".\") ? ns : `${ns}.`,\n            )),\n      ),\n      ttl: props.ttl || Duration.days(2),\n    });\n  }\n}\n\n// ref https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-route53/lib/util.ts\n\n/**\n * Route53 requires the record names are specified as fully qualified names, but this\n * forces lots of redundant work on the user (repeating the zone name over and over).\n * This function allows the user to be lazier and offers a nicer experience, by\n * qualifying relative names appropriately:\n *\n * @param providedName the user-specified name of the record.\n * @param dnsZone      the zone the record will be created in.\n *\n * @returns <ul>\n *        <li>If +providedName+ ends with a +.+, use it as-is</li>\n *        <li>If +dnsZone.zoneName+ is a token, use +providedName+ as-is</li>\n *        <li>If +providedName+ ends with or equals +zoneName+, append a trailing +.+</li>\n *        <li>Otherwise, append +.+, +zoneName+ and a trailing +.+</li>\n *      </ul>\n */\nexport function determineFullyQualifiedDomainName(\n  dnsZone: IDnsZone,\n  recordName?: string,\n): string {\n  if (!recordName) {\n    return `${dnsZone.zoneName}`;\n  }\n\n  if (recordName.endsWith(\".\") || Token.isUnresolved(dnsZone.zoneName)) {\n    return recordName;\n  }\n\n  const zoneName = dnsZone.zoneName.endsWith(\".\")\n    ? dnsZone.zoneName.substring(0, dnsZone.zoneName.length - 1)\n    : dnsZone.zoneName;\n\n  const suffix = `.${zoneName}`;\n  if (recordName.endsWith(suffix) || recordName === zoneName) {\n    return `${recordName}.`;\n  }\n\n  return `${recordName}${suffix}.`;\n}\n"]}