@commercetools-frontend/application-cli 2.1.2 → 2.3.0

package/cli/dist/commercetools-frontend-application-cli-cli.esm.js

@@ -12,20 +12,23 @@ import _defineProperty from '@babel/runtime-corejs3/helpers/esm/defineProperty';
 import _mapInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/map';
 import _Object$entries from '@babel/runtime-corejs3/core-js-stable/object/entries';
 import _Set from '@babel/runtime-corejs3/core-js-stable/set';
-import _flatInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/flat';
+import _flatMapInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/flat-map';
+import { s as storageProviders, l as loadStorageBucketsConfig, c as clusterContexts } from '../../dist/storage-buckets-config-705b6341.esm.js';
 import fs from 'node:fs';
 import path$1 from 'node:path';
 import { Listr } from 'listr2';
 import execa from 'execa';
-import { cosmiconfig } from 'cosmiconfig';
 import { findRootSync } from '@manypkg/find-root';
 import path from 'path';
 import _possibleConstructorReturn from '@babel/runtime-corejs3/helpers/esm/possibleConstructorReturn';
+import _assertThisInitialized from '@babel/runtime-corejs3/helpers/esm/assertThisInitialized';
 import _get from '@babel/runtime-corejs3/helpers/esm/get';
 import _getPrototypeOf from '@babel/runtime-corejs3/helpers/esm/getPrototypeOf';
 import _inherits from '@babel/runtime-corejs3/helpers/esm/inherits';
 import _classCallCheck from '@babel/runtime-corejs3/helpers/esm/classCallCheck';
 import _createClass from '@babel/runtime-corejs3/helpers/esm/createClass';
+import _classPrivateFieldLooseBase from '@babel/runtime-corejs3/helpers/esm/classPrivateFieldLooseBase';
+import _classPrivateFieldLooseKey from '@babel/runtime-corejs3/helpers/esm/classPrivateFieldLooseKey';
 import _Reflect$construct from '@babel/runtime-corejs3/core-js-stable/reflect/construct';
 import fs$1 from 'fs';
 import dotenv from 'dotenv';
@@ -33,9 +36,9 @@ import _findInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instanc
 import _JSON$stringify from '@babel/runtime-corejs3/core-js-stable/json/stringify';
 import { processConfig } from '@commercetools-frontend/application-config';
 import { getSupportedLocales } from '@commercetools-frontend/l10n';
-import { c as clusterContexts } from '../../dist/storage-buckets-config-7845a091.esm.js';
 import _sliceInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/slice';
 import { Validator } from 'jsonschema';
