terraconstructs 0.0.8

package/lib/aws/edge/certificate.js

@@ -0,0 +1,191 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationMethod = exports.PublicCertificate = 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 duration_1 = require("../../duration");
+const aws_construct_1 = require("../aws-construct");
+/**
+ * Amazon issued certificate
+ */
+class PublicCertificate extends aws_construct_1.AwsConstructBase {
+    get certificateOutputs() {
+        return this._outputs;
+    }
+    get outputs() {
+        return this.certificateOutputs;
+    }
+    get domainName() {
+        return this._domainName;
+    }
+    get certificateArn() {
+        return this._certificateArn;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this._domainName = props.domainName;
+        // check if domain name is 64 characters or less
+        if (!cdktf_1.Token.isUnresolved(props.domainName) && props.domainName.length > 64) {
+            throw new Error("Domain name must be 64 characters or less");
+        }
+        let { validation } = props;
+        if (!validation) {
+            validation = {
+                method: ValidationMethod.EMAIL,
+                validationDomains: {
+                    [props.domainName]: props.domainName,
+                },
+            };
+        }
+        const allDomainNames = [props.domainName].concat(props.subjectAlternativeNames || []);
+        const domainValidation = renderDomainValidation(validation, allDomainNames);
+        this.resource = new provider_aws_1.acmCertificate.AcmCertificate(this, "Resource", {
+            ...props,
+            validationMethod: validation.method,
+            validationOption: domainValidation?.Options,
+        });
+        if (domainValidation && validation.method === ValidationMethod.DNS) {
+            const records = new Array();
+            // TODO: Test use case where certificates exist across multiple zones (validation record should allow override)
+            const sortedZones = Object.entries(domainValidation.zoneLookup).sort(([a], [b]) => a.localeCompare(b));
+            for (const [domainName, zone] of sortedZones) {
+                const index = records.length;
+                records.push(new _1.RecordSet(this, `ValidationRecord-${domainName}`, {
+                    recordType: this.resource.domainValidationOptions.get(index)
+                        .resourceRecordType,
+                    recordName: this.resource.domainValidationOptions.get(index)
+                        .resourceRecordName,
+                    target: _1.RecordTarget.fromValues(this.resource.domainValidationOptions.get(index)
+                        .resourceRecordValue),
+                    ttl: duration_1.Duration.seconds(60),
+                    zone,
+                    allowOverwrite: true, // required to prevent cross region wildcard errors
+                }));
+            }
+            new provider_aws_1.acmCertificateValidation.AcmCertificateValidation(this, "Validation", {
+                certificateArn: this.resource.arn,
+                validationRecordFqdns: records.map((record) => record.fqdn),
+            });
+            // // terraform-provider-aws bug, can't use TerraformIterator (`for_each`) here:
+            // // https://github.com/hashicorp/terraform-cdk/issues/3713
+            // const zoneLookup: TerraformLocal = new TerraformLocal( this, "zoneLookup", domainValidation.zoneLookup);
+            // const domainValidationIterator = TerraformIterator.fromComplexList( this.resource.domainValidationOptions, "domain_name");
+            // // RecordSet doesn't work with zone = IResolvable
+            // // using Route53Record resource directly
+            // const records = new route53Record.Route53Record( this, "ValidationRecords", {
+            //   forEach: domainValidationIterator,
+            //   allowOverwrite: true,
+            //   name: domainValidationIterator.getString("resource_record_name"),
+            //   records: [
+            //     domainValidationIterator.getString("resource_record_value"),
+            //   ],
+            //   ttl: 60,
+            //   type: domainValidationIterator.getString("resource_record_type"),
+            //   zoneId: Fn.lookup(zoneLookup, domainValidationIterator.key),
+            // });
+            // const recordsIterator = TerraformIterator.fromResources(records);
+            // new acmCertificateValidation.AcmCertificateValidation( this, "Validation", {
+            //   certificateArn: this.resource.arn,
+            //   validationRecordFqdns: Token.asList(
+            //     recordsIterator.pluckProperty("fqdn"),
+            //   ),
+            // });
+        }
+        this._certificateArn = this.resource.arn;
+        this._outputs = {
+            arn: this.resource.arn,
+            status: this.resource.status,
+            domainValidationOptions: this.resource.domainValidationOptions,
+        };
+    }
+}
+exports.PublicCertificate = PublicCertificate;
+_a = JSII_RTTI_SYMBOL_1;
+PublicCertificate[_a] = { fqn: "terraconstructs.aws.edge.PublicCertificate", version: "0.0.8" };
+/**
+ * Method used to assert ownership of the domain
+ */
+var ValidationMethod;
+(function (ValidationMethod) {
+    /**
+     * Send email to a number of email addresses associated with the domain
+     *
+     * IMPORTANT: if you are creating a certificate as part of your stack, the stack
+     * will not complete creating until you read and follow the instructions in the
+     * email that you will receive.
+     *
+     * ACM will send validation emails to the following addresses:
+     *
+     *  admin@domain.com
+     *  administrator@domain.com
+     *  hostmaster@domain.com
+     *  postmaster@domain.com
+     *  webmaster@domain.com
+     *
+     * For every domain that you register.
+     *
+     * @see https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-validate-email.html
+     */
+    ValidationMethod["EMAIL"] = "EMAIL";
+    /**
+     * Validate ownership by adding appropriate DNS records
+     *
+     * IMPORTANT: If `hostedZone` is not specified, DNS records must be added
+     * manually and the stack will not complete creating until the records are
+     * added.
+     *
+     * @see https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-validate-dns.html
+     */
+    ValidationMethod["DNS"] = "DNS";
+})(ValidationMethod || (exports.ValidationMethod = ValidationMethod = {}));
+function renderDomainValidation(validation, domainNames) {
+    const result = {
+        Options: [],
+        zoneLookup: {},
+    };
+    switch (validation.method) {
+        case ValidationMethod.DNS:
+            for (const domainName of getUniqueDnsDomainNames(domainNames)) {
+                const hostedZone = validation.hostedZones?.[domainName] ?? validation.hostedZone;
+                if (hostedZone) {
+                    result.Options.push({
+                        domainName,
+                        validationDomain: hostedZone.zoneName,
+                    });
+                    result.zoneLookup[domainName] = hostedZone; // .zoneId;
+                }
+            }
+            break;
+        case ValidationMethod.EMAIL:
+            for (const domainName of domainNames) {
+                const validationDomain = validation.validationDomains?.[domainName];
+                if (!validationDomain) {
+                    throw new Error("When using email for validation, 'validationDomains' needs to be supplied");
+                }
+                result.Options.push({
+                    domainName,
+                    validationDomain: validationDomain,
+                });
+            }
+            break;
+        default:
+            throw new Error(`Unknown validation method ${validation.method}`);
+    }
+    return result.Options.length !== 0 ? result : undefined;
+}
+/**
+ * Removes wildcard domains (*.example.com) where the base domain (example.com) is present.
+ * This is because the DNS validation treats them as the same thing, and the Route53 records
+ * resources would be duplicated causing apply-time errors.
+ */
+function getUniqueDnsDomainNames(domainNames) {
+    return domainNames.filter((domain) => {
+        return (cdktf_1.Token.isUnresolved(domain) ||
+            !domain.startsWith("*.") ||
+            !domainNames.includes(domain.replace("*.", "")));
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"certificate.js","sourceRoot":"","sources":["../../../src/aws/edge/certificate.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  acmCertificate,\n  acmCertificateValidation,\n  // route53Record,\n} from \"@cdktf/provider-aws\";\nimport {\n  Token,\n  // TerraformIterator,\n  // TerraformLocal,\n  // Fn\n} from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { IDnsZone, RecordSet, RecordTarget, RecordType } from \".\";\nimport { Duration } from \"../../duration\";\nimport {\n  AwsConstructBase,\n  IAwsConstruct,\n  AwsConstructProps,\n} from \"../aws-construct\";\n\nexport interface CertificateOutputs {\n  /**\n   * Status of the certificate.\n   */\n  readonly status: string;\n\n  /**\n   * The ARN of the certificate.\n   */\n  readonly arn: string;\n\n  /**\n   * Set of domain validation objects which can be used to complete certificate validation.\n   * Can have more than one element, e.g., if SANs are defined.\n   *\n   * Only set if DNS-validation was used.\n   */\n  readonly domainValidationOptions?: acmCertificate.AcmCertificateDomainValidationOptionsList;\n}\n\n// NOTE: The reason some properties are repeated in outputs is\n// because outputs and the resource interface serve a different purpose.\n// The outputs are a mechanism to expose the properties in the grid\n// through the stack state while the resource interface is used\n// while building composite beacons (L3) build out of base (L2) beacons.\n\nexport interface ICertificate extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly certificateOutputs: CertificateOutputs;\n  /**\n   * Domain name of the certificate.\n   */\n  readonly domainName: string;\n  /**\n   * The ARN of the certificate.\n   */\n  readonly certificateArn: string;\n}\n\nexport interface PublicCertificateProps extends AwsConstructProps {\n  /**\n   * Domain name of the certificate.\n   *\n   * Changing this property will force a new resource.\n   */\n  readonly domainName: string;\n  /**\n   * SANs for the domain.\n   *\n   * Changing this property will force a new resource.\n   */\n  readonly subjectAlternativeNames?: string[];\n  /**\n   * Specifies the algorithm of the public and private key pair that your Amazon issued\n   * certificate uses to encrypt data.\n   * See [ACM Certificate characteristics][acm-certificate-algorithms] for more details.\n   *\n   * @default RSA_2048\n   *\n   * [acm-certificate-algorithms]: https://docs.aws.amazon.com/acm/latest/userguide/acm-certificate-characteristics.html#algorithms\n   */\n  readonly keyAlgorithm?: string;\n  /**\n   * Validation configuration for the certificate.\n   */\n  readonly validation?: CertificateValidationOption;\n}\n\nexport interface CertificateValidationOption {\n  /**\n   * How to validate this certificate\n   *\n   * To validate ownership by adding appropriate DNS records\n   *\n   * @default ValidationMethod.EMAIL\n   *\n   * @see https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-validate-dns.html\n   */\n  readonly method: ValidationMethod;\n  /**\n   * Hosted zone to use for DNS validation\n   *\n   * @default - use email validation\n   */\n  readonly hostedZone?: IDnsZone;\n  /**\n   * A map of hosted zones to use for DNS validation\n   *\n   * @default - use `hostedZone`\n   */\n  readonly hostedZones?: { [domainName: string]: IDnsZone };\n\n  /**\n   * Validation domains to use for email validation\n   *\n   * @default - Apex domain\n   */\n  readonly validationDomains?: { [domainName: string]: string };\n}\n\n/**\n * Amazon issued certificate\n */\nexport class PublicCertificate\n  extends AwsConstructBase\n  implements ICertificate\n{\n  // TODO: Add static fromLookup?\n  resource: acmCertificate.AcmCertificate;\n\n  private readonly _outputs: CertificateOutputs;\n  public get certificateOutputs(): CertificateOutputs {\n    return this._outputs;\n  }\n  public get outputs(): Record<string, any> {\n    return this.certificateOutputs;\n  }\n  private readonly _domainName: string;\n  public get domainName(): string {\n    return this._domainName;\n  }\n  private readonly _certificateArn: string;\n  public get certificateArn(): string {\n    return this._certificateArn;\n  }\n\n  constructor(scope: Construct, id: string, props: PublicCertificateProps) {\n    super(scope, id, props);\n    this._domainName = props.domainName;\n\n    // check if domain name is 64 characters or less\n    if (!Token.isUnresolved(props.domainName) && props.domainName.length > 64) {\n      throw new Error(\"Domain name must be 64 characters or less\");\n    }\n    let { validation } = props;\n    if (!validation) {\n      validation = {\n        method: ValidationMethod.EMAIL,\n        validationDomains: {\n          [props.domainName]: props.domainName,\n        },\n      };\n    }\n\n    const allDomainNames = [props.domainName].concat(\n      props.subjectAlternativeNames || [],\n    );\n\n    const domainValidation = renderDomainValidation(validation, allDomainNames);\n    this.resource = new acmCertificate.AcmCertificate(this, \"Resource\", {\n      ...props,\n      validationMethod: validation.method,\n      validationOption: domainValidation?.Options,\n    });\n\n    if (domainValidation && validation.method === ValidationMethod.DNS) {\n      const records = new Array<RecordSet>();\n      // TODO: Test use case where certificates exist across multiple zones (validation record should allow override)\n      const sortedZones = Object.entries(domainValidation.zoneLookup).sort(\n        ([a], [b]) => a.localeCompare(b),\n      );\n      for (const [domainName, zone] of sortedZones) {\n        const index = records.length;\n        records.push(\n          new RecordSet(this, `ValidationRecord-${domainName}`, {\n            recordType: this.resource.domainValidationOptions.get(index)\n              .resourceRecordType as RecordType,\n            recordName:\n              this.resource.domainValidationOptions.get(index)\n                .resourceRecordName,\n            target: RecordTarget.fromValues(\n              this.resource.domainValidationOptions.get(index)\n                .resourceRecordValue,\n            ),\n            ttl: Duration.seconds(60),\n            zone,\n            allowOverwrite: true, // required to prevent cross region wildcard errors\n          }),\n        );\n      }\n      new acmCertificateValidation.AcmCertificateValidation(\n        this,\n        \"Validation\",\n        {\n          certificateArn: this.resource.arn,\n          validationRecordFqdns: records.map((record) => record.fqdn),\n        },\n      );\n      // // terraform-provider-aws bug, can't use TerraformIterator (`for_each`) here:\n      // // https://github.com/hashicorp/terraform-cdk/issues/3713\n      // const zoneLookup: TerraformLocal = new TerraformLocal( this, \"zoneLookup\", domainValidation.zoneLookup);\n      // const domainValidationIterator = TerraformIterator.fromComplexList( this.resource.domainValidationOptions, \"domain_name\");\n      // // RecordSet doesn't work with zone = IResolvable\n      // // using Route53Record resource directly\n      // const records = new route53Record.Route53Record( this, \"ValidationRecords\", {\n      //   forEach: domainValidationIterator,\n      //   allowOverwrite: true,\n      //   name: domainValidationIterator.getString(\"resource_record_name\"),\n      //   records: [\n      //     domainValidationIterator.getString(\"resource_record_value\"),\n      //   ],\n      //   ttl: 60,\n      //   type: domainValidationIterator.getString(\"resource_record_type\"),\n      //   zoneId: Fn.lookup(zoneLookup, domainValidationIterator.key),\n      // });\n      // const recordsIterator = TerraformIterator.fromResources(records);\n      // new acmCertificateValidation.AcmCertificateValidation( this, \"Validation\", {\n      //   certificateArn: this.resource.arn,\n      //   validationRecordFqdns: Token.asList(\n      //     recordsIterator.pluckProperty(\"fqdn\"),\n      //   ),\n      // });\n    }\n\n    this._certificateArn = this.resource.arn;\n    this._outputs = {\n      arn: this.resource.arn,\n      status: this.resource.status,\n      domainValidationOptions: this.resource.domainValidationOptions,\n    };\n  }\n}\n\n/**\n * Method used to assert ownership of the domain\n */\nexport enum ValidationMethod {\n  /**\n   * Send email to a number of email addresses associated with the domain\n   *\n   * IMPORTANT: if you are creating a certificate as part of your stack, the stack\n   * will not complete creating until you read and follow the instructions in the\n   * email that you will receive.\n   *\n   * ACM will send validation emails to the following addresses:\n   *\n   *  admin@domain.com\n   *  administrator@domain.com\n   *  hostmaster@domain.com\n   *  postmaster@domain.com\n   *  webmaster@domain.com\n   *\n   * For every domain that you register.\n   *\n   * @see https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-validate-email.html\n   */\n  EMAIL = \"EMAIL\",\n\n  /**\n   * Validate ownership by adding appropriate DNS records\n   *\n   * IMPORTANT: If `hostedZone` is not specified, DNS records must be added\n   * manually and the stack will not complete creating until the records are\n   * added.\n   *\n   * @see https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-validate-dns.html\n   */\n  DNS = \"DNS\",\n}\n\ninterface DomainValidation {\n  Options: acmCertificate.AcmCertificateValidationOption[];\n  zoneLookup: { [domainName: string]: IDnsZone }; // string };\n}\n\nfunction renderDomainValidation(\n  validation: CertificateValidationOption,\n  domainNames: string[],\n): DomainValidation | undefined {\n  const result: DomainValidation = {\n    Options: [],\n    zoneLookup: {},\n  };\n\n  switch (validation.method) {\n    case ValidationMethod.DNS:\n      for (const domainName of getUniqueDnsDomainNames(domainNames)) {\n        const hostedZone =\n          validation.hostedZones?.[domainName] ?? validation.hostedZone;\n        if (hostedZone) {\n          result.Options.push({\n            domainName,\n            validationDomain: hostedZone.zoneName,\n          });\n          result.zoneLookup[domainName] = hostedZone; // .zoneId;\n        }\n      }\n      break;\n    case ValidationMethod.EMAIL:\n      for (const domainName of domainNames) {\n        const validationDomain = validation.validationDomains?.[domainName];\n        if (!validationDomain) {\n          throw new Error(\n            \"When using email for validation, 'validationDomains' needs to be supplied\",\n          );\n        }\n        result.Options.push({\n          domainName,\n          validationDomain: validationDomain,\n        });\n      }\n      break;\n    default:\n      throw new Error(`Unknown validation method ${validation.method}`);\n  }\n\n  return result.Options.length !== 0 ? result : undefined;\n}\n\n/**\n * Removes wildcard domains (*.example.com) where the base domain (example.com) is present.\n * This is because the DNS validation treats them as the same thing, and the Route53 records\n * resources would be duplicated causing apply-time errors.\n */\nfunction getUniqueDnsDomainNames(domainNames: string[]) {\n  return domainNames.filter((domain) => {\n    return (\n      Token.isUnresolved(domain) ||\n      !domain.startsWith(\"*.\") ||\n      !domainNames.includes(domain.replace(\"*.\", \"\"))\n    );\n  });\n}\n"]}