electron-publisher-s3/out/s3Publisher.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

function _bluebirdLst() {
  const data = require("bluebird-lst");

  _bluebirdLst = function () {
    return data;
  };

  return data;
}

function _s() {
  const data = _interopRequireDefault(require("aws-sdk/clients/s3"));

  _s = function () {
    return data;
  };

  return data;
}

function _builderUtil() {
  const data = require("builder-util");

  _builderUtil = function () {
    return data;
  };

  return data;
}

function _BaseS3Publisher() {
  const data = require("./BaseS3Publisher");

  _BaseS3Publisher = function () {
    return data;
  };

  return data;
}

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

class S3Publisher extends _BaseS3Publisher().BaseS3Publisher {
  constructor(context, info) {
    super(context, info);
    this.info = info;
    this.providerName = "S3";
  }

  static checkAndResolveOptions(options, channelFromAppVersion, errorIfCannot) {
    return (0, _bluebirdLst().coroutine)(function* () {
      const bucket = options.bucket;

      if (bucket == null) {
        throw new (_builderUtil().InvalidConfigurationError)(`Please specify "bucket" for "s3" publish provider`);
      }

      if (options.endpoint == null && bucket.includes(".") && options.region == null) {
        // on dotted bucket names, we need to use a path-based endpoint URL. Path-based endpoint URLs need to include the region.
        const s3 = new (_s().default)({
          signatureVersion: "v4"
        });

        try {
          options.region = (yield s3.getBucketLocation({
            Bucket: bucket
          }).promise()).LocationConstraint;
        } catch (e) {
          if (errorIfCannot) {
            throw e;
          } else {
            _builderUtil().log.warn(`cannot compute region for bucket (required because on dotted bucket names, we need to use a path-based endpoint URL): ${e}`);
          }
        }
      }

      if (options.channel == null && channelFromAppVersion != null) {
        options.channel = channelFromAppVersion;
      }
    })();
  }

  createClientConfiguration() {
    const configuration = super.createClientConfiguration();
    const endpoint = this.info.endpoint;

    if (endpoint != null) {
      configuration.endpoint = endpoint;
      configuration.s3ForcePathStyle = true;
    }

    return configuration;
  }

  getBucketName() {
    return this.info.bucket;
  }

  configureS3Options(s3Options) {
    super.configureS3Options(s3Options);

    if (this.info.storageClass != null) {
      s3Options.StorageClass = this.info.storageClass;
    }

    if (this.info.encryption != null) {
      s3Options.ServerSideEncryption = this.info.encryption;
    }
  }

  toString() {
    const result = super.toString();
    const endpoint = this.info.endpoint;

    if (endpoint != null) {
      return result.substring(0, result.length - 1) + `, endpoint: ${endpoint})`;
    }

    return result;
  }

} exports.default = S3Publisher;
//# sourceMappingURL=s3Publisher.js.map