@hubspot/cli 5.2.1-beta.8 → 5.3.0

package/lib/buildAccount.js

@@ -13,7 +13,7 @@ const {
 } = require('@hubspot/local-dev-lib/config');
 const { logger } = require('@hubspot/local-dev-lib/logger');
 const { i18n } = require('./lang');
-const { enterAccountNamePrompt } = require('./prompts/enterAccountNamePrompt');
+const { cliAccountNamePrompt } = require('./prompts/accountNamePrompt');
 const SpinniesManager = require('./ui/SpinniesManager');
 const {
   debugErrorAndContext,
@@ -65,11 +65,11 @@ async function saveAccountToConfig({
       if (!force) {
         logger.log('');
         logger.warn(
-          i18n(`lib.prompts.enterAccountNamePrompt.errors.accountNameExists`, {
+          i18n(`lib.prompts.accountNamePrompt.errors.accountNameExists`, {
             name: nameForConfig,
           })
         );
-        const { name: promptName } = await enterAccountNamePrompt(
+        const { name: promptName } = await cliAccountNamePrompt(
           nameForConfig + `_${accountId}`
         );
         validName = promptName;

package/lib/constants.js

@@ -25,6 +25,7 @@ const POLLING_DELAY = 2000;
 const POLLING_STATUS = {
   SUCCESS: 'SUCCESS',
   ERROR: 'ERROR',
+  REVERTED: 'REVERTED',
   FAILURE: 'FAILURE',
 };
 
@@ -65,8 +66,9 @@ const PROJECT_ERROR_TYPES = {
 };
 const PROJECT_TASK_TYPES = {
   PRIVATE_APP: 'private app',
+  PUBLIC_APP: 'public app',
   APP_FUNCTION: 'function',
-  CRM_CARD_V2: 'crm card',
+  CRM_CARD_V2: 'card',
 };
 const PROJECT_COMPONENT_TYPES = {
   PROJECTS: 'projects',

package/lib/interpolationHelpers.js

@@ -20,4 +20,7 @@ module.exports = {
   cyan: function(stringValue) {
     return chalk.cyan(stringValue);
   },
+  orange: function(stringValue) {
+    return chalk.hex('#FC9900')(stringValue);
+  },
 };

package/lib/localDev.js

@@ -8,18 +8,17 @@ const {
   isSpecifiedError,
 } = require('@hubspot/local-dev-lib/errors/apiErrors');
 const { getHubSpotWebsiteOrigin } = require('@hubspot/local-dev-lib/urls');
-const { getAccountConfig } = require('@hubspot/local-dev-lib/config');
+const { getAccountConfig, getEnv } = require('@hubspot/local-dev-lib/config');
 const { createProject } = require('@hubspot/local-dev-lib/api/projects');
+const {
+  ENVIRONMENTS,
+} = require('@hubspot/local-dev-lib/constants/environments');
 const {
   confirmDefaultAccountPrompt,
   selectSandboxTargetAccountPrompt,
   selectDeveloperTestTargetAccountPrompt,
   confirmUseExistingDeveloperTestAccountPrompt,
 } = require('./prompts/projectDevTargetAccountPrompt');
-const { sandboxNamePrompt } = require('./prompts/sandboxesPrompt');
-const {
-  developerTestAccountNamePrompt,
-} = require('./prompts/developerTestAccountNamePrompt');
 const { confirmPrompt } = require('./prompts/promptUtils');
 const {
   validateSandboxUsageLimits,
@@ -56,6 +55,7 @@ const {
   PERSONAL_ACCESS_KEY_AUTH_METHOD,
 } = require('@hubspot/local-dev-lib/constants/auth');
 const { buildNewAccount, saveAccountToConfig } = require('./buildAccount');
+const { hubspotAccountNamePrompt } = require('./prompts/accountNamePrompt');
 
 const i18nKey = 'lib.localDev';
 
@@ -163,9 +163,9 @@ const createSandboxForLocalDev = async (accountId, accountConfig, env) => {
     process.exit(EXIT_CODES.ERROR);
   }
   try {
-    const { name } = await sandboxNamePrompt(
-      HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX
-    );
+    const { name } = await hubspotAccountNamePrompt({
+      accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+    });
 
     trackCommandMetadataUsage(
       'sandbox-create',
@@ -192,8 +192,7 @@ const createSandboxForLocalDev = async (accountId, accountConfig, env) => {
       parentAccountConfig: accountConfig,
       env,
       syncTasks,
-      allowEarlyTermination: false, // Don't let user terminate early in this flow
-      skipPolling: true, // Skip polling, sync will run and complete in the background
+      slimInfoMessage: true,
     });
     return targetAccountId;
   } catch (err) {
@@ -242,7 +241,10 @@ const createDeveloperTestAccountForLocalDev = async (
   }
 
   try {
-    const { name } = await developerTestAccountNamePrompt(currentPortalCount);
+    const { name } = await hubspotAccountNamePrompt({
+      currentPortalCount,
+      accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+    });
     trackCommandMetadataUsage(
       'developer-test-account-create',
       { step: 'project-dev' },
@@ -427,6 +429,13 @@ const createInitialBuildForNewProject = async (
   return initialUploadResult.buildResult;
 };
 
+const getAccountHomeUrl = accountId => {
+  const baseUrl = getHubSpotWebsiteOrigin(
+    getEnv(accountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD
+  );
+  return `${baseUrl}/home?portalId=${accountId}`;
+};
+
 module.exports = {
   confirmDefaultAccountIsTarget,
   checkIfAppDeveloperAccount,
@@ -437,4 +446,5 @@ module.exports = {
   useExistingDevTestAccount,
   createNewProjectForLocalDev,
   createInitialBuildForNewProject,
+  getAccountHomeUrl,
 };

package/lib/marketplace-validate.js

@@ -57,12 +57,20 @@ const fetchValidationResults = async (accountId, validationId) => {
   }
 };
 
-const processValidationErrors = validationResults => {
+const processValidationErrors = (i18nKey, validationResults) => {
   if (validationResults.errors.length) {
-    const { errors } = validationResults;
+    const { assetPath, errors } = validationResults;
 
     errors.forEach(err => {
-      logger.error(`${err.context}`);
+      if (err.failureReasonType === 'DOWNLOAD_EMPTY') {
+        logger.error(
+          i18n(`${i18nKey}.errors.invalidPath`, {
+            path: assetPath,
+          })
+        );
+      } else {
+        logger.error(`${err.context}`);
+      }
     });
     process.exit(EXIT_CODES.ERROR);
   }

package/lib/polling.js

@@ -3,18 +3,24 @@ const { POLLING_DELAY, POLLING_STATUS } = require('./constants');
 const poll = (callback, accountId, taskId) => {
   return new Promise((resolve, reject) => {
     const pollInterval = setInterval(async () => {
-      const pollResp = await callback(accountId, taskId);
-      const { status } = pollResp;
+      try {
+        const pollResp = await callback(accountId, taskId);
+        const { status } = pollResp;
 
-      if (status === POLLING_STATUS.SUCCESS) {
+        if (status === POLLING_STATUS.SUCCESS) {
+          clearInterval(pollInterval);
+          resolve(pollResp);
+        } else if (
+          status === POLLING_STATUS.ERROR ||
+          status === POLLING_STATUS.REVERTED ||
+          status === POLLING_STATUS.FAILURE
+        ) {
+          clearInterval(pollInterval);
+          reject(pollResp);
+        }
+      } catch (error) {
         clearInterval(pollInterval);
-        resolve(pollResp);
-      } else if (
-        status === POLLING_STATUS.ERROR ||
-        status === POLLING_STATUS.FAILURE
-      ) {
-        clearInterval(pollInterval);
-        reject(pollResp);
+        reject(error);
       }
     }, POLLING_DELAY);
   });

package/lib/projects.js

@@ -60,8 +60,10 @@ const writeProjectConfig = (configPath, config) => {
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
     logger.debug(`Wrote project config at ${configPath}`);
   } catch (e) {
-    logger.error(`Could not write project config at ${configPath}`);
+    logger.debug(e);
+    return false;
   }
+  return true;
 };
 
 const getIsInProject = _dir => {
@@ -326,17 +328,19 @@ const getProjectDetailUrl = (projectName, accountId) => {
   return `${getProjectHomeUrl(accountId)}/project/${projectName}`;
 };
 
+const getProjectActivityUrl = (projectName, accountId) => {
+  if (!projectName) return;
+  return `${getProjectDetailUrl(projectName, accountId)}/activity`;
+};
+
 const getProjectBuildDetailUrl = (projectName, buildId, accountId) => {
   if (!projectName || !buildId || !accountId) return;
-  return `${getProjectDetailUrl(projectName, accountId)}/build/${buildId}`;
+  return `${getProjectActivityUrl(projectName, accountId)}/build/${buildId}`;
 };
 
 const getProjectDeployDetailUrl = (projectName, deployId, accountId) => {
   if (!projectName || !deployId || !accountId) return;
-  return `${getProjectDetailUrl(
-    projectName,
-    accountId
-  )}/activity/deploy/${deployId}`;
+  return `${getProjectActivityUrl(projectName, accountId)}/deploy/${deployId}`;
 };
 
 const uploadProjectFiles = async (
@@ -405,7 +409,7 @@ const pollProjectBuildAndDeploy = async (
   buildId,
   silenceLogs = false
 ) => {
-  const buildStatus = await pollBuildStatus(
+  let buildStatus = await pollBuildStatus(
     accountId,
     projectConfig.name,
     buildId,
@@ -413,16 +417,6 @@ const pollProjectBuildAndDeploy = async (
     silenceLogs
   );
 
-  const {
-    autoDeployId,
-    isAutoDeployEnabled,
-    deployStatusTaskLocator,
-  } = buildStatus;
-
-  // autoDeployId of 0 indicates a skipped deploy
-  const isDeploying =
-    isAutoDeployEnabled && autoDeployId > 0 && deployStatusTaskLocator;
-
   if (!silenceLogs) {
     uiLine();
   }
@@ -437,7 +431,7 @@ const pollProjectBuildAndDeploy = async (
   if (buildStatus.status === 'FAILURE') {
     result.succeeded = false;
     return result;
-  } else if (isDeploying) {
+  } else if (buildStatus.isAutoDeployEnabled) {
     if (!silenceLogs) {
       logger.log(
         i18n(
@@ -452,17 +446,45 @@ const pollProjectBuildAndDeploy = async (
       displayWarnLogs(accountId, projectConfig.name, buildId);
     }
 
-    const deployStatus = await pollDeployStatus(
-      accountId,
-      projectConfig.name,
-      deployStatusTaskLocator.id,
-      buildId,
-      silenceLogs
-    );
-    result.deployResult = deployStatus;
+    // autoDeployId of 0 indicates a skipped deploy
+    const getIsDeploying = () =>
+      buildStatus.autoDeployId > 0 && buildStatus.deployStatusTaskLocator;
+
+    // Sometimes the deploys do not immediately initiate, give them a chance to kick off
+    if (!getIsDeploying()) {
+      buildStatus = await pollBuildAutodeployStatus(
+        accountId,
+        projectConfig.name,
+        buildId
+      );
+    }
+
+    if (getIsDeploying()) {
+      const deployStatus = await pollDeployStatus(
+        accountId,
+        projectConfig.name,
+        buildStatus.deployStatusTaskLocator.id,
+        buildId,
+        silenceLogs
+      );
+      result.deployResult = deployStatus;
 
-    if (deployStatus.status === 'FAILURE') {
-      result.succeeded = false;
+      if (deployStatus.status === 'FAILURE') {
+        result.succeeded = false;
+      }
+    } else if (!silenceLogs) {
+      logger.log(
+        i18n(
+          `${i18nKey}.pollProjectBuildAndDeploy.unableToFindAutodeployStatus`,
+          {
+            buildId,
+            viewDeploysLink: uiLink(
+              i18n(`${i18nKey}.pollProjectBuildAndDeploy.viewDeploys`),
+              getProjectActivityUrl(projectConfig.name, accountId)
+            ),
+          }
+        )
+      );
     }
   }
 
@@ -588,17 +610,6 @@ const makePollTaskStatusFunc = ({
   statusStrings,
   linkToHubSpot,
 }) => {
-  const isTaskComplete = task => {
-    if (
-      !task[statusText.SUBTASK_KEY].length ||
-      task.status === statusText.STATES.FAILURE
-    ) {
-      return true;
-    } else if (task.status === statusText.STATES.SUCCESS) {
-      return task.isAutoDeployEnabled ? !!task.deployStatusTaskLocator : true;
-    }
-  };
-
   return async (
     accountId,
     taskName,
@@ -635,9 +646,9 @@ const makePollTaskStatusFunc = ({
 
     const tasksById = initialTaskStatus[statusText.SUBTASK_KEY].reduce(
       (acc, task) => {
-        const type = task[statusText.TYPE_KEY];
-        if (type !== 'APP_ID' && type !== 'SERVERLESS_PKG') {
-          acc[task.id] = task;
+        const { id, visible } = task;
+        if (visible) {
+          acc[id] = task;
         }
         return acc;
       },
@@ -677,7 +688,7 @@ const makePollTaskStatusFunc = ({
         const formattedTaskType = PROJECT_TASK_TYPES[taskType]
           ? `[${PROJECT_TASK_TYPES[taskType]}]`
           : '';
-        const text = `${statusText.STATUS_TEXT} ${chalk.bold(
+        const text = `${indent <= 2 ? statusText.STATUS_TEXT : ''} ${chalk.bold(
           taskName
         )} ${formattedTaskType} ...${newline ? '\n' : ''}`;
 
@@ -703,13 +714,7 @@ const makePollTaskStatusFunc = ({
         try {
           taskStatus = await statusFn(accountId, taskName, taskId);
         } catch (e) {
-          logApiErrorInstance(
-            e,
-            new ApiErrorContext({
-              accountId,
-              projectName: taskName,
-            })
-          );
+          logger.debug(e);
           return reject(
             new Error(
               i18n(
@@ -785,61 +790,64 @@ const makePollTaskStatusFunc = ({
             }
           });
 
-          if (isTaskComplete(taskStatus)) {
-            if (status === statusText.STATES.SUCCESS) {
-              SpinniesManager.succeed(overallTaskSpinniesKey, {
-                text: statusStrings.SUCCESS(taskName, displayId),
-              });
-            } else if (status === statusText.STATES.FAILURE) {
-              SpinniesManager.fail(overallTaskSpinniesKey, {
-                text: statusStrings.FAIL(taskName, displayId),
-              });
-
-              if (!silenceLogs) {
-                const failedSubtasks = subTaskStatus.filter(
-                  subtask => subtask.status === 'FAILURE'
-                );
-
-                uiLine();
+          if (status === statusText.STATES.SUCCESS) {
+            SpinniesManager.succeed(overallTaskSpinniesKey, {
+              text: statusStrings.SUCCESS(taskName, displayId),
+            });
+            clearInterval(pollInterval);
+            resolve(taskStatus);
+          } else if (status === statusText.STATES.FAILURE) {
+            SpinniesManager.fail(overallTaskSpinniesKey, {
+              text: statusStrings.FAIL(taskName, displayId),
+            });
+
+            if (!silenceLogs) {
+              const failedSubtasks = subTaskStatus.filter(
+                subtask => subtask.status === 'FAILURE'
+              );
+
+              uiLine();
+              logger.log(
+                `${statusStrings.SUBTASK_FAIL(
+                  displayId,
+                  failedSubtasks.length === 1
+                    ? failedSubtasks[0][statusText.SUBTASK_NAME_KEY]
+                    : failedSubtasks.length + ' components'
+                )}\n`
+              );
+              logger.log('See below for a summary of errors.');
+              uiLine();
+
+              const displayErrors = failedSubtasks.filter(
+                subtask =>
+                  subtask.standardError.subCategory !==
+                    PROJECT_ERROR_TYPES.SUBBUILD_FAILED &&
+                  subtask.standardError.subCategory !==
+                    PROJECT_ERROR_TYPES.SUBDEPLOY_FAILED
+              );
+
+              displayErrors.forEach(subTask => {
                 logger.log(
-                  `${statusStrings.SUBTASK_FAIL(
-                    displayId,
-                    failedSubtasks.length === 1
-                      ? failedSubtasks[0][statusText.SUBTASK_NAME_KEY]
-                      : failedSubtasks.length + ' components'
-                  )}\n`
-                );
-                logger.log('See below for a summary of errors.');
-                uiLine();
-
-                const displayErrors = failedSubtasks.filter(
-                  subtask =>
-                    subtask.standardError.subCategory !==
-                      PROJECT_ERROR_TYPES.SUBBUILD_FAILED &&
-                    subtask.standardError.subCategory !==
-                      PROJECT_ERROR_TYPES.SUBDEPLOY_FAILED
+                  `\n--- ${chalk.bold(
+                    subTask[statusText.SUBTASK_NAME_KEY]
+                  )} failed with the following error ---`
                 );
-
-                displayErrors.forEach(subTask => {
-                  logger.log(
-                    `\n--- ${chalk.bold(
-                      subTask[statusText.SUBTASK_NAME_KEY]
-                    )} failed with the following error ---`
-                  );
-                  logger.error(subTask.errorMessage);
-
-                  // Log nested errors
-                  if (subTask.standardError && subTask.standardError.errors) {
-                    logger.log();
-                    subTask.standardError.errors.forEach(error => {
-                      logger.log(error.message);
-                    });
-                  }
-                });
-              }
+                logger.error(subTask.errorMessage);
+
+                // Log nested errors
+                if (subTask.standardError && subTask.standardError.errors) {
+                  logger.log();
+                  subTask.standardError.errors.forEach(error => {
+                    logger.log(error.message);
+                  });
+                }
+              });
             }
             clearInterval(pollInterval);
             resolve(taskStatus);
+          } else if (!subTaskStatus.length) {
+            clearInterval(pollInterval);
+            resolve(taskStatus);
           }
         }
       }, POLLING_DELAY);
@@ -847,6 +855,41 @@ const makePollTaskStatusFunc = ({
   };
 };
 
+const pollBuildAutodeployStatus = (accountId, taskName, buildId) => {
+  return new Promise((resolve, reject) => {
+    let maxIntervals = (30 * 1000) / POLLING_DELAY; // Num of intervals in ~30s
+
+    const pollInterval = setInterval(async () => {
+      let taskStatus;
+      try {
+        taskStatus = await getBuildStatus(accountId, taskName, buildId);
+      } catch (e) {
+        logger.debug(e);
+        return reject(
+          new Error(
+            i18n(`${i18nKey}.pollBuildAutodeployStatusError`, { buildId })
+          )
+        );
+      }
+
+      if (!taskStatus || !taskStatus.status) {
+        return reject(
+          new Error(
+            i18n(`${i18nKey}.pollBuildAutodeployStatusError`, { buildId })
+          )
+        );
+      }
+
+      if (taskStatus.deployStatusTaskLocator || maxIntervals <= 0) {
+        clearInterval(pollInterval);
+        resolve(taskStatus);
+      } else {
+        maxIntervals -= 1;
+      }
+    }, POLLING_DELAY);
+  });
+};
+
 const pollBuildStatus = makePollTaskStatusFunc({
   linkToHubSpot: (accountId, taskName, taskId) =>
     uiLink(

package/lib/prompts/accountNamePrompt.js

@@ -0,0 +1,78 @@
+const { accountNameExistsInConfig } = require('@hubspot/local-dev-lib/config');
+const { STRING_WITH_NO_SPACES_REGEX } = require('../regex');
+const { promptUser } = require('./promptUtils');
+const { i18n } = require('../lang');
+const {
+  HUBSPOT_ACCOUNT_TYPES,
+} = require('@hubspot/local-dev-lib/constants/config');
+
+const i18nKey = 'lib.prompts.accountNamePrompt';
+
+const getCliAccountNamePromptConfig = defaultName => ({
+  name: 'name',
+  message: i18n(`${i18nKey}.enterAccountName`),
+  default: defaultName,
+  validate(val) {
+    if (typeof val !== 'string') {
+      return i18n(`${i18nKey}.errors.invalidName`);
+    } else if (!val.length) {
+      return i18n(`${i18nKey}.errors.nameRequired`);
+    } else if (!STRING_WITH_NO_SPACES_REGEX.test(val)) {
+      return i18n(`${i18nKey}.errors.spacesInName`);
+    }
+    return accountNameExistsInConfig(val)
+      ? i18n(`${i18nKey}.errors.accountNameExists`, { name: val })
+      : true;
+  },
+});
+
+const cliAccountNamePrompt = defaultName => {
+  return promptUser(getCliAccountNamePromptConfig(defaultName));
+};
+
+const hubspotAccountNamePrompt = ({ accountType, currentPortalCount = 0 }) => {
+  const isDevelopmentSandbox =
+    accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX;
+  const isSandbox =
+    accountType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX ||
+    isDevelopmentSandbox;
+  const isDeveloperTestAccount =
+    accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST;
+
+  let promptMessageString;
+  let defaultName;
+  if (isSandbox) {
+    promptMessageString = isDevelopmentSandbox
+      ? i18n(`${i18nKey}.enterDevelopmentSandboxName`)
+      : i18n(`${i18nKey}.enterStandardSandboxName`);
+  } else if (isDeveloperTestAccount) {
+    promptMessageString = i18n(`${i18nKey}.enterDeveloperTestAccountName`);
+    defaultName = i18n(`${i18nKey}.developerTestAccountDefaultName`, {
+      count: currentPortalCount + 1,
+    });
+  }
+
+  return promptUser([
+    {
+      name: 'name',
+      message: promptMessageString,
+      validate(val) {
+        if (typeof val !== 'string') {
+          return i18n(`${i18nKey}.errors.invalidName`);
+        } else if (!val.trim().length) {
+          return i18n(`${i18nKey}.errors.nameRequired`);
+        }
+        return accountNameExistsInConfig(val)
+          ? i18n(`${i18nKey}.errors.accountNameExists`, { name: val })
+          : true;
+      },
+      default: defaultName,
+    },
+  ]);
+};
+
+module.exports = {
+  getCliAccountNamePromptConfig,
+  cliAccountNamePrompt,
+  hubspotAccountNamePrompt,
+};

package/lib/prompts/activeInstallConfirmationPrompt.js

@@ -0,0 +1,20 @@
+const { promptUser } = require('./promptUtils');
+const { i18n } = require('../lang');
+
+const i18nKey = 'lib.prompts.activeInstallConfirmationPrompt';
+
+const activeInstallConfirmationPrompt = async () => {
+  const { proceed } = await promptUser([
+    {
+      name: 'proceed',
+      message: i18n(`${i18nKey}.message`),
+      type: 'confirm',
+      default: false,
+    },
+  ]);
+  return proceed;
+};
+
+module.exports = {
+  activeInstallConfirmationPrompt,
+};

package/lib/prompts/createProjectPrompt.js

@@ -1,6 +1,10 @@
 const fs = require('fs');
 const path = require('path');
-const { getCwd } = require('@hubspot/local-dev-lib/path');
+const {
+  getCwd,
+  sanitizeFileName,
+  isValidPath,
+} = require('@hubspot/local-dev-lib/path');
 const { PROJECT_COMPONENT_TYPES } = require('../../lib/constants');
 const { promptUser } = require('./promptUtils');
 const { fetchFileFromRepository } = require('@hubspot/local-dev-lib/github');
@@ -79,7 +83,10 @@ const createProjectPrompt = async (
       message: i18n(`${i18nKey}.enterLocation`),
       when: !promptOptions.location,
       default: answers => {
-        return path.resolve(getCwd(), answers.name || promptOptions.name);
+        const projectName = sanitizeFileName(
+          answers.name || promptOptions.name
+        );
+        return path.resolve(getCwd(), projectName);
       },
       validate: input => {
         if (!input) {
@@ -88,6 +95,9 @@ const createProjectPrompt = async (
         if (fs.existsSync(input)) {
           return i18n(`${i18nKey}.errors.invalidLocation`);
         }
+        if (!isValidPath(input)) {
+          return i18n(`${i18nKey}.errors.invalidCharacters`);
+        }
         return true;
       },
     },