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

package/lib/prompts/accountsPrompt.js

@@ -1,14 +1,12 @@
 const { updateDefaultAccount } = require('@hubspot/cli-lib/lib/config');
 const { promptUser } = require('./promptUtils');
 const { i18n } = require('@hubspot/cli-lib/lib/lang');
-const { getSandboxType } = require('../sandboxes');
+const { getAccountName } = require('../sandboxes');
 
 const mapAccountChoices = portals =>
   portals.map(p => {
-    const isSandbox = p.sandboxAccountType && p.sandboxAccountType !== null;
-    const sandboxName = `[${getSandboxType(p.sandboxAccountType)} sandbox] `;
     return {
-      name: `${p.name} ${isSandbox ? sandboxName : ''}(${p.portalId})`,
+      name: getAccountName(p),
       value: p.name || p.portalId,
     };
   });

package/lib/prompts/buildIdPrompt.js

@@ -0,0 +1,35 @@
+const { promptUser } = require('./promptUtils');
+const { i18n } = require('@hubspot/cli-lib/lib/lang');
+
+const i18nKey = 'cli.lib.prompts.buildIdPrompt';
+
+const buildIdPrompt = (latestBuildId, deployedBuildId, projectName) => {
+  return promptUser({
+    name: 'buildId',
+    message: i18n(`${i18nKey}.enterBuildId`),
+    default: () => {
+      if (latestBuildId === deployedBuildId) {
+        return;
+      }
+      return latestBuildId;
+    },
+    validate: val => {
+      if (Number(val) > latestBuildId) {
+        return i18n(`${i18nKey}.errors.buildIdDoesNotExist`, {
+          buildId: val,
+          projectName,
+        });
+      }
+      if (Number(val) === deployedBuildId) {
+        return i18n(`${i18nKey}.errors.buildAlreadyDeployed`, {
+          buildId: val,
+        });
+      }
+      return true;
+    },
+  });
+};
+
+module.exports = {
+  buildIdPrompt,
+};

package/lib/prompts/createProjectPrompt.js

@@ -1,12 +1,49 @@
 const path = require('path');
 const { getCwd } = require('@hubspot/cli-lib/path');
-const { PROJECT_TEMPLATES } = require('@hubspot/cli-lib/lib/constants');
+const {
+  PROJECT_COMPONENT_TYPES,
+  PROJECT_PROPERTIES,
+} = require('@hubspot/cli-lib/lib/constants');
 const { promptUser } = require('./promptUtils');
+const { fetchJsonFromRepository } = require('@hubspot/cli-lib/github');
 const { i18n } = require('@hubspot/cli-lib/lib/lang');
+const { logger } = require('@hubspot/cli-lib/logger');
+const { EXIT_CODES } = require('../../lib/enums/exitCodes');
 
 const i18nKey = 'cli.lib.prompts.createProjectPrompt';
 
