index.js

const path = require('path');
const _ = require('lodash');
const chalk = require('chalk');
const yaml = require('js-yaml');
const fs = require('fs');

const certStatuses = ['PENDING_VALIDATION', 'ISSUED', 'INACTIVE'];

class ServerlessAppSyncCloudFrontPlugin {
  constructor(serverless, options) {
    this.serverless = serverless;
    this.options = options;
    this.hooks = {
        'package:createDeploymentArtifacts': this.createDeploymentArtifacts.bind(this),
        'aws:info:displayStackOutputs': this.printSummary.bind(this),
      };

    this.hooks = {
      'package:createDeploymentArtifacts': this.createDeploymentArtifacts.bind(this),
      'aws:info:displayStackOutputs': this.printSummary.bind(this),
    };
  }

  async createDeploymentArtifacts() {
    this.givenDomainName = this.serverless.service.custom.appSyncCloudFront.domainName;
    const credentials = this.serverless.providers.aws.getCredentials();
    const acmCredentials = Object.assign({}, credentials, { region: 'us-east-1' });
    this.acm = new this.serverless.providers.aws.sdk.ACM(acmCredentials);
    this.route53 = new this.serverless.providers.aws.sdk.Route53(credentials);

    const baseResources = this.serverless.service.provider.compiledCloudFormationTemplate;

    const filename = path.resolve(__dirname, 'resources.yml');
    const content = fs.readFileSync(filename, 'utf-8');
    const resources = yaml.safeLoad(content, {
      filename,
    });

    await this.prepareResources(resources);
    return _.merge(baseResources, resources);
  }

  async printSummary() {
    const awsInfo = _.find(this.serverless.pluginManager.getPlugins(), plugin => (
      plugin.constructor.name === 'AwsInfo'
    ));

    if (!awsInfo || !awsInfo.gatheredData) {
      return;
    }

    const { outputs } = awsInfo.gatheredData;
    const apiDistributionDomain = _.find(outputs, output => (
      output.OutputKey === 'AppSyncApiDistribution'
    ));

    if (!apiDistributionDomain || !apiDistributionDomain.OutputValue) {
      return;
    }

    const cnameDomain = this.getConfig('domainName', null);
    this.serverless.cli.consoleLog(chalk.yellow('CloudFront domain name'));
    this.serverless.cli.consoleLog(`  ${apiDistributionDomain.OutputValue} (CNAME: ${cnameDomain || '-'})`);

    if (cnameDomain) {
      this.serverless.cli.consoleLog(`AppSync: ${chalk.yellow(`Creating Route53 records for ${cnameDomain}...`)}`);

      this.changeResourceRecordSet('UPSERT', apiDistributionDomain.OutputValue);
    }
  }

  /**
   * Gets Certificate ARN that most closely matches domain name OR given Cert ARN if provided
   */
  async getCertArn() {
    let certificateArn; // The arn of the choosen certificate
    let { certificateName } = this.serverless.service.custom.appSyncCloudFront; // The certificate name
    const { domainName } = this.serverless.service.custom.appSyncCloudFront; // Domain name
    try {
      const certData = await this.acm.listCertificates(
        { CertificateStatuses: certStatuses },
      ).promise();

      // The more specific name will be the longest
      let nameLength = 0;
      const certificates = certData.CertificateSummaryList;

      // Checks if a certificate name is given
      if (certificateName != null) {
        const foundCertificate = certificates
          .find(certificate => (certificate.DomainName === certificateName));
        if (foundCertificate != null) {
          certificateArn = foundCertificate.CertificateArn;
        }
      } else {
        certificateName = domainName;
        certificates.forEach((certificate) => {
          let certificateListName = certificate.DomainName;
          // Looks for wild card and takes it out when checking
          if (certificateListName[0] === '*') {
            certificateListName = certificateListName.substr(1);
          }
          // Looks to see if the name in the list is within the given domain
          // Also checks if the name is more specific than previous ones
          if (certificateName.includes(certificateListName)
            && certificateListName.length > nameLength) {
            nameLength = certificateListName.length;
            certificateArn = certificate.CertificateArn;
          }
        });
      }
    } catch (err) {
      throw Error(`Error: Could not list certificates in Certificate Manager.\n${err}`);
    }
    if (certificateArn == null) {
      throw Error(`Error: Could not find the certificate ${certificateName}.`);
    }
    return certificateArn;
  }

