@commercetools-frontend/application-cli 1.4.0 → 1.5.0

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

@@ -0,0 +1,699 @@
+import { cac } from 'cac';
+import _Object$keys from '@babel/runtime-corejs3/core-js-stable/object/keys';
+import _Object$getOwnPropertySymbols from '@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols';
+import _Object$getOwnPropertyDescriptor from '@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor';
+import _forEachInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/for-each';
+import _Object$getOwnPropertyDescriptors from '@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptors';
+import _Object$defineProperties from '@babel/runtime-corejs3/core-js-stable/object/define-properties';
+import _Object$defineProperty from '@babel/runtime-corejs3/core-js-stable/object/define-property';
+import _slicedToArray from '@babel/runtime-corejs3/helpers/esm/slicedToArray';
+import _defineProperty from '@babel/runtime-corejs3/helpers/esm/defineProperty';
+import _filterInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/filter';
+import _concatInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/concat';
+import _mapInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/map';
+import _Object$entries from '@babel/runtime-corejs3/core-js-stable/object/entries';
+import fs from 'fs';
+import path from 'path';
+import { Listr } from 'listr2';
+import execa from 'execa';
+import { cosmiconfig } from 'cosmiconfig';
+import { findRootSync } from '@manypkg/find-root';
+import dotenv from 'dotenv';
+import _findInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/find';
+import _JSON$stringify from '@babel/runtime-corejs3/core-js-stable/json/stringify';
+import { processConfig } from '@commercetools-frontend/application-config';
+import _sliceInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/slice';
+import fetch from 'node-fetch';
+import { Validator } from 'jsonschema';
+
+function getApplicationDirectory(cwd) {
+  return fs.realpathSync(cwd);
+}
+
+function resolveInApplication(relativePath, cwd) {
+  return path.resolve(getApplicationDirectory(cwd), relativePath);
+}
+
+function isCI() {
+  // @ts-expect-error The env is sometimes overwritten by code to a boolean
+  return process.env.CI === true || process.env.CI === 'true';
+}
+
+function createApplicationIndexUploadScript(_ref) {
+  var _context, _context2, _context3, _context4, _context5, _context6, _context7, _context8, _context9, _context10;
+  let packageManagerName = _ref.packageManagerName,
+    bucketUrl = _ref.bucketUrl,
+    cdnUrl = _ref.cdnUrl,
+    cloudEnvironment = _ref.cloudEnvironment,
+    buildRevision = _ref.buildRevision,
+    buildNumber = _ref.buildNumber,
+    applicationIndexOutFile = _ref.applicationIndexOutFile;
+  const uploadScriptContent = _concatInstanceProperty(_context = _concatInstanceProperty(_context2 = _concatInstanceProperty(_context3 = _concatInstanceProperty(_context4 = _concatInstanceProperty(_context5 = _concatInstanceProperty(_context6 = _concatInstanceProperty(_context7 = _concatInstanceProperty(_context8 = _concatInstanceProperty(_context9 = _concatInstanceProperty(_context10 = "#!/usr/bin/env bash\n\nset -e\n\necho \"Uploading compiled ".concat(applicationIndexOutFile, " to bucket ")).call(_context10, bucketUrl, "\"\ngsutil \\\n-h \"Content-Type: text/html\" \\\n-h \"Cache-Control: public, max-age=0, no-transform\" \\\ncp -z html \\\n\"$(dirname \"$0\")/")).call(_context9, applicationIndexOutFile, "\" \\\n\"")).call(_context8, bucketUrl, "/\"\n\necho \"Creating version.json and uploading it to bucket ")).call(_context7, bucketUrl, "\"\n\nNODE_ENV=production ")).call(_context6, packageManagerName, " application-cli create-version \\\n  --version-url=")).call(_context5, cdnUrl, "/")).call(_context4, cloudEnvironment, "/version.json \\\n  --build-revision=")).call(_context3, buildRevision, " \\\n  --build-number=")).call(_context2, buildNumber, " \\\n  --out-file=$(dirname \"$0\")/version.json\n\ngsutil \\\n-h \"Content-Type: application/json\" \\\n-h \"Cache-Control: private, max-age=0, no-transform\" \\\ncp -z json \\\n\"$(dirname \"$0\")/version.json\" \\\n\"")).call(_context, bucketUrl, "/\"\n");
+  return uploadScriptContent;
+}
+
+function createApplicationAssetsUploadScript(_ref) {
+  var _context, _context2, _context3, _context4, _context5, _context6;
+  let bucketUrl = _ref.bucketUrl,
+    assetsPath = _ref.assetsPath,
+    skipMenu = _ref.skipMenu;
+  const uploadScriptContent = _concatInstanceProperty(_context = _concatInstanceProperty(_context2 = _concatInstanceProperty(_context3 = _concatInstanceProperty(_context4 = _concatInstanceProperty(_context5 = _concatInstanceProperty(_context6 = "#!/usr/bin/env bash\n\nset -e\n\n# NOTES:\n# https://cloud.google.com/storage/docs/gsutil/commands/cp#options\n#     1. The '-z' option triggers compressing the assets before\n#        uploading them and sets the 'Content-Encoding' to 'gzip'.\n#     2. The 'Accept-encoding: gzip' is set automatically by the 'gsutils'.\n#     3. The 'max-age' is set to 1 year which is considered the maximum\n#        \"valid\" lifetime of an asset to be cached.\n#     5. The '-n' will skip uploading existing files and prevents them to\n#        be overwritten\necho \"Uploading static assets to bucket ".concat(bucketUrl, "\"\n\ngsutil -m \\\n  -h \"Cache-Control: public, max-age=31536000, no-transform\" \\\n  cp -z js,css \\\n  -n \\\n  ")).call(_context6, assetsPath, "/public/{*.css,*.js,*.js.map,*.png,*.html,robots.txt} \\\n  \"")).call(_context5, bucketUrl, "\"\n\nif ")).call(_context4, skipMenu, "; then\n  echo \"Skipping menu.json upload\"\nelse\n  echo \"Uploading menu.json to bucket ")).call(_context3, bucketUrl, "\"\n  # NOTE: somehow the 'cache-control:private' doesn't work.\n  # I mean, the file is uploaded with the correct metadata but when I fetch\n  # the file the response contains the header\n  # 'cache-control: public, max-age=31536000, no-transform', even though the\n  # documentation clearly states that by marking the header as 'private' will\n  # disable the cache (for publicly readable objects).\n  # https://cloud.google.com/storage/docs/gsutil/addlhelp/WorkingWithObjectMetadata#cache-control\n  # However, I found out that, by requesting the file with any RANDOM\n  # query parameter, will instruct the storage to return a 'fresh' object\n  # (without any cache control).\n  # Unofficial source: https://stackoverflow.com/a/49052895\n  # This seems to be the 'easiest' option to 'disable' the cache for public\n  # objects. Other alternative approaces are:\n  #   * make the object private with some simple ACL (private objects are not cached)\n  #   * suffix the file name with e.g. the git SHA, so we have different files\n  #   for each upload ('index.html.template-${CIRCLE_SHA1}'). The server knows\n  #   the git SHA on runtime and can get the correct file when it starts.\n  #   * find out why the 'private' cache control does not work\n  gsutil \\\n    -h \"Content-Type: application/json\" \\\n    -h \"Cache-Control: private, max-age=0, no-transform\" \\\n    cp -z json \\\n    ")).call(_context2, assetsPath, "/menu.json \\\n    ")).call(_context, bucketUrl, "\nfi\n");
+  return uploadScriptContent;
+}
+
+function ownKeys$3(object, enumerableOnly) { var keys = _Object$keys(object); if (_Object$getOwnPropertySymbols) { var symbols = _Object$getOwnPropertySymbols(object); enumerableOnly && (symbols = _filterInstanceProperty(symbols).call(symbols, function (sym) { return _Object$getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread$3(target) { for (var i = 1; i < arguments.length; i++) { var _context2, _context3; var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? _forEachInstanceProperty(_context2 = ownKeys$3(Object(source), !0)).call(_context2, function (key) { _defineProperty(target, key, source[key]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(target, _Object$getOwnPropertyDescriptors(source)) : _forEachInstanceProperty(_context3 = ownKeys$3(Object(source))).call(_context3, function (key) { _Object$defineProperty(target, key, _Object$getOwnPropertyDescriptor(source, key)); }); } return target; }
+function loadDotenvFiles(_ref) {
+  let dotenvPath = _ref.dotenvPath,
+    cloudEnvironment = _ref.cloudEnvironment;
+  // No path requested, skip.
+  if (!dotenvPath) {
+    return {};
+  }
+
+  // Check if the given path exists.
+  if (!fs.existsSync(dotenvPath)) {
+    throw new Error("The dotenv folder path does not exist: \"".concat(dotenvPath, "\"."));
+  }
+
+  // Load the environment values
+  const sharedDotenvFile = '.env.production';
+  const cloudDotenvFile = ".env.".concat(cloudEnvironment);
+
+  // The shared dotenv file across environments is optional
+  const sharedProductionEnvironment = dotenv.config({
+    encoding: 'utf8',
+    path: path.join(dotenvPath, sharedDotenvFile)
+  });
+  const cloudSpecificProductionEnvironment = dotenv.config({
+    encoding: 'utf8',
+    path: path.join(dotenvPath, cloudDotenvFile)
+  });
+  if (cloudSpecificProductionEnvironment.error) {
+    var _context;
+    throw new Error(_concatInstanceProperty(_context = "Failed loading '".concat(cloudDotenvFile, "' in '")).call(_context, dotenvPath, "'. Make sure it exists."));
+  }
+  if (sharedProductionEnvironment.error) {
+    throw new Error("Failed loading '".concat(sharedDotenvFile, "' in '").concat(dotenvPath, "'. Make sure it exists."));
+  }
+  return _objectSpread$3(_objectSpread$3({}, sharedProductionEnvironment.parsed), cloudSpecificProductionEnvironment.parsed);
+}
+
+function ownKeys$2(object, enumerableOnly) { var keys = _Object$keys(object); if (_Object$getOwnPropertySymbols) { var symbols = _Object$getOwnPropertySymbols(object); enumerableOnly && (symbols = _filterInstanceProperty(symbols).call(symbols, function (sym) { return _Object$getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var _context8, _context9; var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? _forEachInstanceProperty(_context8 = ownKeys$2(Object(source), !0)).call(_context8, function (key) { _defineProperty(target, key, source[key]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(target, _Object$getOwnPropertyDescriptors(source)) : _forEachInstanceProperty(_context9 = ownKeys$2(Object(source))).call(_context9, function (key) { _Object$defineProperty(target, key, _Object$getOwnPropertyDescriptor(source, key)); }); } return target; }
+const buckedConfigExplorer = cosmiconfig('google-storage-buckets');
+function writeUploadScriptFile(_ref) {
+  let fileName = _ref.fileName,
+    fileContent = _ref.fileContent,
+    filePath = _ref.filePath;
+  fs.writeFileSync(path.join(filePath, fileName), fileContent, {
+    // Make the script executable
+    mode: 0o755,
+    encoding: 'utf8'
+  });
+}
+function getBucketNamespace(prNumber) {
+  if (!prNumber) return;
+  if (prNumber === 'merchant-center-preview') return prNumber;
+  return "mc-".concat(prNumber);
+}
+
+/**
+ *  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 getApplicationAssetsBucketUrl(_ref2) {
+  var _context;
+  let bucketRegion = _ref2.bucketRegion,
+    prNumber = _ref2.prNumber,
+    applicationName = _ref2.applicationName;
+  const applicationAssetsBucketUrl = _filterInstanceProperty(_context = ["gs://".concat(bucketRegion), getBucketNamespace(prNumber), applicationName]).call(_context, Boolean);
+  return applicationAssetsBucketUrl.join('/');
+}
+function getApplicationIndexBucketUrl(_ref3) {
+  var _context2;
+  let bucketRegion = _ref3.bucketRegion,
+    prNumber = _ref3.prNumber,
+    applicationName = _ref3.applicationName,
+    cloudEnvironment = _ref3.cloudEnvironment;
+  const applicationAssetsBucketUrl = getApplicationAssetsBucketUrl({
+    bucketRegion,
+    prNumber,
+    applicationName
+  });
+  const applicationIndexBucketUrl = _concatInstanceProperty(_context2 = "".concat(applicationAssetsBucketUrl, "/")).call(_context2, cloudEnvironment);
+  return applicationIndexBucketUrl;
+}
+function getCdnUrl(_ref4) {
+  var _context3;
+  let bucketRegion = _ref4.bucketRegion,
+    prNumber = _ref4.prNumber,
+    applicationName = _ref4.applicationName;
+  return _filterInstanceProperty(_context3 = ["https://storage.googleapis.com/".concat(bucketRegion), getBucketNamespace(prNumber), applicationName]).call(_context3, Boolean).join('/');
+}
+async function compileApplicationAssets(_ref5) {
+  var _context4, _context5;
+  let cliFlags = _ref5.cliFlags,
+    bucketRegion = _ref5.bucketRegion,
+    paths = _ref5.paths;
+  const applicationAssetsUploadScriptContent = createApplicationAssetsUploadScript({
+    bucketUrl: getApplicationAssetsBucketUrl({
+      bucketRegion,
+      prNumber: cliFlags.prNumber,
+      applicationName: cliFlags.applicationName
+    }),
+    assetsPath: paths.assetsPath,
+    skipMenu: cliFlags.skipMenu
+  });
+  const parsedApplicationAssetsUploadScriptFile = path.parse(cliFlags.applicationAssetsUploadScriptOutFile);
+  const applicationAssetsUploadScriptFileName = _concatInstanceProperty(_context4 = _concatInstanceProperty(_context5 = "".concat(parsedApplicationAssetsUploadScriptFile.name, "-")).call(_context5, bucketRegion)).call(_context4, parsedApplicationAssetsUploadScriptFile.ext);
+  writeUploadScriptFile({
+    fileName: applicationAssetsUploadScriptFileName,
+    fileContent: applicationAssetsUploadScriptContent,
+    filePath: paths.deploymentsPath
+  });
+}
+async function compileEnvironmentApplicationIndexes(_ref6) {
+  let cliFlags = _ref6.cliFlags,
+    paths = _ref6.paths,
+    bucketRegion = _ref6.bucketRegion,
+    cloudEnvironment = _ref6.cloudEnvironment;
+  const cloudEnvironmentDeploymentPath = path.join(paths.deploymentsPath, cloudEnvironment);
+  // Ensure the folder exists
+  const createDeploymentsFolderResult = await execa('mkdir', ['-p', cloudEnvironmentDeploymentPath], {
+    encoding: 'utf8'
+  });
+  if (createDeploymentsFolderResult.failed) {
+    throw new Error(createDeploymentsFolderResult.stderr);
+  }
+
+  // Construct the proper CDN URL for the specific application
+  const cdnUrl = getCdnUrl({
+    bucketRegion,
+    prNumber: cliFlags.prNumber,
+    applicationName: cliFlags.applicationName
+  });
+  const environmentVariablesForCompilation = _objectSpread$2(_objectSpread$2(_objectSpread$2(_objectSpread$2({}, loadDotenvFiles({
+    dotenvPath: paths.dotenvPath,
+    cloudEnvironment
+  })), {}, {
+    // The trailing slash is important to indicate to the CSP directive that all the resources
+    // under that path should be allowed.
+    MC_CDN_URL: "".concat(cdnUrl, "/")
+  }, cliFlags.mcUrl ? {
+    MC_URL: cliFlags.mcUrl
+  } : {}), cliFlags.mcApiUrl ? {
+    MC_API_URL: cliFlags.mcApiUrl
+  } : {}), {}, {
+    // Will be used by the Application Kit for Sentry and exposed on `window.app.revision`.
+    REVISION: cliFlags.buildRevision
+  });
+
+  /// Sentry and GTM is disabled on branch deployments
+  if (cliFlags.prNumber) {
+    // @ts-expect-error The env is sometimes overwritten by code to a boolean
+    process.env.TRACKING_SENTRY = null;
+    // @ts-expect-error The env is sometimes overwritten by code to a boolean
+    process.env.TRACKING_GTM = null;
+    // @ts-expect-error
+    environmentVariablesForCompilation.TRACKING_SENTRY = null;
+    // @ts-expect-error
+    environmentVariablesForCompilation.TRACKING_GTM = null;
+  }
+
+  // Compile the application using the loaded environment values
+  const compileResult = await execa('mc-scripts', ['compile-html'], {
+    encoding: 'utf8',
+    preferLocal: true,
+    extendEnv: true,
+    env: environmentVariablesForCompilation
+  });
+  if (compileResult.failed) {
+    throw new Error(compileResult.stderr);
+  }
+  const applicationIndexUploadScriptContent = createApplicationIndexUploadScript({
+    packageManagerName: cliFlags.packageManagerName,
+    bucketUrl: getApplicationIndexBucketUrl({
+      bucketRegion,
+      prNumber: cliFlags.prNumber,
+      applicationName: cliFlags.applicationName,
+      cloudEnvironment
+    }),
+    cdnUrl,
+    cloudEnvironment,
+    buildRevision: cliFlags.buildRevision,
+    buildNumber: cliFlags.buildNumber,
+    applicationIndexOutFile: cliFlags.applicationIndexOutFile
+  });
+  // Generate bash scripts to run the `gsutil` upload command.
+
+  writeUploadScriptFile({
+    fileName: cliFlags.applicationIndexUploadScriptOutFile,
+    fileContent: applicationIndexUploadScriptContent,
+    filePath: cloudEnvironmentDeploymentPath
+  });
+
+  // Move the compiled `index.html` to the deployments folder of the related cloud environment.
+
+  const moveResult = await execa('mv', [path.join(paths.publicAssetsPath, 'index.html'), path.join(cloudEnvironmentDeploymentPath, cliFlags.applicationIndexOutFile)]);
+  if (moveResult.failed) {
+    throw new Error(moveResult.stderr);
+  }
+}
+async function command$3(cliFlags, cwd) {
+  var _context6;
+  let cloudEnvironmentsGroupedByBucketRegions;
+  try {
+    // This is the list of the supported cloud environments and their related bucket location.
+    cloudEnvironmentsGroupedByBucketRegions = await buckedConfigExplorer.search();
+  } catch (e) {
+    throw new Error('Failed loading a Google Bucket configuration. Create a cosmiconfig for `google-storage-buckets` for example `google-storage-buckets.config.cjs`.');
+  }
+  if (!cloudEnvironmentsGroupedByBucketRegions) {
+    throw new Error('Failed loading a Google Bucket configuration');
+  }
+  const applicationDirectory = getApplicationDirectory(cwd);
+  let assetsPath;
+  if (cliFlags.ciAssetsRootPath && isCI()) {
+    assetsPath = applicationDirectory.replace('/home/circleci/', cliFlags.ciAssetsRootPath);
+  } else {
+    assetsPath = applicationDirectory;
+  }
+  const monorepoRoot = findRootSync(cwd);
+  const paths = {
+    publicAssetsPath: resolveInApplication('public', cwd),
+    deploymentsPath: resolveInApplication('deployments', cwd),
+    dotenvPath: cliFlags.dotenvFolder && path.join(monorepoRoot.rootDir, cliFlags.dotenvFolder),
+    assetsPath
+  };
+  const taskList = new Listr(_mapInstanceProperty(_context6 = _Object$entries(cloudEnvironmentsGroupedByBucketRegions.config)).call(_context6, _ref7 => {
+    let _ref8 = _slicedToArray(_ref7, 2),
+      bucketRegion = _ref8[0],
+      cloudEnvironments = _ref8[1];
+    return {
+      title: "Compiling application for bucket ".concat(bucketRegion),
+      task: () => {
+        var _context7;
+        return new Listr(_concatInstanceProperty(_context7 = _mapInstanceProperty(cloudEnvironments).call(cloudEnvironments, cloudEnvironment => ({
+          title: "Compiling ".concat(cloudEnvironment, " application index"),
+          task: () => compileEnvironmentApplicationIndexes({
+            cliFlags,
+            paths,
+            bucketRegion,
+            cloudEnvironment
+          })
+        }))).call(_context7, {
+          title: "Compiling application assets",
+          task: () => compileApplicationAssets({
+            cliFlags,
+            bucketRegion,
+            paths
+          })
+        }));
+      }
+    };
+  }), {
+    renderer: isCI() ? 'verbose' : 'default'
+  });
+  await taskList.run();
+}
+
+function ownKeys$1(object, enumerableOnly) { var keys = _Object$keys(object); if (_Object$getOwnPropertySymbols) { var symbols = _Object$getOwnPropertySymbols(object); enumerableOnly && (symbols = _filterInstanceProperty(symbols).call(symbols, function (sym) { return _Object$getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var _context2, _context3; var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? _forEachInstanceProperty(_context2 = ownKeys$1(Object(source), !0)).call(_context2, function (key) { _defineProperty(target, key, source[key]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(target, _Object$getOwnPropertyDescriptors(source)) : _forEachInstanceProperty(_context3 = ownKeys$1(Object(source))).call(_context3, function (key) { _Object$defineProperty(target, key, _Object$getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+// The menu links are only parsed from the config in development mode.
+process.env.NODE_ENV = 'development';
+const supportedLocales = ['en', 'de', 'es', 'fr-FR', 'zh-CN', 'ja'];
+const mapLabelAllLocalesWithDefaults = (labelAllLocales, defaultLabel) => {
+  let mappedLabelAllLocales = labelAllLocales;
+  if (defaultLabel) {
+    // Map all supported locales with the given localized labels.
+    // If a locale is not defined in the config, we use the `default` label as the value.
+    // This is only needed for development as we're trying to map two different schemas.
+    mappedLabelAllLocales = _mapInstanceProperty(supportedLocales).call(supportedLocales, supportedLocale => {
+      const existingField = _findInstanceProperty(labelAllLocales).call(labelAllLocales, field => field.locale === supportedLocale);
+      if (existingField) return existingField;
+      return {
+        locale: supportedLocale,
+        value: defaultLabel
+      };
+    });
+  }
+  return mappedLabelAllLocales;
+};
+
+/**
+ * Transform menu links defined in the `custom-application-config.json` to the format
+ * used by the HTTP Proxy GraphQL API.
+ */
+
+const mapApplicationMenuConfigToGraqhQLMenuJson = config => {
+  var _ref, _config$env$__DEVELOP, _config$env$__DEVELOP2, _menuLinks$featureTog, _menuLinks$menuVisibi, _menuLinks$actionRigh, _menuLinks$dataFences, _context, _menuLinks$shouldRend;
+  const entryPointUriPath = config.env.entryPointUriPath;
+
+  // @ts-expect-error: the `accountLinks` is not explicitly typed as it's only used by the account app.
+  const accountLinks = (_ref = (_config$env$__DEVELOP = config.env.__DEVELOPMENT__) === null || _config$env$__DEVELOP === void 0 ? void 0 : _config$env$__DEVELOP.accountLinks) !== null && _ref !== void 0 ? _ref : [];
+  if (accountLinks.length > 0) {
+    return _mapInstanceProperty(accountLinks).call(accountLinks, menuLink => {
+      var _menuLink$permissions, _menuLink$featureTogg;
+      return {
+        key: menuLink.uriPath,
+        uriPath: menuLink.uriPath,
+        labelAllLocales: mapLabelAllLocalesWithDefaults(menuLink.labelAllLocales, menuLink.defaultLabel),
+        permissions: (_menuLink$permissions = menuLink.permissions) !== null && _menuLink$permissions !== void 0 ? _menuLink$permissions : [],
+        // @ts-ignore: not defined in schema, as it's only used internally.
+        featureToggle: (_menuLink$featureTogg = menuLink.featureToggle) !== null && _menuLink$featureTogg !== void 0 ? _menuLink$featureTogg : null
+      };
+    });
+  }
+  const menuLinks = (_config$env$__DEVELOP2 = config.env.__DEVELOPMENT__) === null || _config$env$__DEVELOP2 === void 0 ? void 0 : _config$env$__DEVELOP2.menuLinks;
+  return {
+    key: entryPointUriPath,
+    uriPath: entryPointUriPath,
+    icon: menuLinks.icon,
+    labelAllLocales: mapLabelAllLocalesWithDefaults(menuLinks === null || menuLinks === void 0 ? void 0 : menuLinks.labelAllLocales, menuLinks === null || menuLinks === void 0 ? void 0 : menuLinks.defaultLabel),
+    permissions: menuLinks.permissions,
+    // @ts-ignore: not defined in schema, as it's only used internally.
+    featureToggle: (_menuLinks$featureTog = menuLinks.featureToggle) !== null && _menuLinks$featureTog !== void 0 ? _menuLinks$featureTog : null,
+    // @ts-ignore: not defined in schema, as it's only used internally.
+    menuVisibility: (_menuLinks$menuVisibi = menuLinks.menuVisibility) !== null && _menuLinks$menuVisibi !== void 0 ? _menuLinks$menuVisibi : null,
+    // @ts-ignore: not defined in schema, as it's only used internally.
+    actionRights: (_menuLinks$actionRigh = menuLinks.actionRights) !== null && _menuLinks$actionRigh !== void 0 ? _menuLinks$actionRigh : null,
+    // @ts-ignore: not defined in schema, as it's only used internally.
+    dataFences: (_menuLinks$dataFences = menuLinks.dataFences) !== null && _menuLinks$dataFences !== void 0 ? _menuLinks$dataFences : null,
+    submenu: _mapInstanceProperty(_context = menuLinks.submenuLinks).call(_context, submenuLink => {
+      var _submenuLink$featureT, _submenuLink$menuVisi, _submenuLink$actionRi, _submenuLink$dataFenc;
+      return {
+        key: submenuLink.uriPath.replace('/', '-'),
+        uriPath: submenuLink.uriPath,
+        labelAllLocales: mapLabelAllLocalesWithDefaults(submenuLink.labelAllLocales, submenuLink.defaultLabel),
+        permissions: submenuLink.permissions,
+        // @ts-ignore: not defined in schema, as it's only used internally.
+        featureToggle: (_submenuLink$featureT = submenuLink.featureToggle) !== null && _submenuLink$featureT !== void 0 ? _submenuLink$featureT : null,
+        // @ts-ignore: not defined in schema, as it's only used internally.
+        menuVisibility: (_submenuLink$menuVisi = submenuLink.menuVisibility) !== null && _submenuLink$menuVisi !== void 0 ? _submenuLink$menuVisi : null,
+        // @ts-ignore: not defined in schema, as it's only used internally.
+        actionRights: (_submenuLink$actionRi = submenuLink.actionRights) !== null && _submenuLink$actionRi !== void 0 ? _submenuLink$actionRi : null,
+        // @ts-ignore: not defined in schema, as it's only used internally.
+        dataFences: (_submenuLink$dataFenc = submenuLink.dataFences) !== null && _submenuLink$dataFenc !== void 0 ? _submenuLink$dataFenc : null
+      };
+    }),
+    // @ts-ignore: not defined in schema, as it's only used internally.
+    shouldRenderDivider: (_menuLinks$shouldRend = menuLinks.shouldRenderDivider) !== null && _menuLinks$shouldRend !== void 0 ? _menuLinks$shouldRend : false
+  };
+};
+async function command$2(cliFlags, cwd) {
+  const applicationDirectory = getApplicationDirectory(cwd);
+  const monorepoRoot = findRootSync(cwd);
+  const dotenvPath = cliFlags.dotenvFolder && path.join(monorepoRoot.rootDir, cliFlags.dotenvFolder);
+  const processEnv = _objectSpread$1(_objectSpread$1({}, loadDotenvFiles({
+    dotenvPath,
+    // The env itself is not important for the menu. However, the application config
+    // uses environment placeholders and therefore we need to provide the variables for it.
+    cloudEnvironment: 'ctp-gcp-staging'
+  })), {}, {
+    // Again, make sure that the environment is "development", otherwise
+    // the menu config won't be available.
+    NODE_ENV: 'development',
+    MC_APP_ENV: 'development',
+    // Something random, just to have environment variable defined.
+    REVISION: '123'
+  });
+  const applicationRuntimeConfig = processConfig({
+    disableCache: true,
+    applicationPath: applicationDirectory,
+    processEnv
+  });
+  const applicationMenu = mapApplicationMenuConfigToGraqhQLMenuJson(applicationRuntimeConfig);
+  const formattedJson = _JSON$stringify(applicationMenu, null, 2);
+  fs.writeFileSync(path.join(applicationDirectory, 'menu.json'), formattedJson, {
+    encoding: 'utf8'
+  });
+}
+
+async function command$1(cliFlags) {
+  const numberOfRollbacks = cliFlags.rollbacks - 1;
+  let nextRollbacks;
+  try {
+    var _context, _context2;
+    // The last build's JSON becomes the first rollback
+    // while all previous rollbacks remain but are sliced.
+    const lastVersionResponse = await fetch(cliFlags.versionUrl);
+    const lastVersionJson = await lastVersionResponse.json();
+    const previousBuild = lastVersionJson && {
+      buildNumber: lastVersionJson.buildNumber,
+      revision: lastVersionJson.revision,
+      deployedAt: lastVersionJson.deployedAt
+    };
+    nextRollbacks = _sliceInstanceProperty(_context = _filterInstanceProperty(_context2 = [previousBuild, ...lastVersionJson.rollbacks]).call(_context2, Boolean)).call(_context, 0, numberOfRollbacks);
+  } catch (error) {
+    nextRollbacks = [];
+  }
+  const nextBuild = {
+    buildNumber: cliFlags.buildNumber,
+    revision: cliFlags.buildRevision,
+    deployedAt: new Date().toISOString(),
+    rollbacks: nextRollbacks
+  };
+  const formattedJson = _JSON$stringify(nextBuild, null, 2);
+  // Logging to stdout which is from where it will be picked
+  // up by the caller (a bash script).
+  if (cliFlags.outFile) {
+    fs.writeFileSync(cliFlags.outFile, formattedJson, {
+      encoding: 'utf8'
+    });
+  } else {
+    console.log(formattedJson);
+  }
+}
+
+function ownKeys(object, enumerableOnly) { var keys = _Object$keys(object); if (_Object$getOwnPropertySymbols) { var symbols = _Object$getOwnPropertySymbols(object); enumerableOnly && (symbols = _filterInstanceProperty(symbols).call(symbols, function (sym) { return _Object$getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var _context, _context2; var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? _forEachInstanceProperty(_context = ownKeys(Object(source), !0)).call(_context, function (key) { _defineProperty(target, key, source[key]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(target, _Object$getOwnPropertyDescriptors(source)) : _forEachInstanceProperty(_context2 = ownKeys(Object(source))).call(_context2, function (key) { _Object$defineProperty(target, key, _Object$getOwnPropertyDescriptor(source, key)); }); } return target; }
+const baseMenuProperties = {
+  key: {
+    type: 'string'
+  },
+  uriPath: {
+    type: 'string'
+  },
+  icon: {
+    type: 'string'
+  },
+  featureToggle: {
+    type: ['string', 'null']
+  },
+  labelAllLocales: {
+    type: 'array',
+    items: [{
+      type: 'object',
+      properties: {
+        locale: {
+          type: 'string'
+        },
+        value: {
+          type: 'string'
+        }
+      },
+      required: ['locale', 'value']
+    }]
+  },
+  menuVisibility: {
+    type: ['string', 'null']
+  },
+  permissions: {
+    type: 'array',
+    items: {
+      type: 'string'
+    }
+  },
+  dataFences: {
+    type: ['array', 'null'],
+    items: [{
+      type: ['object'],
+      properties: {
+        group: {
+          type: 'string'
+        },
+        name: {
+          type: 'string'
+        },
+        type: {
+          type: 'string'
+        }
+      }
+    }]
+  },
+  actionRights: {
+    type: ['array', 'null'],
+    items: [{
+      type: ['object'],
+      properties: {
+        group: {
+          type: 'string'
+        },
+        name: {
+          type: 'string'
+        }
+      }
+    }]
+  }
+};
+const navbarMenuSchema = {
+  $schema: 'https://json-schema.org/draft/2020-12/schema',
+  // "$id":""
+  title: 'NavbarMenu',
+  type: 'object',
+  properties: _objectSpread(_objectSpread({}, baseMenuProperties), {}, {
+    submenu: {
+      type: 'array',
+      items: [{
+        type: 'object',
+        properties: baseMenuProperties
+      }]
+    }
+  }),
+  required: ['icon', 'key', 'labelAllLocales', 'permissions', 'submenu', 'uriPath']
+};
+const appbarMenuSchema = {
+  $schema: 'https://json-schema.org/draft/2020-12/schema',
+  // "$id":""
+  title: 'AppbarMenu',
+  type: 'array',
+  items: [{
+    type: 'object',
+    properties: baseMenuProperties,
+    required: ['key', 'labelAllLocales', 'permissions', 'uriPath']
+  }]
+};
+
+function validateMenu(menuJson) {
+  let schema = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : navbarMenuSchema;
+  const validator = new Validator();
+  const result = validator.validate(menuJson, schema);
+  if (result.valid) {
+    return menuJson;
+  } else {
+    throw new Error('menu.json validation failed\n' + result.errors);
+  }
+}
+async function command(cliFlags) {
+  const menuJsonPath = cliFlags.inputFile;
+  const isAppbarMenu = cliFlags.navigation === 'top';
+  if (!menuJsonPath) throw new Error("--input-file cannot be empty. please provide the path of compiled menu.json");
+  if (!fs.existsSync(menuJsonPath)) throw new Error("The menu.json file doesn't exist: ".concat(menuJsonPath));
+  const menuJson = fs.readFileSync(menuJsonPath, 'utf-8');
+  return validateMenu(JSON.parse(menuJson), isAppbarMenu ? appbarMenuSchema : navbarMenuSchema);
+}
+
+var pkgJson = {
+	name: "@commercetools-frontend/application-cli",
+	version: "1.5.0",
+	description: "Internal CLI to manage Merchant Center application deployments across various environments.",
+	keywords: [
+		"commercetools",
+		"cli",
+		"custom-application"
+	],
+	license: "MIT",
+	main: "dist/commercetools-frontend-application-cli.cjs.js",
+	module: "dist/commercetools-frontend-application-cli.esm.js",
+	bin: "bin/cli.js",
+	files: [
+		"cli",
+		"dist",
+		"package.json",
+		"LICENSE",
+		"README.md"
+	],
+	scripts: {
+		typecheck: "tsc --noEmit"
+	},
+	dependencies: {
+		"@babel/core": "^7.21.0",
+		"@babel/runtime": "^7.21.0",
+		"@babel/runtime-corejs3": "^7.21.0",
+		"@commercetools-frontend/application-config": "22.2.1",
+		"@commercetools-frontend/constants": "22.2.1",
+		"@manypkg/find-root": "2.1.0",
+		cac: "^6.7.14",
+		cosmiconfig: "8.1.3",
+		dotenv: "16.0.3",
+		execa: "5.1.1",
+		jsonschema: "^1.4.1",
+		listr2: "^6.4.2",
+		"node-fetch": "2.6.9"
+	},
+	devDependencies: {
+		"@tsconfig/node18": "1.0.3",
+		"@types/node": "18.15.12",
+		"@types/node-fetch": "2.6.3",
+		typescript: "^4.9.5"
+	},
+	engines: {
+		node: ">=14",
+		npm: ">=6"
+	},
+	publishConfig: {
+		access: "public"
+	},
+	preconstruct: {
+		entrypoints: [
+			"./cli.ts"
+		]
+	}
+};
+
+const cli = cac('application-cli');
+const cwd = process.cwd();
+const run = async () => {
+  cli.option('--build-revision [git-sha]', '(optional) The git commit SHA which is being built.', {
+    default: process.env.CIRCLE_SHA1
+  }).option('--build-number [string]', '(optional) A number of the build on the Continuous Integration system.', {
+    default: process.env.CIRCLE_BUILD_NUM
+  }).option('--package-manager-name [string]', '(optional) Name of the binary of the used package manager (e.g. pnpm).', {
+    default: 'yarn'
+  });
+
+  // Default command
+  cli.command('').usage('\n\n  Compile deployments and menus and create versions for MC applications').action(cli.outputHelp);
+  const usageCompileDeployment = 'Compile the deployments for an application for all environments.';
+  cli.command('compile-deployments', usageCompileDeployment).usage("compile-deployments \n\n  ".concat(usageCompileDeployment)).option('--application-name <string>', '(required) The name of the application being compiled for example application-products.').option('--dotenv-folder [string]', '(optional) The path to a folder containing a dotenv file ".env.production" and a cloud-environment specific dotenv file (for example ".env.gcp-production-eu"). Those values are parsed and merged together to be used by the `mc-scripts compile-html` command.').option('--pr-number [string]', '(optional) A pull request number determining a scoped storage bucket for the deployment. Please use it carefully.').option('--mc-url [string]', '(optional) The MC URL of the deployment. This is usually inferred from the env file and overwrites the value. Please use it carefully.').option('--mc-api-url [string]', '(optional) The MC API URL of the deployment. This is usually inferred from the env file and overwrites the value. Please use it carefully.').option('--application-index-out-file [path]', '(optional) The name of the application index file.', {
+    default: 'application.html'
+  }).option('--application-index-upload-script-out-file [path]', '(optional) The name of the the application index upload script file.', {
+    default: 'upload-index.sh'
+  }).option('--application-assets-upload-script-out-file [path]', '(optional) The name of the the assets upload script file.', {
+    default: 'upload-assets.sh'
+  }).option('--ci-assets-root-path [path]', '(optional) A replacement value for the scripts root path only used on CI (e.g. "--ci-assets-root-path=/root/") used in generated scripts.').option('--skip-menu', '(optional) If provided, it will skip uploading the `menu.json`.', {
+    default: false
+  }).action(async options => {
+    await command$3(options, cwd);
+  });
+  const usageCompileMenu = 'Compile the menu links of an application into a `menu.json`. This is only required for internal applications';
+  cli.command('compile-menu', usageCompileMenu).usage("compile-menu \n\n  ".concat(usageCompileMenu)).option('--dotenv-folder [string]', '(optional) The path to a folder containing a dotenv file `.env.production` and a cloud-environment specific dotenv file (for example `.env.gcp-production-eu`). Those values are parsed and merged together to be used by the application config.').action(async options => {
+    await command$2(options, cwd);
+  });
+  const usageValidateMenu = 'Validate compiled `menu.json` file';
+  cli.command('validate-menu', usageValidateMenu).usage("validate-menu \n\n  ".concat(usageValidateMenu)).option('--input-file <path>', '(required) The path to the `menu.json` file to be validated.').option('--navigation [string]', '(optional) Location of the menu navigation. Possible values are `top`.').action(async options => {
+    await command(options);
+  });
+  const usageCreateVersion = 'Output a JSON string about the information in the `version.json` for a deployment, including the updated list of rollbacks.';
+  cli.command('create-version', usageCreateVersion).usage("create-version \n\n  ".concat(usageCreateVersion)).option('--version-url <url>', "(required) The path of an application's current `version.json` within the storage bucket.").option('--rollbacks [int]', '(optional) The number of max rollbacks to keep', {
+    default: 15
+  }).option('--out-file [path]', '(optional) The path to the file where to write the JSON. If not specified, the JSON is printed to stdout.').action(async options => {
+    await command$1(options);
+  });
+  cli.help();
+  cli.version(pkgJson.version);
+  cli.parse(process.argv, {
+    run: false
+  });
+  await cli.runMatchedCommand();
+};
+
+export { run };