@hubspot/cli 4.1.8-beta.0 → 4.1.8-beta.2

package/lib/sandboxes.js

@@ -1,13 +1,10 @@
-const cliProgress = require('cli-progress');
 const {
   getConfig,
   writeConfig,
   updateAccountConfig,
+  getAccountId,
 } = require('@hubspot/cli-lib');
-const {
-  DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME,
-  PERSONAL_ACCESS_KEY_AUTH_METHOD,
-} = require('@hubspot/cli-lib/lib/constants');
+const chalk = require('chalk');
 const { i18n } = require('@hubspot/cli-lib/lib/lang');
 const { logger } = require('@hubspot/cli-lib/logger');
 const {
@@ -15,36 +12,68 @@ const {
 } = require('@hubspot/cli-lib/personalAccessKey');
 const { EXIT_CODES } = require('./enums/exitCodes');
 const { enterAccountNamePrompt } = require('./prompts/enterAccountNamePrompt');
+const {
+  fetchTaskStatus,
+  fetchTypes,
+  getSandboxUsageLimits,
+} = require('@hubspot/cli-lib/sandboxes');
+const { handleExit, handleKeypress } = require('@hubspot/cli-lib/lib/process');
+const { accountNameExistsInConfig } = require('@hubspot/cli-lib/lib/config');
+const CliProgressMultibarManager = require('./CliProgressMultibarManager');
+const { promptUser } = require('./prompts/promptUtils');
+const { getHubSpotWebsiteOrigin } = require('@hubspot/cli-lib/lib/urls');
 const {
   personalAccessKeyPrompt,
 } = require('./prompts/personalAccessKeyPrompt');
-const {
-  setAsDefaultAccountPrompt,
-} = require('./prompts/setAsDefaultAccountPrompt');
-const { uiFeatureHighlight } = require('./ui');
-const { fetchTaskStatus, fetchTypes } = require('@hubspot/cli-lib/sandboxes');
-const { handleExit, handleKeypress } = require('@hubspot/cli-lib/lib/process');
 
-const getSandboxType = type =>
+const STANDARD_SANDBOX = 'standard';
+const DEVELOPER_SANDBOX = 'developer';
+
+const syncTypes = {
+  OBJECT_RECORDS: 'object-records',
+};
+
+const sandboxTypeMap = {
+  DEV: DEVELOPER_SANDBOX,
+  dev: DEVELOPER_SANDBOX,
+  DEVELOPER: DEVELOPER_SANDBOX,
+  developer: DEVELOPER_SANDBOX,
+  DEVELOPMENT: DEVELOPER_SANDBOX,
+  development: DEVELOPER_SANDBOX,
+  STANDARD: STANDARD_SANDBOX,
+  standard: STANDARD_SANDBOX,
+};
+
+const sandboxApiTypeMap = {
+  standard: 1,
+  developer: 2,
+};
+
+const getSandboxTypeAsString = type =>
   type === 'DEVELOPER' ? 'development' : 'standard';
 
+const isSandbox = config =>
+  config.sandboxAccountType && config.sandboxAccountType !== null;
+
 function getAccountName(config) {
-  const isSandbox =
-    config.sandboxAccountType && config.sandboxAccountType !== null;
-  const sandboxName = `[${getSandboxType(config.sandboxAccountType)} sandbox] `;
-  return `${config.name} ${isSandbox ? sandboxName : ''}(${config.portalId})`;
+  const sandboxName = `[${getSandboxTypeAsString(
+    config.sandboxAccountType
+  )} sandbox] `;
+  return chalk.bold(
+    `${config.name} ${isSandbox(config) ? sandboxName : ''}(${config.portalId})`
+  );
 }
 
-function getHasDevelopmentSandboxes(parentAccountConfig) {
+function getHasSandboxesByType(parentAccountConfig, type) {
   const config = getConfig();
-  const parentPortalId = parentAccountConfig.portalId;
+  const parentPortalId = getAccountId(parentAccountConfig.portalId);
   for (const portal of config.portals) {
     if (
       (portal.parentAccountId !== null ||
         portal.parentAccountId !== undefined) &&
       portal.parentAccountId === parentPortalId &&
       portal.sandboxAccountType &&
-      portal.sandboxAccountType === 'DEVELOPER'
+      sandboxTypeMap[portal.sandboxAccountType] === type
     ) {
       return true;
     }
@@ -52,7 +81,7 @@ function getHasDevelopmentSandboxes(parentAccountConfig) {
   return false;
 }
 
-function getDevSandboxLimit(error) {
+function getSandboxLimit(error) {
   // Error context should contain a limit property with a list of one number. That number is the current limit
   const limit = error.context && error.context.limit && error.context.limit[0];
   return limit ? parseInt(limit, 10) : 1; // Default to 1
@@ -60,31 +89,186 @@ function getDevSandboxLimit(error) {
 
 // Fetches available sync types for a given sandbox portal
 async function getAvailableSyncTypes(parentAccountConfig, config) {
-  const parentPortalId = parentAccountConfig.portalId;
-  const portalId = config.portalId;
+  const parentPortalId = getAccountId(parentAccountConfig.portalId);
+  const portalId = getAccountId(config.portalId);
   const syncTypes = await fetchTypes(parentPortalId, portalId);
+  if (!syncTypes) {
+    throw new Error(
+      'Unable to fetch available sandbox sync types. Please try again.'
+    );
+  }
   return syncTypes.map(t => ({ type: t.name }));
 }
 
-const sandboxCreatePersonalAccessKeyFlow = async (env, account, name) => {
-  const configData = await personalAccessKeyPrompt({ env, account });
-  const updatedConfig = await updateConfigWithPersonalAccessKey(configData);
+/**
+ * @param {Object} accountConfig - Account config of sandbox portal
+ * @param {Array} availableSyncTasks - Array of available sync tasks
+ * @param {Boolean} skipPrompt - Option to skip contact records prompt and return all available sync tasks
+ * @returns {Array} Adjusted available sync task items
+ */
+const getSyncTypesWithContactRecordsPrompt = async (
+  accountConfig,
+  syncTasks,
+  skipPrompt = false
+) => {
+  // Fetches sync types based on default account. Parent account required for fetch
+
+  if (
+    syncTasks &&
+    syncTasks.some(t => t.type === syncTypes.OBJECT_RECORDS) &&
+    !skipPrompt
+  ) {
+    const { contactRecordsSyncPrompt } = await promptUser([
+      {
+        name: 'contactRecordsSyncPrompt',
+        type: 'confirm',
+        message: i18n(
+          `cli.lib.sandbox.sync.confirm.syncContactRecords.${
+            sandboxTypeMap[accountConfig.sandboxAccountType]
+          }`
+        ),
+      },
+    ]);
+    if (!contactRecordsSyncPrompt) {
+      return syncTasks.filter(t => t.type !== syncTypes.OBJECT_RECORDS);
+    }
+  }
+  return syncTasks;
+};
+
+/**
+ * @param {Object} accountConfig - Account config of sandbox portal
+ * @param {String} sandboxType - Sandbox type for limit validation
+ * @param {String} env - Environment
+ * @returns {null}
+ */
+const validateSandboxUsageLimits = async (accountConfig, sandboxType, env) => {
+  const accountId = getAccountId(accountConfig.portalId);
+  const usage = await getSandboxUsageLimits(accountId);
+  if (!usage) {
+    throw new Error('Unable to fetch sandbox usage limits. Please try again.');
+  }
+  if (sandboxType === DEVELOPER_SANDBOX) {
+    if (usage['DEVELOPER'].available === 0) {
+      const devSandboxLimit = usage['DEVELOPER'].limit;
+      const plural = devSandboxLimit !== 1;
+      const hasDevelopmentSandboxes = getHasSandboxesByType(
+        accountConfig,
+        DEVELOPER_SANDBOX
+      );
+      if (hasDevelopmentSandboxes) {
+        throw new Error(
+          i18n(
+            `cli.lib.sandbox.create.failure.alreadyInConfig.developer.${
+              plural ? 'other' : 'one'
+            }`,
+            {
+              accountName: accountConfig.name || accountId,
+              limit: devSandboxLimit,
+            }
+          )
+        );
+      } else {
+        const baseUrl = getHubSpotWebsiteOrigin(env);
+        throw new Error(
+          i18n(
+            `cli.lib.sandbox.create.failure.limit.developer.${
+              plural ? 'other' : 'one'
+            }`,
+            {
+              accountName: accountConfig.name || accountId,
+              limit: devSandboxLimit,
+              link: `${baseUrl}/sandboxes-developer/${accountId}/development`,
+            }
+          )
+        );
+      }
+    }
+  }
+  if (sandboxType === STANDARD_SANDBOX) {
+    if (usage['STANDARD'].available === 0) {
+      const standardSandboxLimit = usage['STANDARD'].limit;
+      const plural = standardSandboxLimit !== 1;
+      const hasStandardSandboxes = getHasSandboxesByType(
+        accountConfig,
+        STANDARD_SANDBOX
+      );
+      if (hasStandardSandboxes) {
+        throw new Error(
+          i18n(
+            `cli.lib.sandbox.create.failure.alreadyInConfig.standard.${
+              plural ? 'other' : 'one'
+            }`,
+            {
+              accountName: accountConfig.name || accountId,
+              limit: standardSandboxLimit,
+            }
+          )
+        );
+      } else {
+        const baseUrl = getHubSpotWebsiteOrigin(env);
+        throw new Error(
+          i18n(
+            `cli.lib.sandbox.create.failure.limit.standard.${
+              plural ? 'other' : 'one'
+            }`,
+            {
+              accountName: accountConfig.name || accountId,
+              limit: standardSandboxLimit,
+              link: `${baseUrl}/sandboxes-developer/${accountId}/standard`,
+            }
+          )
+        );
+      }
+    }
+  }
+};
 
+/**
+ * @param {String} env - Environment (QA/Prod)
+ * @param {Object} result - Sandbox instance returned from API
+ * @param {Boolean} force - Force flag to skip prompt
+ * @returns {String} validName saved into config
+ */
+const saveSandboxToConfig = async (env, result, force = false) => {
+  let configData = { env, personalAccessKey: result.personalAccessKey };
+  if (!result.personalAccessKey) {
+    configData = await personalAccessKeyPrompt({
+      env,
+      account: result.sandbox.sandboxHubId,
+    });
+  }
+  const updatedConfig = await updateConfigWithPersonalAccessKey(configData);
   if (!updatedConfig) {
-    process.exit(EXIT_CODES.SUCCESS);
+    throw new Error('Failed to update config with personal access key.');
   }
 
   let validName = updatedConfig.name;
-
   if (!updatedConfig.name) {
-    const nameForConfig = name
+    const nameForConfig = result.sandbox.name
       .toLowerCase()
       .split(' ')
       .join('-');
-    const { name: promptName } = await enterAccountNamePrompt(nameForConfig);
-    validName = promptName;
+    validName = nameForConfig;
+    const invalidAccountName = accountNameExistsInConfig(nameForConfig);
+    if (invalidAccountName) {
+      if (!force) {
+        logger.log(
+          i18n(
+            `cli.lib.prompts.enterAccountNamePrompt.errors.accountNameExists`,
+            { name: nameForConfig }
+          )
+        );
+        const { name: promptName } = await enterAccountNamePrompt(
+          nameForConfig
+        );
+        validName = promptName;
+      } else {
+        // Basic invalid name handling when force flag is passed
+        validName = nameForConfig + `_${Date.now()}`;
+      }
+    }
   }
-
   updateAccountConfig({
     ...updatedConfig,
     environment: updatedConfig.env,
@@ -93,35 +277,8 @@ const sandboxCreatePersonalAccessKeyFlow = async (env, account, name) => {
   });
   writeConfig();
 
-  const setAsDefault = await setAsDefaultAccountPrompt(validName);
-
   logger.log('');
-  if (setAsDefault) {
-    logger.success(
-      i18n(`cli.lib.prompts.setAsDefaultAccountPrompt.setAsDefaultAccount`, {
-        accountName: validName,
-      })
-    );
-  } else {
-    const config = getConfig();
-    logger.info(
-      i18n(`cli.lib.prompts.setAsDefaultAccountPrompt.keepingCurrentDefault`, {
-        accountName: config.defaultPortal,
-      })
-    );
-  }
-  logger.success(
-    i18n('cli.commands.sandbox.subcommands.create.success.configFileUpdated', {
-      configFilename: DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME,
-      authMethod: PERSONAL_ACCESS_KEY_AUTH_METHOD.name,
-      account: validName,
-    })
-  );
-  uiFeatureHighlight([
-    'accountsUseCommand',
-    'accountOption',
-    'accountsListCommand',
-  ]);
+  return validName;
 };
 
 const ACTIVE_TASK_POLL_INTERVAL = 1000;
@@ -133,46 +290,56 @@ const isTaskComplete = task => {
   return task.status === 'COMPLETE';
 };
 
-// Returns a promise to poll a sync task with taskId. Interval runs until sync task status is equal to 'COMPLETE'
-function pollSyncTaskStatus(accountId, taskId, syncStatusUrl) {
-  const i18nKey = 'cli.commands.sandbox.subcommands.sync.types';
-  const multibar = new cliProgress.MultiBar(
-    {
-      hideCursor: true,
-      format: '[{bar}] {percentage}% | {taskType}',
-      gracefulExit: true,
-    },
-    cliProgress.Presets.rect
-  );
+const incrementBy = (value, multiplier = 3) => {
+  return Math.min(value + Math.floor(Math.random() * multiplier), 99);
+};
+
+/**
+ * @param {Number} accountId - Parent portal ID (needs sandbox scopes)
+ * @param {String} taksId - Task ID to poll
+ * @param {String} syncStatusUrl - Link to UI to check polling status
+ * @param {Boolean} allowEarlyTermination - Option to allow a keypress to terminate early
+ * @returns {Promise} Interval runs until sync task status is equal to 'COMPLETE'
+ */
+function pollSyncTaskStatus(
+  accountId,
+  taskId,
+  syncStatusUrl,
+  allowEarlyTermination = true
+) {
+  const i18nKey = 'cli.lib.sandbox.sync.types';
+  const progressBar = CliProgressMultibarManager.init();
   const mergeTasks = {
     'lead-flows': 'forms', // lead-flows are a subset of forms. We combine these in the UI as a single item, so we want to merge here for consistency.
   };
-  const barInstances = {};
+  let progressCounter = {};
   let pollInterval;
   // Handle manual exit for return key and ctrl+c
   const onTerminate = () => {
     clearInterval(pollInterval);
-    multibar.stop();
+    progressBar.stop();
     logger.log('');
     logger.log('Exiting, sync will continue in the background.');
     logger.log('');
     logger.log(
-      i18n('cli.commands.sandbox.subcommands.sync.info.syncStatus', {
+      i18n('cli.lib.sandbox.sync.info.syncStatus', {
         url: syncStatusUrl,
       })
     );
     process.exit(EXIT_CODES.SUCCESS);
   };
-  handleExit(onTerminate);
-  handleKeypress(key => {
-    if (
-      (key && key.ctrl && key.name == 'c') ||
-      key.name === 'enter' ||
-      key.name === 'return'
-    ) {
-      onTerminate();
-    }
-  });
+  if (allowEarlyTermination) {
+    handleExit(onTerminate);
+    handleKeypress(key => {
+      if (
+        (key && key.ctrl && key.name == 'c') ||
+        key.name === 'enter' ||
+        key.name === 'return'
+      ) {
+        onTerminate();
+      }
+    });
+  }
   return new Promise((resolve, reject) => {
     pollInterval = setInterval(async () => {
       const taskResult = await fetchTaskStatus(accountId, taskId).catch(reject);
@@ -181,13 +348,17 @@ function pollSyncTaskStatus(accountId, taskId, syncStatusUrl) {
         for (const task of taskResult.tasks) {
           // For each sync task, show a progress bar and increment bar each time we run this interval until status is 'COMPLETE'
           const taskType = task.type;
-          if (!barInstances[taskType] && !mergeTasks[taskType]) {
-            // skip creation of lead-flows bar because we're combining lead-flows into the forms bar
-            barInstances[taskType] = multibar.create(100, 0, {
-              taskType: i18n(`${i18nKey}.${taskType}.label`),
+          if (!progressBar.get(taskType) && !mergeTasks[taskType]) {
+            // skip creation of lead-flows bar because we're combining lead-flows into the forms bar, otherwise create a bar instance for the type
+            progressCounter[taskType] = 0;
+            progressBar.create(taskType, 100, 0, {
+              label: i18n(`${i18nKey}.${taskType}.label`),
             });
           } else if (mergeTasks[taskType]) {
-            // If its a lead-flow, merge status into the forms progress bar
+            // It's a lead-flow here, merge status into the forms progress bar
+            if (!progressCounter[mergeTasks[taskType]]) {
+              progressCounter[mergeTasks[taskType]] = 0;
+            }
             const formsTask = taskResult.tasks.filter(
               t => t.type === mergeTasks[taskType]
             )[0];
@@ -197,46 +368,66 @@ function pollSyncTaskStatus(accountId, taskId, syncStatusUrl) {
               formsTaskStatus !== 'COMPLETE' ||
               leadFlowsTaskStatus !== 'COMPLETE'
             ) {
-              barInstances[mergeTasks[taskType]].increment(
-                Math.floor(Math.random() * 3),
+              // Randomly increment bar while sync is in progress. Sandboxes currently does not have an accurate measurement for progress.
+              progressCounter[mergeTasks[taskType]] = incrementBy(
+                progressCounter[mergeTasks[taskType]]
+              );
+              progressBar.update(
+                mergeTasks[taskType],
+                progressCounter[mergeTasks[taskType]],
                 {
-                  taskType: i18n(`${i18nKey}.${mergeTasks[taskType]}.label`),
+                  label: i18n(`${i18nKey}.${mergeTasks[taskType]}.label`),
                 }
               );
             }
           }
-          if (barInstances[taskType] && task.status === 'COMPLETE') {
-            barInstances[taskType].update(100, {
-              taskType: i18n(`${i18nKey}.${taskType}.label`),
+          if (progressBar.get(taskType) && task.status === 'COMPLETE') {
+            progressBar.update(taskType, 100, {
+              label: i18n(`${i18nKey}.${taskType}.label`),
             });
-          } else if (barInstances[taskType] && task.status === 'PROCESSING') {
-            // Do not increment for tasks still in PENDING state
-            barInstances[taskType].increment(Math.floor(Math.random() * 3), {
-              // Randomly increment bar by 0 - 2 while sync is in progress. Sandboxes currently does not have an accurate measurement for progress.
-              taskType: i18n(`${i18nKey}.${taskType}.label`),
+          } else if (
+            // Do not start incrementing for tasks still in PENDING state
+            progressBar.get(taskType) &&
+            task.status === 'PROCESSING'
+          ) {
+            // Randomly increment bar while sync is in progress. Sandboxes currently does not have an accurate measurement for progress.
+            progressCounter[taskType] = incrementBy(
+              progressCounter[taskType],
+              taskType === syncTypes.OBJECT_RECORDS ? 2 : 3 // slower progress for object-records, sync can take up to a few minutes
+            );
+            progressBar.update(taskType, progressCounter[taskType], {
+              label: i18n(`${i18nKey}.${taskType}.label`),
             });
           }
         }
       } else {
         clearInterval(pollInterval);
         reject();
-        multibar.stop();
+        progressBar.stop();
       }
       if (isTaskComplete(taskResult)) {
         clearInterval(pollInterval);
         resolve(taskResult);
-        multibar.stop();
+        progressBar.stop();
       }
     }, ACTIVE_TASK_POLL_INTERVAL);
   });
 }
 
 module.exports = {
-  getSandboxType,
+  STANDARD_SANDBOX,
+  DEVELOPER_SANDBOX,
+  sandboxTypeMap,
+  sandboxApiTypeMap,
+  syncTypes,
+  isSandbox,
+  getSandboxTypeAsString,
   getAccountName,
-  getHasDevelopmentSandboxes,
-  getDevSandboxLimit,
+  saveSandboxToConfig,
+  getHasSandboxesByType,
+  getSandboxLimit,
+  validateSandboxUsageLimits,
   getAvailableSyncTypes,
-  sandboxCreatePersonalAccessKeyFlow,
+  getSyncTypesWithContactRecordsPrompt,
   pollSyncTaskStatus,
 };

package/lib/ui.js

@@ -1,3 +1,4 @@
+const process = require('process');
 const chalk = require('chalk');
 const supportsHyperlinks = require('../lib/supportHyperlinks');
 const supportsColor = require('../lib/supportsColor');
@@ -35,7 +36,7 @@ const getTerminalUISupport = () => {
  * @param {object} options
  * @returns {string}
  */
-const uiLink = (linkText, url) => {
+const uiLink = (linkText, url, { inSpinnies = false } = {}) => {
   const terminalUISupport = getTerminalUISupport();
   const encodedUrl = encodeURI(url);
   if (terminalUISupport.hyperlinks) {
@@ -46,12 +47,20 @@ const uiLink = (linkText, url) => {
       linkText,
       '\u001B]8;;\u0007',
     ].join('');
-    return terminalUISupport.color ? chalk.cyan(result) : result;
-  } else {
-    return terminalUISupport.color
-      ? `${linkText}: ${chalk.reset.cyan(encodedUrl)}`
-      : `${linkText}: ${encodedUrl}`;
+
+    // Required b/c spinnies will break long lines
+    // See https://github.com/jbcarpanelli/spinnies/blob/d672dedcab8c8ce0f6de0bb26ca5582bf602afd7/utils.js#L68-L74
+    const columns = process.stderr.columns || 95;
+    const validLength = !inSpinnies || result.length < columns;
+
+    if (validLength) {
+      return terminalUISupport.color ? chalk.cyan(result) : result;
+    }
   }
+
+  return terminalUISupport.color
+    ? `${linkText}: ${chalk.reset.cyan(encodedUrl)}`
+    : `${linkText}: ${encodedUrl}`;
 };
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hubspot/cli",
-  "version": "4.1.8-beta.0",
+  "version": "4.1.8-beta.2",
   "description": "CLI for working with HubSpot",
   "license": "Apache-2.0",
   "repository": {
@@ -8,10 +8,11 @@
     "url": "https://github.com/HubSpot/hubspot-cms-tools"
   },
   "dependencies": {
-    "@hubspot/cli-lib": "4.1.8-beta.0",
-    "@hubspot/serverless-dev-runtime": "4.1.8-beta.0",
+    "@hubspot/cli-lib": "4.1.8-beta.2",
+    "@hubspot/serverless-dev-runtime": "4.1.8-beta.2",
     "archiver": "^5.3.0",
     "chalk": "^4.1.2",
+    "chokidar": "^3.0.1",
     "cli-progress": "^3.11.2",
     "express": "^4.17.1",
     "findup-sync": "^4.0.0",
@@ -20,6 +21,7 @@
     "moment": "^2.29.1",
     "open": "^7.0.3",
     "ora": "^4.0.3",
+    "p-queue": "^6.0.2",
     "spinnies": "^0.5.1",
     "tmp": "^0.2.1",
     "update-notifier": "^5.1.0",
@@ -38,5 +40,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "af16182b2c7abd401771d5e0eed3de21e7b0477c"
+  "gitHead": "99dd6099b4d643bd335b1a1c3a28250ff7b0c39d"
 }