  /**
 * Change A Alias record through Route53 based on given action
 * @param action: String descriptor of change to be made. Valid actions are ['UPSERT', 'DELETE']
 * @param domain: DomainInfo object containing info about custom domain
 */
  async changeResourceRecordSet(action, domain) {
    if (action !== 'UPSERT' && action !== 'DELETE') {
      throw new Error(`Error: Invalid action "${action}" when changing Route53 Record.
                Action must be either UPSERT or DELETE.\n`);
    }

    const createRoute53Record = this.getConfig('createRoute53Record', null);
    if (createRoute53Record !== undefined && createRoute53Record === false) {
      this.serverless.cli.log('Skipping creation of Route53 record.');
      return;
    }
    // Set up parameters
    const route53HostedZoneId = await this.getRoute53HostedZoneId();
    const Changes = ['A', 'AAAA'].map(Type => ({
      Action: action,
      ResourceRecordSet: {
        AliasTarget: {
          DNSName: domain,
          EvaluateTargetHealth: false,
          HostedZoneId: 'Z2FDTNDATAQYW2', // CloudFront HZID is always Z2FDTNDATAQYW2
        },
        Name: this.givenDomainName,
        Type,
      },
    }));
    const params = {
      ChangeBatch: {
        Changes,
        Comment: 'Record created by serverless-appsync-cloudfront',
      },
      HostedZoneId: route53HostedZoneId,
    };
    // Make API call
    try {
      await this.route53.changeResourceRecordSets(params).promise();
    } catch (err) {
      throw new Error(`Error: Failed to ${action} A Alias for ${this.givenDomainName}\n`);
    }
  }

  /**
   * Gets Route53 HostedZoneId from user or from AWS
   */
  async getRoute53HostedZoneId() {
    if (this.serverless.service.custom.appSyncCloudFront.hostedZoneId) {
      this.serverless.cli.log(
        `Selected specific hostedZoneId ${this.serverless.service.custom.appSyncCloudFront.hostedZoneId}`);
      return this.serverless.service.custom.appSyncCloudFront.hostedZoneId;
    }

    const filterZone = this.hostedZonePrivate !== undefined;
    if (filterZone && this.hostedZonePrivate) {
      this.serverless.cli.log('Filtering to only private zones.');
    } else if (filterZone && !this.hostedZonePrivate) {
      this.serverless.cli.log('Filtering to only public zones.');
    }

    let hostedZoneData;
    const givenDomainNameReverse = this.givenDomainName.split('.').reverse();

    try {
      hostedZoneData = await this.route53.listHostedZones({}).promise();
      const targetHostedZone = hostedZoneData.HostedZones
        .filter((hostedZone) => {
          let hostedZoneName;
          if (hostedZone.Name.endsWith('.')) {
            hostedZoneName = hostedZone.Name.slice(0, -1);
          } else {
            hostedZoneName = hostedZone.Name;
          }
          if (!filterZone || this.hostedZonePrivate === hostedZone.Config.PrivateZone) {
            const hostedZoneNameReverse = hostedZoneName.split('.').reverse();

            if (givenDomainNameReverse.length === 1
              || (givenDomainNameReverse.length >= hostedZoneNameReverse.length)) {
              for (let i = 0; i < hostedZoneNameReverse.length; i += 1) {
                if (givenDomainNameReverse[i] !== hostedZoneNameReverse[i]) {
                  return false;
                }
              }
              return true;
            }
          }
          return false;
        })
        .sort((zone1, zone2) => zone2.Name.length - zone1.Name.length)
        .shift();

      if (targetHostedZone) {
        const hostedZoneId = targetHostedZone.Id;
        // Extracts the hostzone Id
        const startPos = hostedZoneId.indexOf('e/') + 2;
        const endPos = hostedZoneId.length;
        return hostedZoneId.substring(startPos, endPos);
      }
    } catch (err) {
      this.logIfDebug(err);
      throw new Error(`Error: Unable to list hosted zones in Route53.\n${err}`);
    }
    throw new Error(`Error: Could not find hosted zone "${this.givenDomainName}"`);
  }


