async update()

in provider-utils/awscloudformation/cloudformation-templates/livestream-helpers/LambdaFunctions/psdemo-js-live-workflow_v0.4.0/lib/babelfish.js [501:626]
105 lines of code
20 McCabe index (conditional complexity)

  async update() {
    // first get existing endpoints

    const diff = this.compareUpdates(this.$event.OldResourceProperties, this.$event.ResourceProperties);
    if (Object.keys(diff).length === 0) {
      return 'Nothing has changed';
    }

    const response = await this.describeChannel();
    const {
      OriginEndpoints,
    } = await this.listOrigins();
    const { Id, Arn, HlsIngest: { IngestEndpoints } } = response;
    this.storeResponseData('Id', Id);
    this.storeResponseData('Arn', Arn);
    /* store parameters as list, comma separator */
    ['Url', 'Username', 'Password'].forEach((k) => {
      this.storeResponseData(k, IngestEndpoints.map(x => x[k]).join(','));
    });

    const streamsUp = OriginEndpoints.map(x => x.Id.replace(`${this.channelId.toLowerCase()}-`, '').toUpperCase());

    let promises = streamsUp.map((x) => {
      const location = diff.PS_ENDPOINTS.indexOf(x);
      let params;
      if (location >= 0) {
        // Update'
        switch (x.toLowerCase()) {
          case 'hls':
            params = this.createHlsPackageParams();
            break;
          case 'dash':
            params = this.createDashPackageParams();
            break;
          case 'mss':
            params = this.createMssPackageParams();
            break;
          case 'cmaf':
            params = this.createCmafPackageParams();
            break;
        }
        delete params.ChannelId;
        diff.PS_ENDPOINTS.splice(location, 1);
        return (params !== undefined)
          ? this.babelfish.updateOriginEndpoint(params).promise()
          : undefined;
      }
      // Delete
      return this.babelfish.deleteOriginEndpoint({ Id: `${this.channelId.toLowerCase()}-${x.toLowerCase()}` }).promise();
    });

    if (diff.PS_ENDPOINTS) {
      const createPromises = diff.PS_ENDPOINTS.map((endpoint) => {
        let params;
        switch (endpoint.toLowerCase()) {
          case 'hls':
            params = this.createHlsPackageParams();
            break;
          case 'dash':
            params = this.createDashPackageParams();
            break;
          case 'mss':
            params = this.createMssPackageParams();
            break;
          case 'cmaf':
            params = this.createCmafPackageParams();
            break;
          default:
            console.log(`${endpoint} NOT IMPL`);
            params = undefined;
        }
        return (params !== undefined)
          ? this.babelfish.createOriginEndpoint(params).promise()
          : undefined;
      });
      promises = promises.concat(createPromises);
    }
    const responses = await Promise.all(promises);

    /* even if package is not created, we still need to report it to CF */
    const initSettings = {
      HlsEndpoint: '',
      DashEndpoint: '',
      MssEndpoint: '',
      CmafEndpoint: '',
    };
    const results = responses.filter(x => Object.keys(x).length > 0).reduce((acc, cur) => {
      const {
        Url, CmafPackage, DashPackage, HlsPackage, MssPackage,
      } = cur;
      if (Object.keys(cur).length != 0) {

      }
      acc.DomainEndpoint = acc.DomainEndpoint || new Set();
      console.log(cur);
      acc.DomainEndpoint.add(URL.parse(Url).hostname);
      if (HlsPackage) {
        return Object.assign({}, acc, { HlsEndpoint: Url });
      }
      if (DashPackage) {
        return Object.assign({}, acc, { DashEndpoint: Url });
      }
      if (MssPackage) {
        return Object.assign({}, acc, { MssEndpoint: Url });
      }
      if (CmafPackage) {
        return Object.assign({}, acc, { CmafEndpoint: CmafPackage.HlsManifests[0].Url });
      }
      return acc;
    }, initSettings);
    /* serialize DomainName array */
    // results.DomainEndpoint = Array.from(results.DomainEndpoint).join(',');
    /**
     * CAUTION: AWS::CloudFront::Distribution could only take a single origin (string)
     * If we would need to support multiple origins, we might need to go with CustomResource!
     */
    const [DomainEndpoint] = Array.from(results.DomainEndpoint);
    results.DomainEndpoint = DomainEndpoint;

    this.storeResponseData('ParameterStoreKey', `${this.ssmKey}-0,${this.ssmKey}-1`);

    Object.keys(results).forEach(x => this.storeResponseData(x, results[x]));

    console.log(`responseData = ${JSON.stringify(this.responseData, null, 2)}`);
    return this.responseData;
  }