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

package/lib/sandboxes.js

@@ -1,13 +1,9 @@
-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 { i18n } = require('@hubspot/cli-lib/lib/lang');
 const { logger } = require('@hubspot/cli-lib/logger');
 const {
@@ -15,36 +11,55 @@ const {
 } = require('@hubspot/cli-lib/personalAccessKey');
 const { EXIT_CODES } = require('./enums/exitCodes');
 const { enterAccountNamePrompt } = require('./prompts/enterAccountNamePrompt');
+const { fetchTaskStatus, fetchTypes } = require('@hubspot/cli-lib/sandboxes');
+const { handleExit, handleKeypress } = require('@hubspot/cli-lib/lib/process');
+const { accountNameExistsInConfig } = require('@hubspot/cli-lib/lib/config');
 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 CliProgressMultibarManager = require('./CliProgressMultibarManager');
+
+const STANDARD_SANDBOX = 'standard';
+const DEVELOPER_SANDBOX = 'developer';
+
+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 getSandboxType = type =>
+const sandboxApiTypeMap = {
+  standard: 1,
+  developer: 2,
+};
+
+const getSandboxTypeAsString = type =>
   type === 'DEVELOPER' ? 'development' : 'standard';
 
 function getAccountName(config) {
   const isSandbox =
     config.sandboxAccountType && config.sandboxAccountType !== null;
-  const sandboxName = `[${getSandboxType(config.sandboxAccountType)} sandbox] `;
+  const sandboxName = `[${getSandboxTypeAsString(
+    config.sandboxAccountType
+  )} sandbox] `;
   return `${config.name} ${isSandbox ? 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 +67,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 +75,57 @@ 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);
   return syncTypes.map(t => ({ type: t.name }));
 }
 
-const sandboxCreatePersonalAccessKeyFlow = async (env, account, name) => {
-  const configData = await personalAccessKeyPrompt({ env, account });
+/**
+ * @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) => {
+  // const configData = { env, personalAccessKey: result.personalAccessKey };
+  // TODO: Temporary, remove
+  const configData = await personalAccessKeyPrompt({
+    env,
+    account: result.sandbox.sandboxHubId,
+  });
+  // End temporary section
   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 +134,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,26 +147,34 @@ 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('');
@@ -163,16 +185,18 @@ function pollSyncTaskStatus(accountId, taskId, 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 +205,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 +225,62 @@ 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 === '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,
+  getSandboxTypeAsString,
   getAccountName,
-  getHasDevelopmentSandboxes,
-  getDevSandboxLimit,
+  saveSandboxToConfig,
+  getHasSandboxesByType,
+  getSandboxLimit,
   getAvailableSyncTypes,
-  sandboxCreatePersonalAccessKeyFlow,
   pollSyncTaskStatus,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hubspot/cli",
-  "version": "4.1.8-beta.0",
+  "version": "4.1.8-beta.1",
   "description": "CLI for working with HubSpot",
   "license": "Apache-2.0",
   "repository": {
@@ -8,8 +8,8 @@
     "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.1",
+    "@hubspot/serverless-dev-runtime": "4.1.8-beta.1",
     "archiver": "^5.3.0",
     "chalk": "^4.1.2",
     "cli-progress": "^3.11.2",
@@ -38,5 +38,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "af16182b2c7abd401771d5e0eed3de21e7b0477c"
+  "gitHead": "8aafada9270602e912d89fc6a513816f5f7232bb"
 }