  async prepareResources(resources) {
    const distributionConfig = resources.Resources.AppSyncApiDistribution.Properties.DistributionConfig;

    this.prepareLogging(distributionConfig);
    this.prepareDomain(distributionConfig);
    this.preparePriceClass(distributionConfig);
    // this.prepareOrigins(distributionConfig);
    this.prepareCookies(distributionConfig);
    this.prepareHeaders(distributionConfig);
    this.prepareQueryString(distributionConfig);
    this.prepareComment(distributionConfig);
    await this.prepareCertificate(distributionConfig);
    this.prepareWaf(distributionConfig);
    this.prepareCompress(distributionConfig);
    this.prepareMinimumProtocolVersion(distributionConfig);
  }

  prepareLogging(distributionConfig) {
    const loggingBucket = this.getConfig('logging.bucket', null);

    if (loggingBucket !== null) {
      distributionConfig.Logging.Bucket = loggingBucket;
      distributionConfig.Logging.Prefix = this.getConfig('logging.prefix', '');
    } else {
      delete distributionConfig.Logging;
    }
  }

  prepareDomain(distributionConfig) {
    const domain = this.getConfig('domainName', null);
    if (domain !== null) {
      distributionConfig.Aliases = Array.isArray(domain) ? domain : [domain];
    } else {
      delete distributionConfig.Aliases;
    }
  }

  preparePriceClass(distributionConfig) {
    const priceClass = this.getConfig('priceClass', 'PriceClass_All');
    distributionConfig.PriceClass = priceClass;
  }

  // prepareOrigins(distributionConfig) {
  //   distributionConfig.Origins[0].OriginPath = `/${this.options.stage}`;
  // }

  prepareCookies(distributionConfig) {
    const forwardCookies = this.getConfig('cookies', 'all');
    distributionConfig.DefaultCacheBehavior.ForwardedValues.Cookies.Forward = Array.isArray(forwardCookies) ? 'whitelist' : forwardCookies;
    if (Array.isArray(forwardCookies)) {
      distributionConfig.DefaultCacheBehavior.ForwardedValues.Cookies.WhitelistedNames = forwardCookies;
    }
  }

  prepareHeaders(distributionConfig) {
    const forwardHeaders = this.getConfig('headers', 'none');

    if (Array.isArray(forwardHeaders)) {
      distributionConfig.DefaultCacheBehavior.ForwardedValues.Headers = forwardHeaders;
    } else {
      distributionConfig.DefaultCacheBehavior.ForwardedValues.Headers = forwardHeaders === 'none' ? [] : ['*'];
    }
  }

  prepareQueryString(distributionConfig) {
    const forwardQueryString = this.getConfig('querystring', 'all');

    if (Array.isArray(forwardQueryString)) {
      distributionConfig.DefaultCacheBehavior.ForwardedValues.QueryString = true;
      distributionConfig.DefaultCacheBehavior.ForwardedValues.QueryStringCacheKeys = forwardQueryString;
    } else {
      distributionConfig.DefaultCacheBehavior.ForwardedValues.QueryString = forwardQueryString === 'all';
    }
  }

  prepareComment(distributionConfig) {
    const name = this.serverless.getProvider('aws').naming.getApiGatewayName();
    distributionConfig.Comment = `Serverless Managed ${name}`;
  }

  async prepareCertificate(distributionConfig) {
    const certificate = this.getConfig('certificate', null) || await this.getCertArn();

    if (certificate !== null) {
      distributionConfig.ViewerCertificate.AcmCertificateArn = certificate;
    } else {
      delete distributionConfig.ViewerCertificate;
    }
  }

  prepareWaf(distributionConfig) {
    const waf = this.getConfig('waf', null);

    if (waf !== null) {
      distributionConfig.WebACLId = waf;
    } else {
      delete distributionConfig.WebACLId;
    }
  }

  prepareCompress(distributionConfig) {
    distributionConfig.DefaultCacheBehavior.Compress = (this.getConfig('compress', false) === true);
  }

  prepareMinimumProtocolVersion(distributionConfig) {
    const minimumProtocolVersion = this.getConfig('minimumProtocolVersion', undefined);

    if (minimumProtocolVersion) {
      distributionConfig.ViewerCertificate.MinimumProtocolVersion = minimumProtocolVersion;
    }
  }

  getConfig(field, defaultValue) {
    return _.get(this.serverless, `service.custom.appSyncCloudFront.${field}`, defaultValue);
  }
}

module.exports = ServerlessAppSyncCloudFrontPlugin;