+import 'cosmiconfig';
 import 'ts-deepmerge';
 
 function getApplicationDirectory(cwd) {
@@ -67,23 +70,34 @@ function _callSuper(_this, derived, args) {
   derived = _getPrototypeOf(derived);
   return _possibleConstructorReturn(_this, isNativeReflectConstruct() ? _Reflect$construct(derived, args || [], _getPrototypeOf(_this).constructor) : derived.apply(_this, args));
 }
+var _bucketRegion$1 = /*#__PURE__*/_classPrivateFieldLooseKey("bucketRegion");
+var _bucketEnvironment$1 = /*#__PURE__*/_classPrivateFieldLooseKey("bucketEnvironment");
 let StorageProvider = /*#__PURE__*/function () {
-  function StorageProvider() {
+  function StorageProvider(config) {
     _classCallCheck(this, StorageProvider);
+    _Object$defineProperty(this, _bucketRegion$1, {
+      writable: true,
+      value: void 0
+    });
+    _Object$defineProperty(this, _bucketEnvironment$1, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _bucketRegion$1)[_bucketRegion$1] = config.bucketRegion;
+    _classPrivateFieldLooseBase(this, _bucketEnvironment$1)[_bucketEnvironment$1] = config.bucketEnvironment;
   }
+  /**
+   *  Construct the storage bucket URL for the specific application and cloud environment.
+   *
+   *  1. Static assets are uploaded to `:bucketRegion/:prNumber?/:applicationName`
+   *  2. The application index is uploaded to `:bucketRegion/:prNumber?/:applicationName/:cloudEnvironment`
+   *
+   *  This allows all cloud environments sharing the same static assets while each application's index
+   *  is uploaded with different headers (e.g. CSP rules).
+   */
   _createClass(StorageProvider, [{
     key: "getBucketNamespace",
-    value:
-    /**
-     *  Construct the storage bucket URL for the specific application and cloud environment.
-     *
-     *  1. Static assets are uploaded to `:bucketRegion/:prNumber?/:applicationName`
-     *  2. The application index is uploaded to `:bucketRegion/:prNumber?/:applicationName/:cloudEnvironment`
-     *
-     *  This allows all cloud environments sharing the same static assets while each application's index
-     *  is uploaded with different headers (e.g. CSP rules).
-     */
-    function getBucketNamespace(prNumber) {
+    value: function getBucketNamespace(prNumber) {
       if (!prNumber) return;
       if (prNumber === 'merchant-center-preview') return prNumber;
       return `mc-${prNumber}`;
@@ -96,56 +110,94 @@ let StorageProvider = /*#__PURE__*/function () {
     key: "getAssetsBucketUrl",
     value: function getAssetsBucketUrl(_ref) {
       var _context;
-      let bucketProtocol = _ref.bucketProtocol,
-        bucketRegion = _ref.bucketRegion,
+      let applicationName = _ref.applicationName,
+        bucketProtocol = _ref.bucketProtocol,
         bucketNamespace = _ref.bucketNamespace,
-        applicationName = _ref.applicationName;
-      const assetsBucketUrl = _filterInstanceProperty(_context = [bucketRegion, bucketNamespace, applicationName]).call(_context, Boolean).join('/');
+        tag = _ref.tag;
+      if (!_classPrivateFieldLooseBase(this, _bucketRegion$1)[_bucketRegion$1]) {
+        throw new Error("'bucketRegion' is not defined. Required to determine 'assetsBucketUrl'.");
+      }
+      const storageProvider = storageProviders[tag];
+      const assetBuketUrl = storageProvider.urls.bucket?.[_classPrivateFieldLooseBase(this, _bucketRegion$1)[_bucketRegion$1]] ?? _classPrivateFieldLooseBase(this, _bucketRegion$1)[_bucketRegion$1];
+      const assetsBucketUrl = _filterInstanceProperty(_context = [assetBuketUrl, bucketNamespace, applicationName]).call(_context, Boolean).join('/');
       return `${bucketProtocol}${assetsBucketUrl}`;
     }
   }, {
     key: "getApplicationIndexBucketUrl",
     value: function getApplicationIndexBucketUrl(_ref2) {
-      let bucketProtocol = _ref2.bucketProtocol,
-        bucketRegion = _ref2.bucketRegion,
-        bucketNamespace = _ref2.bucketNamespace,
+      let tag = _ref2.tag,
         prNumber = _ref2.prNumber,
         applicationName = _ref2.applicationName,
-        bucketEnvironment = _ref2.bucketEnvironment;
+        bucketProtocol = _ref2.bucketProtocol,
+        bucketNamespace = _ref2.bucketNamespace;
       const applicationAssetsBucketUrl = this.getAssetsBucketUrl({
-        bucketProtocol,
-        bucketRegion,
-        bucketNamespace,
+        tag,
+        applicationName,
         prNumber,
-        applicationName
+        bucketProtocol,
+        bucketNamespace
       });
-      const applicationIndexBucketUrl = `${applicationAssetsBucketUrl}/${bucketEnvironment}`;
+      const applicationIndexBucketUrl = `${applicationAssetsBucketUrl}/${_classPrivateFieldLooseBase(this, _bucketEnvironment$1)[_bucketEnvironment$1]}`;
       return applicationIndexBucketUrl;
     }
   }, {
     key: "getCdnUrl",
     value: function getCdnUrl(_ref3) {
       var _context2;
-      let publicBaseUrl = _ref3.publicBaseUrl,
-        bucketRegion = _ref3.bucketRegion,
+      let applicationName = _ref3.applicationName,
         prNumber = _ref3.prNumber,
-        applicationName = _ref3.applicationName;
-      return _filterInstanceProperty(_context2 = [publicBaseUrl, bucketRegion, this.getBucketNamespace(prNumber), applicationName]).call(_context2, Boolean).join('/');
+        publicBaseUrl = _ref3.publicBaseUrl,
+        excludeBucketRegion = _ref3.excludeBucketRegion;
+      return _filterInstanceProperty(_context2 = [publicBaseUrl, excludeBucketRegion ? null : _classPrivateFieldLooseBase(this, _bucketRegion$1)[_bucketRegion$1], this.getBucketNamespace(prNumber), applicationName]).call(_context2, Boolean).join('/');
+    }
+  }, {
+    key: "getPublicBaseUrl",
+    value: function getPublicBaseUrl(tag) {
+      if (!_classPrivateFieldLooseBase(this, _bucketEnvironment$1)[_bucketEnvironment$1]) {
+        throw new Error("'bucketEnvironment' is not defined. Required to determine 'publicBaseUrl'.");
+      }
+      const storageProvider = storageProviders[tag];
+      const publicBaseUrl = storageProvider.urls.public[_classPrivateFieldLooseBase(this, _bucketEnvironment$1)[_bucketEnvironment$1]] ?? storageProvider.urls.public.default;
+      return publicBaseUrl;
     }
   }]);
   return StorageProvider;
 }();
+var _bucketRegion2$1 = /*#__PURE__*/_classPrivateFieldLooseKey("bucketRegion");
+var _bucketEnvironment2$1 = /*#__PURE__*/_classPrivateFieldLooseKey("bucketEnvironment");
 let GoogleStorageProvider = /*#__PURE__*/function (_StorageProvider) {
   _inherits(GoogleStorageProvider, _StorageProvider);
-  function GoogleStorageProvider() {
+  function GoogleStorageProvider(config) {
+    var _this;
     _classCallCheck(this, GoogleStorageProvider);
-    return _callSuper(this, GoogleStorageProvider, arguments);
+    _this = _callSuper(this, GoogleStorageProvider, [config]);
+    _Object$defineProperty(_assertThisInitialized(_this), _bucketRegion2$1, {
+      writable: true,
+      value: void 0
+    });
+    _Object$defineProperty(_assertThisInitialized(_this), _bucketEnvironment2$1, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(_assertThisInitialized(_this), _bucketRegion2$1)[_bucketRegion2$1] = config.bucketRegion;
+    _classPrivateFieldLooseBase(_assertThisInitialized(_this), _bucketEnvironment2$1)[_bucketEnvironment2$1] = config.bucketEnvironment;
+    return _this;
   }
   _createClass(GoogleStorageProvider, [{
     key: "getTag",
     value: function getTag() {
       return 'gs';
     }
+  }, {
+    key: "getBucketRegion",
+    value: function getBucketRegion() {
+      return _classPrivateFieldLooseBase(this, _bucketRegion2$1)[_bucketRegion2$1];
+    }
+  }, {
+    key: "getBucketEnvironment",
+    value: function getBucketEnvironment() {
+      return _classPrivateFieldLooseBase(this, _bucketEnvironment2$1)[_bucketEnvironment2$1];
+    }
   }, {
     key: "getProtocol",
     value: function getProtocol() {
@@ -154,7 +206,7 @@ let GoogleStorageProvider = /*#__PURE__*/function (_StorageProvider) {
   }, {
     key: "getPublicBaseUrl",
     value: function getPublicBaseUrl() {
-      return 'https://storage.googleapis.com';
+      return _get(_getPrototypeOf(GoogleStorageProvider.prototype), "getPublicBaseUrl", this).call(this, this.getTag());
     }
   }, {
     key: "getCdnUrl",
@@ -167,6 +219,7 @@ let GoogleStorageProvider = /*#__PURE__*/function (_StorageProvider) {
     key: "getAssetsBucketUrl",
     value: function getAssetsBucketUrl(config) {
       return _get(_getPrototypeOf(GoogleStorageProvider.prototype), "getAssetsBucketUrl", this).call(this, _objectSpread$4({
+        tag: this.getTag(),
         bucketProtocol: this.getProtocol(),
         bucketNamespace: _get(_getPrototypeOf(GoogleStorageProvider.prototype), "getBucketNamespace", this).call(this, config.prNumber)
       }, config));
@@ -175,25 +228,114 @@ let GoogleStorageProvider = /*#__PURE__*/function (_StorageProvider) {
     key: "getApplicationIndexBucketUrl",
     value: function getApplicationIndexBucketUrl(config) {
       return _get(_getPrototypeOf(GoogleStorageProvider.prototype), "getApplicationIndexBucketUrl", this).call(this, _objectSpread$4({
+        tag: this.getTag(),
         bucketProtocol: this.getProtocol(),
         bucketNamespace: _get(_getPrototypeOf(GoogleStorageProvider.prototype), "getBucketNamespace", this).call(this, config.prNumber)
       }, config));
     }
   }]);
   return GoogleStorageProvider;
-}(StorageProvider); // TODO: to be implemented.
-function getStorageProvider(storageProvider) {
+}(StorageProvider);
+var _bucketRegion3 = /*#__PURE__*/_classPrivateFieldLooseKey("bucketRegion");
+var _bucketEnvironment3 = /*#__PURE__*/_classPrivateFieldLooseKey("bucketEnvironment");
+let AwsStorageProvider = /*#__PURE__*/function (_StorageProvider2) {
+  _inherits(AwsStorageProvider, _StorageProvider2);
+  function AwsStorageProvider(config) {
+    var _this2;
+    _classCallCheck(this, AwsStorageProvider);
+    _this2 = _callSuper(this, AwsStorageProvider, [config]);
+    _Object$defineProperty(_assertThisInitialized(_this2), _bucketRegion3, {
+      writable: true,
+      value: void 0
+    });
+    _Object$defineProperty(_assertThisInitialized(_this2), _bucketEnvironment3, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(_assertThisInitialized(_this2), _bucketRegion3)[_bucketRegion3] = config.bucketRegion;
+    _classPrivateFieldLooseBase(_assertThisInitialized(_this2), _bucketEnvironment3)[_bucketEnvironment3] = config.bucketEnvironment;
+    return _this2;
+  }
+  _createClass(AwsStorageProvider, [{
+    key: "getTag",
+    value: function getTag() {
+      return 's3';
+    }
+  }, {
+    key: "getBucketRegion",
+    value: function getBucketRegion() {
+      return _classPrivateFieldLooseBase(this, _bucketRegion3)[_bucketRegion3];
+    }
+  }, {
+    key: "getBucketEnvironment",
+    value: function getBucketEnvironment() {
+      return _classPrivateFieldLooseBase(this, _bucketEnvironment3)[_bucketEnvironment3];
+    }
+  }, {
+    key: "getProtocol",
+    value: function getProtocol() {
+      return 's3://';
+    }
+  }, {
+    key: "getPublicBaseUrl",
+    value: function getPublicBaseUrl() {
+      return _get(_getPrototypeOf(AwsStorageProvider.prototype), "getPublicBaseUrl", this).call(this, this.getTag());
+    }
+  }, {
+    key: "getCdnUrl",
+    value: function getCdnUrl(config) {
+      return _get(_getPrototypeOf(AwsStorageProvider.prototype), "getCdnUrl", this).call(this, _objectSpread$4({
+        publicBaseUrl: this.getPublicBaseUrl(),
+        excludeBucketRegion: true
+      }, config));
+    }
+  }, {
+    key: "getAssetsBucketUrl",
+    value: function getAssetsBucketUrl(config) {
+      return _get(_getPrototypeOf(AwsStorageProvider.prototype), "getAssetsBucketUrl", this).call(this, _objectSpread$4({
+        tag: this.getTag(),
+        bucketProtocol: this.getProtocol(),
+        bucketNamespace: _get(_getPrototypeOf(AwsStorageProvider.prototype), "getBucketNamespace", this).call(this, config.prNumber)
+      }, config));
+    }
+  }, {
+    key: "getApplicationIndexBucketUrl",
+    value: function getApplicationIndexBucketUrl(config) {
+      return _get(_getPrototypeOf(AwsStorageProvider.prototype), "getApplicationIndexBucketUrl", this).call(this, _objectSpread$4({
+        tag: this.getTag(),
+        bucketProtocol: this.getProtocol(),
+        bucketNamespace: _get(_getPrototypeOf(AwsStorageProvider.prototype), "getBucketNamespace", this).call(this, config.prNumber)
+      }, config));
+    }
+  }]);
+  return AwsStorageProvider;
+}(StorageProvider);
+function getStorageProvider(storageProvider, config) {
   switch (storageProvider) {
     case 'gs':
-      return new GoogleStorageProvider();
+      return new GoogleStorageProvider(config);
+    case 's3':
+      return new AwsStorageProvider(config);
     default:
       throw new Error(`Storage provider ${storageProvider} not supported`);
   }
 }
 
+var _bucketEnvironment = /*#__PURE__*/_classPrivateFieldLooseKey("bucketEnvironment");
+var _bucketRegion = /*#__PURE__*/_classPrivateFieldLooseKey("bucketRegion");
 let GoogleStorageUploadScriptsGenerator = /*#__PURE__*/function () {
-  function GoogleStorageUploadScriptsGenerator() {
+  function GoogleStorageUploadScriptsGenerator(config) {
     _classCallCheck(this, GoogleStorageUploadScriptsGenerator);
+    _Object$defineProperty(this, _bucketEnvironment, {
+      writable: true,
+      value: void 0
+    });
+    _Object$defineProperty(this, _bucketRegion, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _bucketRegion)[_bucketRegion] = config.bucketRegion;
+    _classPrivateFieldLooseBase(this, _bucketEnvironment)[_bucketEnvironment] = config.bucketEnvironment;
   }
   _createClass(GoogleStorageUploadScriptsGenerator, [{
     key: "getApplicationIndexUploadScript",
@@ -201,10 +343,12 @@ let GoogleStorageUploadScriptsGenerator = /*#__PURE__*/function () {
       let packageManagerName = _ref.packageManagerName,
         bucketUrl = _ref.bucketUrl,
         cdnUrl = _ref.cdnUrl,
-        bucketEnvironment = _ref.bucketEnvironment,
         buildRevision = _ref.buildRevision,
         buildNumber = _ref.buildNumber,
         applicationIndexOutFile = _ref.applicationIndexOutFile;
+      if (!_classPrivateFieldLooseBase(this, _bucketEnvironment)[_bucketEnvironment]) {
+        throw new Error("Missing 'bucketEnvironment' when generating application index.");
+      }
       return `
 #!/usr/bin/env bash
 
@@ -222,7 +366,7 @@ gcloud storage cp \\
 echo "Creating version.json and uploading it to bucket ${bucketUrl}"
 
 NODE_ENV=production ${packageManagerName} application-cli create-version \\
-  --version-url=${cdnUrl}/${bucketEnvironment}/version.json \\
+  --version-url=${cdnUrl}/${_classPrivateFieldLooseBase(this, _bucketEnvironment)[_bucketEnvironment]}/version.json \\
   --build-revision=${buildRevision} \\
   --build-number=${buildNumber} \\
   --out-file=$(dirname "$0")/version.json
@@ -308,11 +452,130 @@ fi
     }
   }]);
   return GoogleStorageUploadScriptsGenerator;
-}(); // TODO: To be implemented.
-function getUploadScriptsGenerator(storageProvider) {
+}();
+var _bucketEnvironment2 = /*#__PURE__*/_classPrivateFieldLooseKey("bucketEnvironment");
+var _bucketRegion2 = /*#__PURE__*/_classPrivateFieldLooseKey("bucketRegion");
+let AwsStorageUploadScriptsGenerator = /*#__PURE__*/function () {
+  function AwsStorageUploadScriptsGenerator(config) {
+    _classCallCheck(this, AwsStorageUploadScriptsGenerator);
+    _Object$defineProperty(this, _bucketEnvironment2, {
+      writable: true,
+      value: void 0
+    });
+    _Object$defineProperty(this, _bucketRegion2, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _bucketRegion2)[_bucketRegion2] = config.bucketRegion;
+    _classPrivateFieldLooseBase(this, _bucketEnvironment2)[_bucketEnvironment2] = config.bucketEnvironment;
+  }
+  _createClass(AwsStorageUploadScriptsGenerator, [{
+    key: "getApplicationIndexUploadScript",
+    value: function getApplicationIndexUploadScript(_ref3) {
+      let packageManagerName = _ref3.packageManagerName,
+        bucketUrl = _ref3.bucketUrl,
+        cdnUrl = _ref3.cdnUrl,
+        buildRevision = _ref3.buildRevision,
+        buildNumber = _ref3.buildNumber,
+        applicationIndexOutFile = _ref3.applicationIndexOutFile;
+      return `
+    #!/usr/bin/env bash
+
+    echo "Uploading static assets to Amazon S3 bucket ${bucketUrl}"
+
+    set -e
+
+    aws s3 cp \\
+      "$(dirname "$0")/${applicationIndexOutFile}" \\
+      "${bucketUrl}/" \\
+      --content-type="text/html" \\
+      --cache-control="public,max-age=0,no-transform" \\
+      --profile ${_classPrivateFieldLooseBase(this, _bucketRegion2)[_bucketRegion2]}
+
+    echo "Creating version.json and uploading it to bucket ${bucketUrl}"
+
+    NODE_ENV=production ${packageManagerName} application-cli create-version \\
+      --version-url=${cdnUrl}/${_classPrivateFieldLooseBase(this, _bucketRegion2)[_bucketRegion2]}/version.json \\
+      --build-revision=${buildRevision} \\
+      --build-number=${buildNumber} \\
+      --out-file=$(dirname "$0")/version.json
+
+    aws s3 cp \\
+      "$(dirname "$0")/version.json" \\
+      "${bucketUrl}/" \\
+      --content-type="application/json" \\
+      --cache-control="public,max-age=0,no-transform" \\
+      --profile ${_classPrivateFieldLooseBase(this, _bucketRegion2)[_bucketRegion2]}
+`;
+    }
+  }, {
+    key: "getProductionBundlesUploadScript",
+    value: function getProductionBundlesUploadScript(_ref4) {
+      let bucketUrl = _ref4.bucketUrl,
+        assetsPath = _ref4.assetsPath,
+        skipMenu = _ref4.skipMenu;
+      return `
+#!/usr/bin/env bash
+
+echo "Uploading static assets to Amazon S3 bucket ${bucketUrl}"
+
+set -e
+
+# NOTE:
+#   The sync command on the AWS CLI is different to the -n option on the gcloud CLI.
+#   Sync will only upload files that are not already in the bucket, but it will skip existing ones
+#   that have been changed locally.
+#   The -n option on the gcloud CLI will skip uploading existing files and prevents them to be overwritten.
+#   https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html
+#   https://cloud.google.com/sdk/gcloud/reference/storage/cp
+#
+#   Compression (gzip) is enabled on CloudFront by default. Hence compression does happing while uploading.
+#   https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/ServingCompressedFiles.html#compressed-content-cloudfront-configuring
+aws s3 sync ${assetsPath}/public \\
+  "${bucketUrl}" \\
+  --exclude "*" \\
+  --include "*.css" \\
+  --include "*.js" \\
+  --include "*.js.map" \\
+  --include "*.html" \\
+  --cache-control="public,max-age=31536000,no-transform" \\
+  --profile ${_classPrivateFieldLooseBase(this, _bucketRegion2)[_bucketRegion2]}
+
+# We need to upload the PNG and HTML files separately because we want them
+# to be able to overwrite the existing files (if any). For instance, the
+# file or the favicons.
+aws s3 cp ${assetsPath}/public \\
+  "${bucketUrl}" \\
+  --recursive \\
+  --exclude "*" \\
+  --include "*.png" \\
+  --include "robots.txt" \\
+  --cache-control="public,max-age=31536000,no-transform" \\
+  --profile ${_classPrivateFieldLooseBase(this, _bucketRegion2)[_bucketRegion2]}
+
+if ${skipMenu}; then
+  echo "Skipping menu.json upload"
+else
+  echo "Uploading menu.json to bucket ${bucketUrl}"
+
+  aws s3 cp \\
+    ${assetsPath}/menu.json \\
+    ${bucketUrl} \\
+    --content-type="application/json" \\
+    --cache-control="public,max-age=0,no-transform" \\
+    --profile ${_classPrivateFieldLooseBase(this, _bucketRegion2)[_bucketRegion2]}
+fi
+`;
+    }
+  }]);
+  return AwsStorageUploadScriptsGenerator;
+}();
+function getUploadScriptsGenerator(storageProvider, config) {
   switch (storageProvider) {
     case 'gs':
-      return new GoogleStorageUploadScriptsGenerator();
+      return new GoogleStorageUploadScriptsGenerator(config);
+    case 's3':
+      return new AwsStorageUploadScriptsGenerator(config);
     default:
       throw new Error(`Storage provider ${storageProvider} not supported`);
   }
@@ -356,10 +619,7 @@ function loadDotenvFiles(_ref) {
 }
 
 function ownKeys$2(e, r) { var t = _Object$keys(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = _filterInstanceProperty(o).call(o, function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread$2(e) { for (var r = 1; r < arguments.length; r++) { var _context4, _context5; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty(_context4 = ownKeys$2(Object(t), !0)).call(_context4, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : _forEachInstanceProperty(_context5 = ownKeys$2(Object(t))).call(_context5, function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
-const storageBucketConfigExplorer = cosmiconfig('storage-buckets', {
-  searchStrategy: 'project'
-});
+function _objectSpread$2(e) { for (var r = 1; r < arguments.length; r++) { var _context3, _context4; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty(_context3 = ownKeys$2(Object(t), !0)).call(_context3, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : _forEachInstanceProperty(_context4 = ownKeys$2(Object(t))).call(_context4, function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
 function writeUploadScriptFile(_ref) {
   let fileName = _ref.fileName,
     fileContent = _ref.fileContent,
@@ -374,12 +634,10 @@ async function compileApplicationAssets(_ref2) {
   let cliFlags = _ref2.cliFlags,
     storageProvider = _ref2.storageProvider,
     uploadScriptsGenerator = _ref2.uploadScriptsGenerator,
-    bucketRegion = _ref2.bucketRegion,
     paths = _ref2.paths;
   const applicationAssetsUploadScriptContent = uploadScriptsGenerator.getProductionBundlesUploadScript({
     storageProvider,
     bucketUrl: storageProvider.getAssetsBucketUrl({
-      bucketRegion,
       prNumber: cliFlags.prNumber,
       applicationName: cliFlags.applicationName
     }),
@@ -387,7 +645,7 @@ async function compileApplicationAssets(_ref2) {
     skipMenu: cliFlags.skipMenu
   });
   const parsedApplicationAssetsUploadScriptFile = path$1.parse(cliFlags.applicationAssetsUploadScriptOutFile);
-  const applicationAssetsUploadScriptFileName = `${parsedApplicationAssetsUploadScriptFile.name}-${bucketRegion}${parsedApplicationAssetsUploadScriptFile.ext}`;
+  const applicationAssetsUploadScriptFileName = `${parsedApplicationAssetsUploadScriptFile.name}-${storageProvider.getBucketRegion()}${parsedApplicationAssetsUploadScriptFile.ext}`;
   writeUploadScriptFile({
     fileName: applicationAssetsUploadScriptFileName,
     fileContent: applicationAssetsUploadScriptContent,
@@ -399,9 +657,7 @@ async function compileEnvironmentApplicationIndexes(_ref3) {
     storageProvider = _ref3.storageProvider,
     uploadScriptsGenerator = _ref3.uploadScriptsGenerator,
     paths = _ref3.paths,
-    bucketRegion = _ref3.bucketRegion,
-    cloudEnvironment = _ref3.cloudEnvironment,
-    bucketEnvironment = _ref3.bucketEnvironment;
+    cloudEnvironment = _ref3.cloudEnvironment;
   const cloudEnvironmentDeploymentPath = path$1.join(paths.deploymentsPath, storageProvider.getTag(), cloudEnvironment);
   // Ensure the folder exists
   const createDeploymentsFolderResult = await execa('mkdir', ['-p', cloudEnvironmentDeploymentPath], {
@@ -413,7 +669,6 @@ async function compileEnvironmentApplicationIndexes(_ref3) {
 
   // Construct the proper CDN URL for the specific application
   const cdnUrl = storageProvider.getCdnUrl({
-    bucketRegion,
     prNumber: cliFlags.prNumber,
     applicationName: cliFlags.applicationName
   });
@@ -459,13 +714,10 @@ async function compileEnvironmentApplicationIndexes(_ref3) {
     storageProvider,
     packageManagerName: cliFlags.packageManagerName,
     bucketUrl: storageProvider.getApplicationIndexBucketUrl({
-      bucketRegion,
       prNumber: cliFlags.prNumber,
-      applicationName: cliFlags.applicationName,
-      bucketEnvironment
+      applicationName: cliFlags.applicationName
     }),
     cdnUrl,
-    bucketEnvironment,
     buildRevision: cliFlags.buildRevision,
     buildNumber: cliFlags.buildNumber,
     applicationIndexOutFile: cliFlags.applicationIndexOutFile
@@ -484,16 +736,7 @@ async function compileEnvironmentApplicationIndexes(_ref3) {
 }
 async function command$3(cliFlags, cwd) {
   var _context;
-  let cloudEnvironmentsGroupedByBucketRegions;
-  try {
-    // This is the list of the supported cloud environments and their related bucket location.
-    cloudEnvironmentsGroupedByBucketRegions = await storageBucketConfigExplorer.search();
-  } catch (e) {
-    throw new Error('Failed to load a storage bucket configuration. Create a cosmiconfig for `storage-buckets` for example `storage-buckets.config.cjs`.');
-  }
-  if (!cloudEnvironmentsGroupedByBucketRegions) {
-    throw new Error('Failed loading a storage bucket configuration');
-  }
+  const storageBucketConfig = await loadStorageBucketsConfig();
   const applicationDirectory = getApplicationDirectory(cwd);
   let assetsPath;
   if (cliFlags.ciAssetsRootPath && isCI()) {
@@ -508,28 +751,32 @@ async function command$3(cliFlags, cwd) {
     dotenvPath: cliFlags.dotenvFolder && path$1.join(monorepoRoot.rootDir, cliFlags.dotenvFolder),
     assetsPath
   };
-  const defaultStorageProviders = ['gs'];
-  const taskList = new Listr(_mapInstanceProperty(_context = _Object$entries(cloudEnvironmentsGroupedByBucketRegions.config)).call(_context, _ref4 => {
+  const defaultStorageProviders = [storageProviders.gs.tag];
+  const taskList = new Listr(_mapInstanceProperty(_context = _Object$entries(storageBucketConfig)).call(_context, _ref4 => {
     let _ref5 = _slicedToArray(_ref4, 2),
       bucketRegion = _ref5[0],
       bucketEnvironmentConfigs = _ref5[1];
     return {
       title: `Compiling for bucket region ${bucketRegion}`,
       task: (_bucketRegionCtx, bucketRegionTask) => {
-        var _context2;
         // NOTE: Application assets need to be compiled
         // for all storage providers once per region.
-        const allStorageProvidersForBucketRegion = [...new _Set(_flatInstanceProperty(_context2 = _mapInstanceProperty(bucketEnvironmentConfigs).call(bucketEnvironmentConfigs, bucketEnvironmentConfig => bucketEnvironmentConfig.storageProviders || defaultStorageProviders)).call(_context2))];
+        const allStorageProvidersForBucketRegion = [...new _Set(_flatMapInstanceProperty(bucketEnvironmentConfigs).call(bucketEnvironmentConfigs, bucketEnvironmentConfig => bucketEnvironmentConfig.storageProviders || defaultStorageProviders))];
         const allApplicationAssetTasks = _mapInstanceProperty(allStorageProvidersForBucketRegion).call(allStorageProvidersForBucketRegion, storageProviderTag => {
-          const storageProvider = getStorageProvider(storageProviderTag);
-          const uploadScriptsGenerator = getUploadScriptsGenerator(storageProviderTag);
+          const uploadScriptsGeneratorConfig = {
+            bucketRegion: bucketRegion
+          };
+          const storageProviderConfig = {
+            bucketRegion: bucketRegion
+          };
+          const storageProvider = getStorageProvider(storageProviderTag, storageProviderConfig);
+          const uploadScriptsGenerator = getUploadScriptsGenerator(storageProviderTag, uploadScriptsGeneratorConfig);
           return {
             title: `Compiling application assets for '${storageProviderTag}'`,
             task: () => compileApplicationAssets({
               cliFlags,
               storageProvider,
               uploadScriptsGenerator,
-              bucketRegion: bucketRegion,
               paths
             })
           };
@@ -538,13 +785,17 @@ async function command$3(cliFlags, cwd) {
           const cloudEnvironment = bucketEnvironmentConfig.cloudEnvironment,
             bucketEnvironment = bucketEnvironmentConfig.bucketEnvironment,
             storageProviders = bucketEnvironmentConfig.storageProviders;
+          const storageProviderConfig = {
+            bucketRegion: bucketRegion,
+            bucketEnvironment
+          };
           return {
             title: `Compiling for cloud environment '${cloudEnvironment}'`,
             task: (_storageProviderCtx, storageProviderTask) => {
-              var _context3;
-              const applicationIndexTasksForStorageProviders = _mapInstanceProperty(_context3 = storageProviders || defaultStorageProviders).call(_context3, storageProviderTag => {
-                const storageProvider = getStorageProvider(storageProviderTag);
-                const uploadScriptsGenerator = getUploadScriptsGenerator(storageProviderTag);
+              var _context2;
+              const applicationIndexTasksForStorageProviders = _mapInstanceProperty(_context2 = storageProviders || defaultStorageProviders).call(_context2, storageProviderTag => {
+                const storageProvider = getStorageProvider(storageProviderTag, storageProviderConfig);
+                const uploadScriptsGenerator = getUploadScriptsGenerator(storageProviderTag, storageProviderConfig);
                 return {
                   title: `Compiling application index for storage provider '${storageProviderTag}'`,
                   task: () => {
@@ -553,9 +804,7 @@ async function command$3(cliFlags, cwd) {
                       storageProvider,
                       uploadScriptsGenerator,
                       paths,
-                      bucketRegion: bucketRegion,
-                      cloudEnvironment,
-                      bucketEnvironment
+                      cloudEnvironment
                     });
                   }
                 };
@@ -839,7 +1088,7 @@ async function command(cliFlags) {
 
 var pkgJson = {
 	name: "@commercetools-frontend/application-cli",
-	version: "2.1.2",
+	version: "2.3.0",
 	description: "Internal CLI to manage Merchant Center application deployments across various environments.",
 	keywords: [
 		"commercetools",
@@ -862,15 +1111,15 @@ var pkgJson = {
 	},
 	dependencies: {
 		"@babel/core": "^7.22.11",
-		"@babel/runtime-corejs3": "^7.21.0",
 		"@babel/runtime": "^7.21.0",
-		"@commercetools-frontend/application-config": "22.17.1",
-		"@commercetools-frontend/constants": "22.17.1",
-		"@commercetools-frontend/l10n": "22.17.1",
+		"@babel/runtime-corejs3": "^7.21.0",
+		"@commercetools-frontend/application-config": "22.22.0",
+		"@commercetools-frontend/constants": "22.22.0",
+		"@commercetools-frontend/l10n": "22.22.0",
 		"@manypkg/find-root": "2.2.1",
 		cac: "^6.7.14",
 		cosmiconfig: "9.0.0",
-		dotenv: "16.4.1",
+		dotenv: "16.4.2",
 		execa: "5.1.1",
 		jsonschema: "^1.4.1",
 		listr2: "8.0.2",
@@ -879,7 +1128,7 @@ var pkgJson = {
 	},
 	devDependencies: {
 		"@tsconfig/node20": "20.1.2",
-		"@types/node": "20.11.5",
+		"@types/node": "20.11.30",
 		typescript: "5.2.2"
 	},
 	engines: {