-const createProjectPrompt = (promptOptions = {}) => {
+const hasAllProperties = projectList => {
+  return projectList.every(config =>
+    PROJECT_PROPERTIES.every(p =>
+      Object.prototype.hasOwnProperty.call(config, p)
+    )
+  );
+};
+
+const createTemplateOptions = async repoPath => {
+  const isRepoPath = !!repoPath;
+  const config = await fetchJsonFromRepository(
+    repoPath,
+    'main/config.json',
+    isRepoPath
+  );
+
+  if (!config || !config[PROJECT_COMPONENT_TYPES.PROJECTS]) {
+    logger.error(i18n(`${i18nKey}.errors.noProjectsInConfig`));
+    process.exit(EXIT_CODES.ERROR);
+  }
+
+  if (!hasAllProperties(config[PROJECT_COMPONENT_TYPES.PROJECTS])) {
+    logger.error(i18n(`${i18nKey}.errors.missingPropertiesInConfig`));
+    process.exit(EXIT_CODES.ERROR);
+  }
+
+  return config[PROJECT_COMPONENT_TYPES.PROJECTS];
+};
+
+const createProjectPrompt = async (promptOptions = {}) => {
+  const projectTemplates = await createTemplateOptions(promptOptions.repoPath);
+
   return promptUser([
     {
       name: 'name',
@@ -37,7 +74,7 @@ const createProjectPrompt = (promptOptions = {}) => {
       name: 'template',
       message: () => {
         return promptOptions.template &&
-          !PROJECT_TEMPLATES.find(t => t.name === promptOptions.template)
+          !projectTemplates.find(t => t.name === promptOptions.template)
           ? i18n(`${i18nKey}.errors.invalidTemplate`, {
               template: promptOptions.template,
             })
@@ -45,12 +82,12 @@ const createProjectPrompt = (promptOptions = {}) => {
       },
       when:
         !promptOptions.template ||
-        !PROJECT_TEMPLATES.find(t => t.name === promptOptions.template),
+        !projectTemplates.find(t => t.name === promptOptions.template),
       type: 'list',
-      choices: PROJECT_TEMPLATES.map(template => {
+      choices: projectTemplates.map(template => {
         return {
           name: template.label,
-          value: template.name,
+          value: template,
         };
       }),
     },

package/lib/prompts/downloadProjectPrompt.js

@@ -0,0 +1,44 @@
+const { promptUser } = require('./promptUtils');
+const { getAccountId } = require('@hubspot/cli-lib/lib/config');
+const { fetchProjects } = require('@hubspot/cli-lib/api/dfs');
+const { i18n } = require('@hubspot/cli-lib/lib/lang');
+
+const i18nKey = 'cli.lib.prompts.downloadProjectPrompt';
+
+const createProjectsList = async () => {
+  const projects = await fetchProjects(getAccountId());
+  return projects.results;
+};
+
+const downloadProjectPrompt = async (promptOptions = {}) => {
+  const projectsList = await createProjectsList();
+
+  return promptUser([
+    {
+      name: 'project',
+      message: () => {
+        return promptOptions.project &&
+          !projectsList.find(p => p.name === promptOptions.name)
+          ? i18n(`${i18nKey}.errors.projectNotFound`, {
+              projectName: promptOptions.project,
+              accountId: getAccountId(),
+            })
+          : i18n(`${i18nKey}.selectProject`);
+      },
+      when:
+        !promptOptions.project ||
+        !projectsList.find(p => p.name === promptOptions.project),
+      type: 'list',
+      choices: projectsList.map(project => {
+        return {
+          name: project.name,
+          value: project.name,
+        };
+      }),
+    },
+  ]);
+};
+
+module.exports = {
+  downloadProjectPrompt,
+};

package/lib/prompts/projectAddPrompt.js

@@ -0,0 +1,57 @@
+const { promptUser } = require('./promptUtils');
+const { fetchJsonFromRepository } = require('@hubspot/cli-lib/github');
+const { i18n } = require('@hubspot/cli-lib/lib/lang');
+const { PROJECT_COMPONENT_TYPES } = require('@hubspot/cli-lib/lib/constants');
+
+const i18nKey = 'cli.lib.prompts.projectAddPrompt';
+
+const createTypeOptions = async () => {
+  const config = await fetchJsonFromRepository(
+    'HubSpot/hubspot-project-components',
+    'main/config.json'
+  );
+
+  return config[PROJECT_COMPONENT_TYPES.COMPONENTS];
+};
+
+const projectAddPrompt = async (promptOptions = {}) => {
+  const components = await createTypeOptions();
+  return promptUser([
+    {
+      name: 'type',
+      message: () => {
+        return promptOptions.type &&
+          !components.find(t => t.path === promptOptions.type.path)
+          ? i18n(`${i18nKey}.errors.invalidType`, {
+              type: promptOptions.type,
+            })
+          : i18n(`${i18nKey}.selectType`);
+      },
+      when:
+        !promptOptions.type ||
+        !components.find(t => t.path === promptOptions.type.path),
+      type: 'list',
+      choices: components.map(type => {
+        return {
+          name: type.label,
+          value: type,
+        };
+      }),
+    },
+    {
+      name: 'name',
+      message: i18n(`${i18nKey}.enterName`),
+      when: !promptOptions.name,
+      validate: input => {
+        if (!input) {
+          return i18n(`${i18nKey}.errors.nameRequired`);
+        }
+        return true;
+      },
+    },
+  ]);
+};
+
+module.exports = {
+  projectAddPrompt,
+};

package/lib/prompts/projectDevTargetAccountPrompt.js

@@ -0,0 +1,105 @@
+const { promptUser } = require('./promptUtils');
+const { i18n } = require('@hubspot/cli-lib/lib/lang');
+const { uiAccountDescription } = require('../ui');
+const { isSandbox, getAccountName } = require('../sandboxes');
+const { getAccountId } = require('@hubspot/cli-lib');
+const { getSandboxUsageLimits } = require('@hubspot/cli-lib/sandboxes');
+const { logger } = require('@hubspot/cli-lib/logger');
+
+const i18nKey = 'cli.lib.prompts.projectDevTargetAccountPrompt';
+
+const mapSandboxAccount = accountConfig => ({
+  name: getAccountName(accountConfig),
+  value: {
+    targetAccountId: getAccountId(accountConfig.name),
+    chooseNonSandbox: false,
+    createNewSandbox: false,
+  },
+});
+
+const selectTargetAccountPrompt = async (
+  accounts,
+  defaultAccountConfig,
+  nonSandbox = false
+) => {
+  let choices;
+
+  if (nonSandbox) {
+    choices = accounts
+      .filter(accountConfig => !isSandbox(accountConfig))
+      .map(accountConfig => {
+        const accountId = getAccountId(accountConfig.name);
+        return {
+          name: uiAccountDescription(accountId),
+          value: {
+            targetAccountId: accountId,
+            chooseNonSandbox: false,
+            createNewSandbox: false,
+          },
+        };
+      });
+  } else {
+    let sandboxUsage = {};
+    try {
+      const accountId = getAccountId(defaultAccountConfig.portalId);
+      sandboxUsage = await getSandboxUsageLimits(accountId);
+    } catch (err) {
+      logger.debug('Unable to fetch sandbox usage limits: ', err);
+    }
+    const sandboxAccounts = accounts.reverse().filter(isSandbox);
+    let disabledMessage = false;
+    if (isSandbox(defaultAccountConfig)) {
+      disabledMessage = i18n(`${i18nKey}.defaultAccountNotProd`);
+    }
+    if (
+      sandboxUsage['DEVELOPER'] &&
+      sandboxUsage['DEVELOPER'].available === 0
+    ) {
+      disabledMessage = i18n(`${i18nKey}.sandboxLimit`, {
+        limit: sandboxUsage['DEVELOPER'].limit,
+      });
+    }
+    // Order choices by Create new -> Developer Sandbox -> Standard Sandbox -> Non sandbox
+    choices = [
+      {
+        name: i18n(`${i18nKey}.createNewSandboxOption`),
+        value: {
+          targetAccountId: null,
+          chooseNonSandbox: false,
+          createNewSandbox: true,
+        },
+        disabled: disabledMessage,
+      },
+      ...sandboxAccounts
+        .filter(a => a.sandboxAccountType === 'DEVELOPER')
+        .map(mapSandboxAccount),
+      ...sandboxAccounts
+        .filter(a => a.sandboxAccountType === 'STANDARD')
+        .map(mapSandboxAccount),
+      {
+        name: i18n(`${i18nKey}.chooseNonSandboxOption`),
+        value: {
+          targetAccountId: null,
+          chooseNonSandbox: true,
+          createNewSandbox: false,
+        },
+      },
+    ];
+  }
+  const { targetAccountInfo } = await promptUser([
+    {
+      name: 'targetAccountInfo',
+      type: 'list',
+      message: nonSandbox
+        ? i18n(`${i18nKey}.chooseNonSandboxAccount`)
+        : i18n(`${i18nKey}.chooseSandboxAccount`),
+      choices,
+    },
+  ]);
+
+  return targetAccountInfo;
+};
+
+module.exports = {
+  selectTargetAccountPrompt,
+};

package/lib/prompts/promptUtils.js

@@ -5,6 +5,19 @@ const promptUser = async promptConfig => {
   return prompt(promptConfig);
 };
 
+const confirmPrompt = async (message, defaultAnswer = true) => {
+  const { choice } = await promptUser([
+    {
+      name: 'choice',
+      type: 'confirm',
+      default: defaultAnswer,
+      message,
+    },
+  ]);
+  return choice;
+};
+
 module.exports = {
   promptUser,
+  confirmPrompt,
 };

package/lib/prompts/sandboxesPrompt.js

@@ -1,6 +1,11 @@
 const { promptUser } = require('./promptUtils');
 const { i18n } = require('@hubspot/cli-lib/lib/lang');
-const { getSandboxType } = require('../sandboxes');
+const {
+  getSandboxTypeAsString,
+  STANDARD_SANDBOX,
+  DEVELOPER_SANDBOX,
+} = require('../sandboxes');
+const { accountNameExistsInConfig } = require('@hubspot/cli-lib/lib/config');
 
 const i18nKey = 'cli.lib.prompts.sandboxesPrompt';
 
@@ -8,7 +13,9 @@ const mapSandboxAccountChoices = portals =>
   portals
     .filter(p => p.sandboxAccountType && p.sandboxAccountType !== null)
     .map(p => {
-      const sandboxName = `[${getSandboxType(p.sandboxAccountType)} sandbox] `;
+      const sandboxName = `[${getSandboxTypeAsString(
+        p.sandboxAccountType
+      )} sandbox] `;
       return {
         name: `${p.name} ${sandboxName}(${p.portalId})`,
         value: p.name || p.portalId,
@@ -27,18 +34,50 @@ const mapNonSandboxAccountChoices = portals =>
       };
     });
 
-const createSandboxPrompt = () => {
+const sandboxNamePrompt = (type = STANDARD_SANDBOX) => {
+  const isDeveloperSandbox = type === DEVELOPER_SANDBOX;
+  const namePromptMessage = isDeveloperSandbox
+    ? `${i18nKey}.name.developmentSandboxMessage`
+    : `${i18nKey}.name.message`;
   return promptUser([
     {
       name: 'name',
-      message: i18n(`${i18nKey}.enterName`),
+      message: i18n(namePromptMessage),
       validate(val) {
         if (typeof val !== 'string') {
-          return i18n(`${i18nKey}.errors.invalidName`);
+          return i18n(`${i18nKey}.name.errors.invalidName`);
+        } else if (!val.length) {
+          return i18n(`${i18nKey}.name.errors.nameRequired`);
         }
-        return true;
+        return accountNameExistsInConfig(val)
+          ? i18n(`${i18nKey}.name.errors.accountNameExists`, { name: val })
+          : true;
       },
-      default: 'New sandbox',
+      default: `New ${isDeveloperSandbox ? 'development ' : ''}sandbox`,
+    },
+  ]);
+};
+
+const sandboxTypeChoices = [
+  {
+    name: i18n(`${i18nKey}.type.developer`),
+    value: 'DEVELOPER',
+  },
+  {
+    name: i18n(`${i18nKey}.type.standard`),
+    value: 'STANDARD',
+  },
+];
+
+const sandboxTypePrompt = () => {
+  return promptUser([
+    {
+      name: 'type',
+      message: i18n(`${i18nKey}.type.message`),
+      type: 'list',
+      look: false,
+      choices: sandboxTypeChoices,
+      default: 'DEVELOPER',
     },
   ]);
 };
@@ -55,8 +94,8 @@ const deleteSandboxPrompt = (config, promptParentAccount = false) => {
       name: 'account',
       message: i18n(
         promptParentAccount
-          ? `${i18nKey}.selectParentAccountName`
-          : `${i18nKey}.selectAccountName`
+          ? `${i18nKey}.name.selectParentAccountName`
+          : `${i18nKey}.name.selectAccountName`
       ),
       type: 'list',
       look: false,
@@ -68,7 +107,7 @@ const deleteSandboxPrompt = (config, promptParentAccount = false) => {
 };
 
 module.exports = {
-  createSandboxPrompt,
+  sandboxNamePrompt,
+  sandboxTypePrompt,
   deleteSandboxPrompt,
-  getSandboxType,
 };

package/lib/sandbox-create.js

@@ -0,0 +1,199 @@
+const Spinnies = require('spinnies');
+const {
+  getSandboxLimit,
+  getHasSandboxesByType,
+  saveSandboxToConfig,
+  sandboxApiTypeMap,
+  STANDARD_SANDBOX,
+  DEVELOPER_SANDBOX,
+} = require('./sandboxes');
+const { i18n } = require('@hubspot/cli-lib/lib/lang');
+const { logger } = require('@hubspot/cli-lib/logger');
+const {
+  debugErrorAndContext,
+  logErrorInstance,
+} = require('@hubspot/cli-lib/errorHandlers/standardErrors');
+const {
+  isMissingScopeError,
+  isSpecifiedError,
+} = require('@hubspot/cli-lib/errorHandlers/apiErrors');
+const { getHubSpotWebsiteOrigin } = require('@hubspot/cli-lib/lib/urls');
+const { getEnv, getAccountId } = require('@hubspot/cli-lib');
+const { createSandbox } = require('@hubspot/cli-lib/sandboxes');
+const { getValidEnv } = require('@hubspot/cli-lib/lib/environment');
+
+const i18nKey = 'cli.lib.sandbox.create';
+
+/**
+ * @param {String} name - Name of sandbox
+ * @param {String} type - Sandbox type to be created (standard/developer)
+ * @param {Object} accountConfig - Account config of parent portal
+ * @param {String} env - Environment (QA/Prod)
+ * @returns {Object} Object containing sandboxConfigName string and sandbox instance from API
+ */
+const buildSandbox = async ({
+  name,
+  type,
+  accountConfig,
+  env,
+  force = false,
+}) => {
+  const spinnies = new Spinnies({
+    succeedColor: 'white',
+  });
+  const accountId = getAccountId(accountConfig.portalId);
+
+  let result;
+  const spinniesI18nKey = `${i18nKey}.loading.${type}`;
+
+  try {
+    logger.log('');
+    spinnies.add('sandboxCreate', {
+      text: i18n(`${spinniesI18nKey}.add`, {
+        sandboxName: name,
+      }),
+    });
+
+    const sandboxApiType = sandboxApiTypeMap[type]; // API expects sandbox type as 1 or 2
+    result = await createSandbox(accountId, name, sandboxApiType);
+
+    spinnies.succeed('sandboxCreate', {
+      text: i18n(`${spinniesI18nKey}.succeed`, {
+        name: result.sandbox.name,
+        sandboxHubId: result.sandbox.sandboxHubId,
+      }),
+    });
+  } catch (err) {
+    debugErrorAndContext(err);
+
+    spinnies.fail('sandboxCreate', {
+      text: i18n(`${spinniesI18nKey}.fail`, {
+        sandboxName: name,
+      }),
+    });
+
+    if (isMissingScopeError(err)) {
+      logger.error(
+        i18n(`${i18nKey}.failure.scopes.message`, {
+          accountName: accountConfig.name || accountId,
+        })
+      );
+      const websiteOrigin = getHubSpotWebsiteOrigin(env);
+      const url = `${websiteOrigin}/personal-access-key/${accountId}`;
+      logger.info(
+        i18n(`${i18nKey}.failure.scopes.instructions`, {
+          accountName: accountConfig.name || accountId,
+          url,
+        })
+      );
+    } else if (
+      isSpecifiedError(err, {
+        statusCode: 400,
+        category: 'VALIDATION_ERROR',
+        subCategory:
+          'SandboxErrors.NUM_DEVELOPMENT_SANDBOXES_LIMIT_EXCEEDED_ERROR',
+      }) &&
+      err.error &&
+      err.error.message
+    ) {
+      logger.log('');
+      const devSandboxLimit = getSandboxLimit(err.error);
+      const plural = devSandboxLimit !== 1;
+      const hasDevelopmentSandboxes = getHasSandboxesByType(
+        accountConfig,
+        DEVELOPER_SANDBOX
+      );
+      if (hasDevelopmentSandboxes) {
+        logger.error(
+          i18n(
+            `${i18nKey}.failure.alreadyInConfig.developer.${
+              plural ? 'other' : 'one'
+            }`,
+            {
+              accountName: accountConfig.name || accountId,
+              limit: devSandboxLimit,
+            }
+          )
+        );
+      } else {
+        const baseUrl = getHubSpotWebsiteOrigin(getValidEnv(getEnv(accountId)));
+        logger.error(
+          i18n(
+            `${i18nKey}.failure.limit.developer.${plural ? 'other' : 'one'}`,
+            {
+              accountName: accountConfig.name || accountId,
+              limit: devSandboxLimit,
+              link: `${baseUrl}/sandboxes-developer/${accountId}/development`,
+            }
+          )
+        );
+      }
+      logger.log('');
+    } else if (
+      isSpecifiedError(err, {
+        statusCode: 400,
+        category: 'VALIDATION_ERROR',
+        subCategory:
+          'SandboxErrors.NUM_STANDARD_SANDBOXES_LIMIT_EXCEEDED_ERROR',
+      }) &&
+      err.error &&
+      err.error.message
+    ) {
+      logger.log('');
+      const standardSandboxLimit = getSandboxLimit(err.error);
+      const plural = standardSandboxLimit !== 1;
+      const hasStandardSandboxes = getHasSandboxesByType(
+        accountConfig,
+        STANDARD_SANDBOX
+      );
+      if (hasStandardSandboxes) {
+        logger.error(
+          i18n(
+            `${i18nKey}.failure.alreadyInConfig.standard.${
+              plural ? 'other' : 'one'
+            }`,
+            {
+              accountName: accountConfig.name || accountId,
+              limit: standardSandboxLimit,
+            }
+          )
+        );
+      } else {
+        const baseUrl = getHubSpotWebsiteOrigin(getValidEnv(getEnv(accountId)));
+        logger.error(
+          i18n(
+            `${i18nKey}.failure.limit.standard.${plural ? 'other' : 'one'}`,
+            {
+              accountName: accountConfig.name || accountId,
+              limit: standardSandboxLimit,
+              link: `${baseUrl}/sandboxes-developer/${accountId}/standard`,
+            }
+          )
+        );
+      }
+      logger.log('');
+    } else {
+      logErrorInstance(err);
+    }
+    throw err;
+  }
+
+  let sandboxConfigName;
+
+  try {
+    // Response contains PAK, save to config here
+    sandboxConfigName = await saveSandboxToConfig(env, result, force);
+  } catch (err) {
+    logErrorInstance(err);
+    throw err;
+  }
+
+  return {
+    sandboxConfigName,
+    result,
+  };
+};
+
+module.exports = {
+  buildSandbox,
+};