@hubspot/cli 5.2.1-beta.1 → 5.2.1-beta.11

package/lib/constants.js

@@ -22,6 +22,13 @@ const CONFIG_FLAGS = {
 
 const POLLING_DELAY = 2000;
 
+const POLLING_STATUS = {
+  SUCCESS: 'SUCCESS',
+  ERROR: 'ERROR',
+  REVERTED: 'REVERTED',
+  FAILURE: 'FAILURE',
+};
+
 const PROJECT_CONFIG_FILE = 'hsproject.json';
 const PROJECT_BUILD_STATES = {
   BUILDING: 'BUILDING',
@@ -54,11 +61,14 @@ const PROJECT_ERROR_TYPES = {
   PROJECT_LOCKED: 'BuildPipelineErrorType.PROJECT_LOCKED',
   MISSING_PROJECT_PROVISION: 'BuildPipelineErrorType.MISSING_PROJECT_PROVISION',
   BUILD_NOT_IN_PROGRESS: 'BuildPipelineErrorType.BUILD_NOT_IN_PROGRESS',
+  SUBBUILD_FAILED: 'BuildPipelineErrorType.DEPENDENT_SUBBUILD_FAILED',
+  SUBDEPLOY_FAILED: 'DeployPipelineErrorType.DEPENDENT_SUBDEPLOY_FAILED',
 };
 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',
@@ -82,6 +92,7 @@ module.exports = {
   MARKETPLACE_FOLDER,
   CONFIG_FLAGS,
   POLLING_DELAY,
+  POLLING_STATUS,
   PROJECT_CONFIG_FILE,
   PROJECT_BUILD_TEXT,
   PROJECT_DEPLOY_TEXT,

package/lib/developerTestAccounts.js

@@ -6,6 +6,14 @@ const { i18n } = require('./lang');
 const {
   fetchDeveloperTestAccounts,
 } = require('@hubspot/local-dev-lib/developerTestAccounts');
+const {
+  isMissingScopeError,
+  isSpecifiedError,
+} = require('@hubspot/local-dev-lib/errors/apiErrors');
+const { logger } = require('@hubspot/local-dev-lib/logger');
+const { uiAccountDescription } = require('./ui');
+const { getHubSpotWebsiteOrigin } = require('@hubspot/local-dev-lib/urls');
+const { logErrorInstance } = require('./errorHandlers/standardErrors');
 
 const getHasDevTestAccounts = appDeveloperAccountConfig => {
   const config = getConfig();
@@ -22,8 +30,6 @@ const getHasDevTestAccounts = appDeveloperAccountConfig => {
   return false;
 };
 
-const i18nKey = 'cli.lib.developerTestAccount';
-
 const validateDevTestAccountUsageLimits = async accountConfig => {
   const accountId = getAccountId(accountConfig.portalId);
   const response = await fetchDeveloperTestAccounts(accountId);
@@ -34,14 +40,14 @@ const validateDevTestAccountUsageLimits = async accountConfig => {
       const hasDevTestAccounts = getHasDevTestAccounts(accountConfig);
       if (hasDevTestAccounts) {
         throw new Error(
-          i18n(`${i18nKey}.create.failure.alreadyInConfig`, {
+          i18n('lib.developerTestAccount.create.failure.alreadyInConfig', {
             accountName: accountConfig.name || accountId,
             limit,
           })
         );
       } else {
         throw new Error(
-          i18n(`${i18nKey}.create.failure.limit`, {
+          i18n('lib.developerTestAccount.create.failure.limit', {
             accountName: accountConfig.name || accountId,
             limit,
           })
@@ -52,6 +58,48 @@ const validateDevTestAccountUsageLimits = async accountConfig => {
   }
   return null;
 };
+
+function handleDeveloperTestAccountCreateError({
+  err,
+  accountId,
+  env,
+  portalLimit,
+}) {
+  if (isMissingScopeError(err)) {
+    logger.error(
+      i18n('lib.developerTestAccount.create.failure.scopes.message', {
+        accountName: uiAccountDescription(accountId),
+      })
+    );
+    const websiteOrigin = getHubSpotWebsiteOrigin(env);
+    const url = `${websiteOrigin}/personal-access-key/${accountId}`;
+    logger.info(
+      i18n('lib.developerTestAccount.create.failure.scopes.instructions', {
+        accountName: uiAccountDescription(accountId),
+        url,
+      })
+    );
+  } else if (
+    isSpecifiedError(err, {
+      statusCode: 400,
+      errorType: 'TEST_PORTAL_LIMIT_REACHED',
+    })
+  ) {
+    logger.log('');
+    logger.error(
+      i18n('lib.developerTestAccount.create.failure.limit', {
+        accountName: uiAccountDescription(accountId),
+        limit: portalLimit,
+      })
+    );
+    logger.log('');
+  } else {
+    logErrorInstance(err);
+  }
+  throw err;
+}
+
 module.exports = {
   validateDevTestAccountUsageLimits,
+  handleDeveloperTestAccountCreateError,
 };

package/lib/errorHandlers/apiErrors.js

@@ -19,7 +19,7 @@ const {
 const { overrideErrors } = require('./overrideErrors');
 const { i18n } = require('../lang');
 
-const i18nKey = 'cli.lib.errorHandlers.apiErrors';
+const i18nKey = 'lib.errorHandlers.apiErrors';
 
 class ApiErrorContext extends ErrorContext {
   constructor(props = {}) {

package/lib/errorHandlers/overrideErrors.js

@@ -5,7 +5,7 @@ const { PLATFORM_VERSION_ERROR_TYPES } = require('../constants');
 const { i18n } = require('../lang');
 const { uiLine, uiLink } = require('../ui');
 
-const i18nKey = 'cli.lib.errorHandlers.overrideErrors';
+const i18nKey = 'lib.errorHandlers.overrideErrors';
 
 function createPlatformVersionError(subCategory, errData) {
   const docsLink = uiLink(

package/lib/errorHandlers/standardErrors.js

@@ -5,7 +5,7 @@ const {
 } = require('@hubspot/local-dev-lib/errors/standardErrors');
 const { i18n } = require('../lang');
 
-const i18nKey = 'cli.lib.errorHandlers.standardErrors';
+const i18nKey = 'lib.errorHandlers.standardErrors';
 
 // TODO: Make these TS interfaces
 class ErrorContext {

package/lib/generate-selectors.js

@@ -8,7 +8,7 @@ const CSS_PSEUDO_CLASS_REGEX = new RegExp(
   /:active|:checked|:disabled|:empty|:enabled|:first-of-type|:focus|:hover|:in-range|:invalid|:link|:optional|:out-of-range|:read-only|:read-write|:required|:target|:valid|:visited/,
   'g'
 );
-const i18nKey = 'cli.commands.theme.subcommands.generateSelectors';
+const i18nKey = 'commands.theme.subcommands.generateSelectors';
 
 let maxFieldsDepth = 0;
 

package/lib/localDev.js

@@ -8,30 +8,26 @@ 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,
-  getSandboxTypeAsString,
   getAvailableSyncTypes,
 } = require('./sandboxes');
-const { buildSandbox } = require('./sandboxCreate');
 const { syncSandbox } = require('./sandboxSync');
 const {
   validateDevTestAccountUsageLimits,
 } = require('./developerTestAccounts');
-const { buildDeveloperTestAccount } = require('./developerTestAccountCreate');
 const { logErrorInstance } = require('./errorHandlers/standardErrors');
 const { uiCommandReference, uiLine, uiAccountDescription } = require('./ui');
 const SpinniesManager = require('./ui/SpinniesManager');
@@ -55,8 +51,13 @@ const {
   logApiErrorInstance,
   ApiErrorContext,
 } = require('./errorHandlers/apiErrors');
+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 = 'cli.lib.localDev';
+const i18nKey = 'lib.localDev';
 
 // If the user passed in the --account flag, confirm they want to use that account as
 // their target account, otherwise exit
@@ -64,9 +65,7 @@ const confirmDefaultAccountIsTarget = async accountConfig => {
   logger.log();
   const useDefaultAccount = await confirmDefaultAccountPrompt(
     accountConfig.name,
-    isDeveloperTestAccount(accountConfig)
-      ? HUBSPOT_ACCOUNT_TYPE_STRINGS[HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST]
-      : `${getSandboxTypeAsString(accountConfig.accountType)} sandbox`
+    HUBSPOT_ACCOUNT_TYPE_STRINGS[accountConfig.accountType]
   );
 
   if (!useDefaultAccount) {
@@ -86,11 +85,15 @@ const confirmDefaultAccountIsTarget = async accountConfig => {
 // Confirm the default account is a developer account if developing public apps
 const checkIfAppDeveloperAccount = accountConfig => {
   if (!isAppDeveloperAccount(accountConfig)) {
-    logger.error(
-      i18n(
-        `${i18nKey}.checkCorrectParentAccountType.standardAccountNotSupported`
-      )
-    );
+    logger.error(i18n(`${i18nKey}.checkIfAppDevloperAccount`));
+    process.exit(EXIT_CODES.SUCCESS);
+  }
+};
+
+// Confirm the default account is a developer account if developing public apps
+const checkIfDeveloperTestAccount = accountConfig => {
+  if (!isDeveloperTestAccount(accountConfig)) {
+    logger.error(i18n(`${i18nKey}.checkIfDeveloperTestAccount`));
     process.exit(EXIT_CODES.SUCCESS);
   }
 };
@@ -104,19 +107,20 @@ const suggestRecommendedNestedAccount = async (
   logger.log();
   uiLine();
   if (hasPublicApps) {
-    logger.warn(
+    logger.log(
       i18n(
         `${i18nKey}.suggestRecommendedNestedAccount.publicAppNonDeveloperTestAccountWarning`
       )
     );
   } else if (isAppDeveloperAccount(accountConfig)) {
-    logger.warn(
+    logger.error(
       i18n(
-        `${i18nKey}.suggestRecommendedNestedAccount.publicAppNonDeveloperTestAccountWarning`
+        `${i18nKey}.suggestRecommendedNestedAccount.privateAppInAppDeveloperAccountError`
       )
     );
+    process.exit(EXIT_CODES.ERROR);
   } else {
-    logger.warn(
+    logger.log(
       i18n(`${i18nKey}.suggestRecommendedNestedAccount.nonSandboxWarning`)
     );
   }
@@ -141,14 +145,14 @@ const createSandboxForLocalDev = async (accountId, accountConfig, env) => {
   } catch (err) {
     if (isMissingScopeError(err)) {
       logger.error(
-        i18n('cli.lib.sandbox.create.failure.scopes.message', {
+        i18n('lib.sandbox.create.failure.scopes.message', {
           accountName: accountConfig.name || accountId,
         })
       );
       const websiteOrigin = getHubSpotWebsiteOrigin(env);
       const url = `${websiteOrigin}/personal-access-key/${accountId}`;
       logger.info(
-        i18n('cli.lib.sandbox.create.failure.scopes.instructions', {
+        i18n('lib.sandbox.create.failure.scopes.instructions', {
           accountName: accountConfig.name || accountId,
           url,
         })
@@ -159,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',
@@ -169,9 +173,9 @@ const createSandboxForLocalDev = async (accountId, accountConfig, env) => {
       accountId
     );
 
-    const { result } = await buildSandbox({
+    const { result } = await buildNewAccount({
       name,
-      type: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+      accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
       accountConfig,
       env,
     });
@@ -219,20 +223,17 @@ const createDeveloperTestAccountForLocalDev = async (
   } catch (err) {
     if (isMissingScopeError(err)) {
       logger.error(
-        i18n('cli.lib.developerTestAccount.create.failure.scopes.message', {
+        i18n('lib.developerTestAccount.create.failure.scopes.message', {
           accountName: accountConfig.name || accountId,
         })
       );
       const websiteOrigin = getHubSpotWebsiteOrigin(env);
       const url = `${websiteOrigin}/personal-access-key/${accountId}`;
       logger.info(
-        i18n(
-          'cli.lib.developerTestAccount.create.failure.scopes.instructions',
-          {
-            accountName: accountConfig.name || accountId,
-            url,
-          }
-        )
+        i18n('lib.developerTestAccount.create.failure.scopes.instructions', {
+          accountName: accountConfig.name || accountId,
+          url,
+        })
       );
     } else {
       logErrorInstance(err);
@@ -241,18 +242,22 @@ 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' },
       accountId
     );
 
-    const { result } = await buildDeveloperTestAccount({
+    const { result } = await buildNewAccount({
       name,
+      accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
       accountConfig,
       env,
-      maxTestPortals,
+      portalLimit: maxTestPortals,
     });
 
     return result.id;
@@ -262,27 +267,61 @@ const createDeveloperTestAccountForLocalDev = async (
   }
 };
 
+// Prompt user to confirm usage of an existing developer test account that is not currently in the config
+const useExistingDevTestAccount = async (env, account) => {
+  const useExistingDevTestAcct = await confirmUseExistingDeveloperTestAccountPrompt(
+    account
+  );
+  if (!useExistingDevTestAcct) {
+    logger.log('');
+    logger.log(
+      i18n(
+        `${i18nKey}.confirmDefaultAccountIsTarget.declineDefaultAccountExplanation`,
+        {
+          useCommand: uiCommandReference('hs accounts use'),
+          devCommand: uiCommandReference('hs project dev'),
+        }
+      )
+    );
+    logger.log('');
+    process.exit(EXIT_CODES.SUCCESS);
+  }
+  const devTestAcctConfigName = await saveAccountToConfig({
+    env,
+    accountName: account.accountName,
+    accountId: account.id,
+  });
+  logger.success(
+    i18n(`lib.developerTestAccount.create.success.configFileUpdated`, {
+      accountName: devTestAcctConfigName,
+      authType: PERSONAL_ACCESS_KEY_AUTH_METHOD.name,
+    })
+  );
+};
+
 // Prompt the user to create a new project if one doesn't exist on their target account
 const createNewProjectForLocalDev = async (
   projectConfig,
   targetAccountId,
-  shouldCreateWithoutConfirmation
+  shouldCreateWithoutConfirmation,
+  hasPublicApps
 ) => {
   // Create the project without prompting if this is a newly created sandbox
   let shouldCreateProject = shouldCreateWithoutConfirmation;
 
   if (!shouldCreateProject) {
+    const explanationString = i18n(
+      hasPublicApps
+        ? `${i18nKey}.createNewProjectForLocalDev.publicAppProjectMustExistExplanation`
+        : `${i18nKey}.createNewProjectForLocalDev.projectMustExistExplanation`,
+      {
+        accountIdentifier: uiAccountDescription(targetAccountId),
+        projectName: projectConfig.name,
+      }
+    );
     logger.log();
     uiLine();
-    logger.warn(
-      i18n(
-        `${i18nKey}.createNewProjectForLocalDev.projectMustExistExplanation`,
-        {
-          accountIdentifier: uiAccountDescription(targetAccountId),
-          projectName: projectConfig.name,
-        }
-      )
-    );
+    logger.log(explanationString);
     uiLine();
 
     shouldCreateProject = await confirmPrompt(
@@ -302,7 +341,7 @@ const createNewProjectForLocalDev = async (
     });
 
     try {
-      await createProject(targetAccountId, projectConfig.name);
+      const project = await createProject(targetAccountId, projectConfig.name);
       SpinniesManager.succeed('createProject', {
         text: i18n(`${i18nKey}.createNewProjectForLocalDev.createdProject`, {
           accountIdentifier: uiAccountDescription(targetAccountId),
@@ -310,6 +349,7 @@ const createNewProjectForLocalDev = async (
         }),
         succeedColor: 'white',
       });
+      return project;
     } catch (err) {
       SpinniesManager.fail('createProject');
       logger.log(
@@ -380,7 +420,7 @@ const createInitialBuildForNewProject = async (
 
     logger.log();
     failedSubTasks.forEach(failedSubTask => {
-      console.error(failedSubTask.errorMessage);
+      logger.error(failedSubTask.errorMessage);
     });
     logger.log();
 
@@ -390,12 +430,22 @@ 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,
+  checkIfDeveloperTestAccount,
   suggestRecommendedNestedAccount,
   createSandboxForLocalDev,
   createDeveloperTestAccountForLocalDev,
+  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

@@ -0,0 +1,31 @@
+const { POLLING_DELAY, POLLING_STATUS } = require('./constants');
+
+const poll = (callback, accountId, taskId) => {
+  return new Promise((resolve, reject) => {
+    const pollInterval = setInterval(async () => {
+      try {
+        const pollResp = await callback(accountId, taskId);
+        const { status } = pollResp;
+
+        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);
+        reject(error);
+      }
+    }, POLLING_DELAY);
+  });
+};
+
+module.exports = {
+  poll,
+};

package/lib/process.js

@@ -6,7 +6,7 @@ const {
 } = require('@hubspot/local-dev-lib/logger');
 const { i18n } = require('./lang');
 
-const i18nKey = 'cli.lib.process';
+const i18nKey = 'lib.process';
 
 const handleExit = callback => {
   const terminationSignals = [

package/lib/projectStructure.js

@@ -7,11 +7,13 @@ const { logErrorInstance } = require('./errorHandlers/standardErrors');
 const COMPONENT_TYPES = Object.freeze({
   privateApp: 'private-app',
   publicApp: 'public-app',
+  hublTheme: 'hubl-theme',
 });
 
 const CONFIG_FILES = {
   [COMPONENT_TYPES.privateApp]: 'app.json',
   [COMPONENT_TYPES.publicApp]: 'public-app.json',
+  [COMPONENT_TYPES.hublTheme]: 'theme.json',
 };
 
 function getTypeFromConfigFile(configFile) {
@@ -102,13 +104,14 @@ async function findProjectComponents(projectSourceDir) {
     if (Object.values(CONFIG_FILES).includes(base)) {
       const parsedAppConfig = loadConfigFile(projectFile);
 
-      if (parsedAppConfig && parsedAppConfig.name) {
+      if (parsedAppConfig) {
         const isLegacy = getIsLegacyApp(parsedAppConfig, dir);
+        const isHublTheme = base === CONFIG_FILES[COMPONENT_TYPES.hublTheme];
 
         components.push({
           type: getTypeFromConfigFile(base),
           config: parsedAppConfig,
-          runnable: !isLegacy,
+          runnable: !isLegacy && !isHublTheme,
           path: dir,
         });
       }