ac360

aj.stuyvenberg

dschep

eahefnawy

pmuens

@serverless/domain

    "test": "echo \"Error: no test specified\" && exit 1",

- Static websites hosted on AWS CloudFront & AWS S3 via the Website Component.

      admin: ${anotherWebsiteComponentInstance}

First, you must purchase your domain within Route53 manually.  Then add it to the Component, as demonstrated above.

When used with the Website Component, the domain component will...

- Create an AWS ACM Certificate, if one does not already exists for the domain.

- Create an AWS Cloudfront Distribution that uses the AWS ACM Certificate.

- Create Records in AWS Route 53 to point your custom domain to your AWS Cloudfront Distribution.

const { Component } = require('@serverless/core')

    this.context.debug(`Starting Domain component deployment.`)

    this.context.debug(`Validating inputs.`)

    inputs.region = inputs.region || 'us-east-1'

      throw Error(`"domain" is a required input.`)

    // TODO: Check if domain has changed.

    // On domain change, call remove for all previous state.

    const clients = getClients(this.context.credentials.aws)

    this.context.debug(`Formatting domains and identifying cloud services being used.`)

    const subdomains = prepareSubdomains(inputs)

    this.context.debug(`Getting the Hosted Zone ID for the domain ${inputs.domain}.`)

    const domainHostedZoneId = await getDomainHostedZoneId(clients.route53, inputs.domain)

      `Searching for an AWS ACM Certificate based on the domain: ${inputs.domain}.`

    let certificateArn = await getCertificateArnByDomain(clients.acm, inputs.domain)

      this.context.debug(`No existing AWS ACM Certificates found for the domain: ${inputs.domain}.`)

      this.context.debug(`Creating a new AWS ACM Certificate for the domain: ${inputs.domain}.`)

      certificateArn = await createCertificate(clients.acm, inputs.domain)

    this.context.debug(`Checking the status of AWS ACM Certificate.`)

    const certificate = await describeCertificateByArn(clients.acm, certificateArn)

    if (certificate.Status === 'PENDING_VALIDATION') {

      this.context.debug(`AWS ACM Certificate Validation Status is "PENDING_VALIDATION".`)

      this.context.debug(`Validating AWS ACM Certificate via Route53 "DNS" method.`)

        'Your AWS ACM Certificate has been created and is being validated via DNS.  This could take up to 30 minutes since it depends on DNS propagation.  Continuining deployment, but you may have to wait for DNS propagation.'

    if (certificate.Status !== 'ISSUED' && certificate.Status !== 'PENDING_VALIDATION') {

      // TODO: Should we auto-create a new one in this scenario?

        `Your AWS ACM Certificate for the domain "${inputs.domain}" has an unsupported status of: "${certificate.Status}".  Please remove it manually and deploy again.`

    // Setting up domains for different services

    for (const subdomain of subdomains) {

      if (subdomain.type === 'awsS3Website') {

        this.context.debug(`Configuring domain "${subdomain.domain}" for S3 Bucket Website`)

        this.context.debug(`Checking CloudFront distribution for domain "${subdomain.domain}"`)

        let distribution = await getCloudFrontDistributionByDomain(clients.cf, subdomain.domain)

            `CloudFront distribution for domain "${subdomain.domain}" not found. Creating...`

          distribution = await createCloudfrontDistribution(

        } else if (!distribution.origins.includes(`${subdomain.s3BucketName}.s3.amazonaws.com`)) {

          this.context.debug(`Updating distribution "${distribution.url}".`)

          distribution = await updateCloudfrontDistribution(clients.cf, subdomain, distribution.id)

        this.context.debug(`Configuring DNS for distribution "${distribution.url}".`)

        await configureDnsForCloudFrontDistribution(

        this.context.debug(`Invalidating CloudFront distribution ${distribution.url}`)

        await invalidateCloudfrontDistribution(clients.cf, distribution.id)

        this.context.debug(`Using AWS Cloudfront Distribution with URL: "${subdomain.domain}"`)

      } else if (subdomain.type === 'awsApiGateway') {

        // Map APIG domain to API ID and recursively retry

        // if APIG domain need to be created first, or TooManyRequests error is thrown

          this // passing instance for helpful logs during the process

      // TODO: Remove unused domains that are kept in state

    outputs.domains = subdomains.map((subdomain) => {

      if (subdomain.domain.startsWith('www')) {

      return `https://${subdomain.domain}`

    const clients = getClients(this.context.credentials.aws, this.state.region)

    this.context.debug(`Getting the Hosted Zone ID for the domain ${this.state.domain}.`)

    const domainHostedZoneId = await getDomainHostedZoneId(clients.route53, this.state.domain)

    for (const subdomain in this.state.subdomains) {

      const domainState = this.state.subdomains[subdomain]

      if (domainState.type === 'awsS3Website') {

          `Fetching CloudFront distribution info for removal for domain ${domainState.domain}.`

        const distribution = await getCloudFrontDistributionByDomain(clients.cf, domainState.domain)

          this.context.debug(`Removing DNS records for website domain ${domainState.domain}.`)

          await removeWebsiteDomainDnsRecords(

          if (domainState.domain.startsWith('wwww')) {

          if (domainState.domain.startsWith('www')) {

            await removeWebsiteDomainDnsRecords(

              domainState.domain.repalce('www.', ''), // it'll move on if it doesn't exist

              domainState.domain.replace('www.', ''), // it'll move on if it doesn't exist

      } else if (domainState.type === 'awsApiGateway') {

          `Fetching API Gateway domain ${domainState.domain} information for removal.`

        const domainRes = await getApiDomainName(clients.apig, domainState.domain)

          this.context.debug(`Removing API Gateway domain ${domainState.domain}.`)

          await removeApiDomain(clients.apig, domainState.domain)

          this.context.debug(`Removing DNS records for API Gateway domain ${domainState.domain}.`)

          await removeApiDomainDnsRecords(

            domainRes.distributionHostedZoneId,

            domainRes.distributionDomainName

const { utils } = require('@serverless/core')

 * - Gets AWS SDK clients to use within this Component

const getClients = (credentials, region = 'us-east-1') => {

    region: 'us-east-1' // ACM must be in us-east-1

 * - Formats component domains & identifies cloud services they're using.

  for (const subdomain in inputs.subdomains || {}) {

    domainObj.domain = `${subdomain}.${inputs.domain}`

    if (inputs.subdomains[subdomain].url.includes('s3')) {

      // Get S3 static hosting endpoint of existing bucket to use w/ CloudFront.

      // todo this doesn't work with bucket names with periods

      domainObj.s3BucketName = inputs.subdomains[subdomain].url.replace('http://', '').split('.')[0]

    // Check if referenced Component is using AWS API Gateway...

    if (inputs.subdomains[subdomain].url.includes('execute-api')) {

      domainObj.apiId = inputs.subdomains[subdomain].url.split('.')[0].split('//')[1]

const getOutdatedDomains = (inputs, state) => {

  for (const domain of Object.keys(state.dns)) {

  for (const domain of state.subdomains) {

    if (!inputs.subdomains[domain.domain]) {

 * - Every Domain on Route53 always has a Hosted Zone w/ 2 Record Sets.

 * - These Record Sets are: "Name Servers (NS)" & "Start of Authority (SOA)"

 * - These don't need to be created and SHOULD NOT be modified.

const getDomainHostedZoneId = async (route53, domain) => {

  const hostedZonesRes = await route53.listHostedZonesByName().promise()

  const hostedZone = hostedZonesRes.HostedZones.find(

    // Name has a period at the end, so we're using includes rather than equals

      `Domain ${domain} was not found in your AWS account. Please purchase it from Route53 first then try again.`

  return hostedZone.Id.replace('/hostedzone/', '') // hosted zone id is always prefixed with this :(

 * - Describe an AWS ACM Certificate by its ARN

const describeCertificateByArn = async (acm, certificateArn) => {

  const certificate = await acm.describeCertificate({ CertificateArn: certificateArn }).promise()

  return certificate && certificate.Certificate ? certificate.Certificate : null

 * - Gets an AWS ACM Certificate by a specified domain or return null

const getCertificateArnByDomain = async (acm, domain) => {

  const listRes = await acm.listCertificates().promise()

  const certificate = listRes.CertificateSummaryList.find((cert) => cert.DomainName === domain)

  return certificate && certificate.CertificateArn ? certificate.CertificateArn : null

 * - Creates an AWS ACM Certificate for the specified domain

const createCertificate = async (acm, domain) => {

  const wildcardSubDomain = `*.${domain}`

    SubjectAlternativeNames: [domain, wildcardSubDomain],

  const res = await acm.requestCertificate(params).promise()

 * - Validate an AWS ACM Certificate via the "DNS" method

const validateCertificate = async (acm, route53, certificate, domain, domainHostedZoneId) => {

   * - Newly Created AWS ACM Certificates may not yet have the info needed to validate it

   * - Specifically, the "ResourceRecord" object in the Domain Validation Options

  const checkReadiness = async function() {

        'Your newly created AWS ACM Certificate is taking a while to initialize.  Please try running this component again in a few minutes.'

    const cert = await describeCertificateByArn(acm, certificate.CertificateArn)

    // Find root domain validation option resource record

    cert.DomainValidationOptions.forEach((option) => {

      if (domain === option.DomainName) {

        validationResourceRecord = option.ResourceRecord

		{
		"name": "@serverless/domain",
		"version": "2.0.6",
		"version": "2.0.7",
		"main": "./serverless.js",
		@@ -5,0 +5,0 @@ "publishConfig": {

		@@ -16,4 +16,4 @@ # Domain
		domain: mywebsite.com
		dns:
		$: ${websiteComponentInstance}
		subdomains:
		www: ${websiteComponentInstance}
		api: ${backendComponentInstance}
		@@ -20,0 +20,0 @@ admin: ${anotherWebsiteComponentInstance}

		@@ -75,6 +75,14 @@ const aws = require('aws-sdk')

		for (const domain of Object.keys(state.dns)) {
		if (!inputs.dns[domain]) {
		const outdatedDomains = {
		domain: state.domain,
		subdomains: []
		}

		for (const domain of state.subdomains) {
		if (!inputs.subdomains[domain.domain]) {
		outdatedDomains.push(domain)
		}
		}

		return outdatedDomains
		}
		@@ -728,2 +736,3 @@
		}

		/**
		@@ -736,2 +745,3 @@ * Exports
		prepareSubdomains,
		getOutdatedDomains,
		describeCertificateByArn,
		@@ -738,0 +748,0 @@ getCertificateArnByDomain,

		@@ -33,2 +33,3 @@ const { Component } = require('@serverless/core')
		inputs.region = inputs.region \|\| 'us-east-1'

		if (!inputs.domain) {
		@@ -46,2 +47,3 @@ throw Error(`"domain" is a required input.`)
		const subdomains = prepareSubdomains(inputs)
		this.state.region = inputs.region
		this.state.domain = inputs.domain
		@@ -169,3 +171,3 @@ this.state.subdomains = subdomains
		// Get AWS SDK Clients
		const clients = getClients(this.context.credentials.aws)
		const clients = getClients(this.context.credentials.aws, this.state.region)

		@@ -192,6 +194,6 @@ this.context.debug(`Getting the Hosted Zone ID for the domain ${this.state.domain}.`)

		if (domainState.domain.startsWith('wwww')) {
		if (domainState.domain.startsWith('www')) {
		await removeWebsiteDomainDnsRecords(
		clients.route53,
		domainState.domain.repalce('www.', ''), // it'll move on if it doesn't exist
		domainState.domain.replace('www.', ''), // it'll move on if it doesn't exist
		domainHostedZoneId,
		@@ -198,0 +200,0 @@ distribution.url

Improved metrics