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

package/commands/project/upload.js

@@ -1,22 +1,21 @@
-const chalk = require('chalk');
 const {
   addAccountOptions,
   addConfigOptions,
   getAccountId,
   addUseEnvironmentOptions,
 } = require('../../lib/commonOpts');
-const { trackCommandUsage } = require('../../lib/usageTracking');
-const { uiLine, uiAccountDescription } = require('../../lib/ui');
+const chalk = require('chalk');
 const { logger } = require('@hubspot/cli-lib/logger');
+const { uiLine } = require('../../lib/ui');
+const { trackCommandUsage } = require('../../lib/usageTracking');
 const { loadAndValidateOptions } = require('../../lib/validation');
 const {
   ensureProjectExists,
   getProjectConfig,
   handleProjectUpload,
   logFeedbackMessage,
-  pollBuildStatus,
-  pollDeployStatus,
   validateProjectConfig,
+  pollProjectBuildAndDeploy,
 } = require('../../lib/projects');
 const { i18n } = require('@hubspot/cli-lib/lib/lang');
 const { getAccountConfig } = require('@hubspot/cli-lib');
@@ -43,81 +42,34 @@ exports.handler = async options => {
 
   await ensureProjectExists(accountId, projectConfig.name, { forceCreate });
 
-  const startPolling = async (tempFile, buildId) => {
-    let exitCode = EXIT_CODES.SUCCESS;
-
-    const {
-      autoDeployId,
-      isAutoDeployEnabled,
-      deployStatusTaskLocator,
-      status,
-    } = await pollBuildStatus(accountId, projectConfig.name, buildId);
-    // autoDeployId of 0 indicates a skipped deploy
-    const isDeploying =
-      isAutoDeployEnabled && autoDeployId > 0 && deployStatusTaskLocator;
-
-    uiLine();
-
-    if (status === 'FAILURE') {
-      exitCode = EXIT_CODES.ERROR;
-      return;
-    } else if (isDeploying) {
-      logger.log(
-        i18n(`${i18nKey}.logs.buildSucceededAutomaticallyDeploying`, {
-          accountIdentifier: uiAccountDescription(accountId),
-          buildId,
-        })
-      );
-      const { status } = await pollDeployStatus(
-        accountId,
-        projectConfig.name,
-        deployStatusTaskLocator.id,
-        buildId
-      );
-      if (status === 'FAILURE') {
-        exitCode = EXIT_CODES.ERROR;
-      }
-    } else {
-      uiLine();
-      logger.log(
-        chalk.bold(
-          i18n(`${i18nKey}.logs.buildSucceeded`, {
-            buildId,
-          })
-        )
-      );
-      logger.log(i18n(`${i18nKey}.logs.readyToGoLive`));
-      logger.log(
-        i18n(`${i18nKey}.logs.runCommand`, {
-          command: chalk.hex('f5c26b')('hs project deploy'),
-        })
-      );
-      uiLine();
-    }
-
-    try {
-      tempFile.removeCallback();
-      logger.debug(
-        i18n(`${i18nKey}.debug.cleanedUpTempFile`, {
-          path: tempFile.name,
-        })
-      );
-    } catch (e) {
-      logger.error(e);
-    }
-
-    logFeedbackMessage(buildId);
-
-    process.exit(exitCode);
-  };
-
-  await handleProjectUpload(
+  const result = await handleProjectUpload(
     accountId,
     projectConfig,
     projectDir,
-    startPolling,
+    pollProjectBuildAndDeploy,
     message
   );
+
+  if (result.buildSucceeded && !result.autodeployEnabled) {
+    uiLine();
+    logger.log(
+      chalk.bold(
+        i18n(`${i18nKey}.logs.buildSucceeded`, {
+          buildId: result.buildId,
+        })
+      )
+    );
+    logger.log(i18n(`${i18nKey}.logs.readyToGoLive`));
+    logger.log(
+      i18n(`${i18nKey}.logs.runCommand`, {
+        command: chalk.hex('f5c26b')('hs project deploy'),
+      })
+    );
+    uiLine();
+  }
+
+  logFeedbackMessage(result.buildId);
+  process.exit(result.succeeded ? EXIT_CODES.SUCCESS : EXIT_CODES.ERROR);
 };
 
 exports.builder = yargs => {

package/commands/project.js

@@ -7,6 +7,8 @@ const logs = require('./project/logs');
 const watch = require('./project/watch');
 const download = require('./project/download');
 const open = require('./project/open');
+const dev = require('./project/dev');
+const add = require('./project/add');
 
 exports.command = 'project';
 exports.describe = false; //'Commands for working with projects';
@@ -24,6 +26,8 @@ exports.builder = yargs => {
   yargs.command(logs).demandCommand(1, '');
   yargs.command(download).demandCommand(0, '');
   yargs.command(open).demandCommand(0, '');
+  yargs.command(dev).demandCommand(0, '');
+  yargs.command(add).demandCommand(0, '');
 
   return yargs;
 };

package/commands/sandbox/create.js

@@ -5,183 +5,199 @@ const {
   addUseEnvironmentOptions,
   addTestingOptions,
 } = require('../../lib/commonOpts');
-const { trackCommandUsage } = require('../../lib/usageTracking');
-const { logger } = require('@hubspot/cli-lib/logger');
-const Spinnies = require('spinnies');
-const { createSandbox } = require('@hubspot/cli-lib/sandboxes');
 const { loadAndValidateOptions } = require('../../lib/validation');
-const { createSandboxPrompt } = require('../../lib/prompts/sandboxesPrompt');
-const {
-  getSandboxType,
-  sandboxCreatePersonalAccessKeyFlow,
-  getHasDevelopmentSandboxes,
-  getDevSandboxLimit,
-} = require('../../lib/sandboxes');
 const { i18n } = require('@hubspot/cli-lib/lib/lang');
-const { logErrorInstance } = require('@hubspot/cli-lib/errorHandlers');
-const {
-  debugErrorAndContext,
-} = require('@hubspot/cli-lib/errorHandlers/standardErrors');
-const { ENVIRONMENTS } = require('@hubspot/cli-lib/lib/constants');
 const { EXIT_CODES } = require('../../lib/enums/exitCodes');
 const { getAccountConfig, getEnv } = require('@hubspot/cli-lib');
-const { getHubSpotWebsiteOrigin } = require('@hubspot/cli-lib/lib/urls');
+const { buildSandbox } = require('../../lib/sandbox-create');
+const { uiFeatureHighlight } = require('../../lib/ui');
+const {
+  sandboxTypeMap,
+  DEVELOPER_SANDBOX,
+  getSandboxTypeAsString,
+  getAccountName,
+  getAvailableSyncTypes,
+  syncTypes,
+  validateSandboxUsageLimits,
+} = require('../../lib/sandboxes');
+const { getValidEnv } = require('@hubspot/cli-lib/lib/environment');
+const { logger } = require('@hubspot/cli-lib/logger');
+const { trackCommandUsage } = require('../../lib/usageTracking');
 const {
-  isMissingScopeError,
-  isSpecifiedError,
-} = require('@hubspot/cli-lib/errorHandlers/apiErrors');
+  sandboxTypePrompt,
+  sandboxNamePrompt,
+} = require('../../lib/prompts/sandboxesPrompt');
+const { promptUser } = require('../../lib/prompts/promptUtils');
+const { syncSandbox } = require('../../lib/sandbox-sync');
+const { logErrorInstance } = require('@hubspot/cli-lib/errorHandlers');
 
 const i18nKey = 'cli.commands.sandbox.subcommands.create';
 
-exports.command = 'create [--name]';
+exports.command = 'create [--name] [--type]';
 exports.describe = i18n(`${i18nKey}.describe`);
 
 exports.handler = async options => {
   await loadAndValidateOptions(options);
 
-  const { name } = options;
+  const { name, type, force } = options;
   const accountId = getAccountId(options);
   const accountConfig = getAccountConfig(accountId);
-  const env = options.qa ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD;
-  const spinnies = new Spinnies({
-    succeedColor: 'white',
-  });
+  const env = getValidEnv(getEnv(accountId));
 
   trackCommandUsage('sandbox-create', null, accountId);
 
+  // Default account is not a production portal
   if (
     accountConfig.sandboxAccountType &&
     accountConfig.sandboxAccountType !== null
   ) {
     trackCommandUsage('sandbox-create', { successful: false }, accountId);
-
     logger.error(
       i18n(`${i18nKey}.failure.creatingWithinSandbox`, {
-        sandboxType: getSandboxType(accountConfig.sandboxAccountType),
+        sandboxType: getSandboxTypeAsString(accountConfig.sandboxAccountType),
+        sandboxName: accountConfig.name,
       })
     );
-
     process.exit(EXIT_CODES.ERROR);
   }
 
+  let typePrompt;
   let namePrompt;
 
-  logger.log(i18n(`${i18nKey}.sandboxLimitation`));
-  logger.log('');
+  if ((type && !sandboxTypeMap[type]) || !type) {
+    if (!force) {
+      typePrompt = await sandboxTypePrompt();
+    } else {
+      logger.error(i18n(`${i18nKey}.failure.optionMissing.type`));
+      trackCommandUsage('sandbox-create', { successful: false }, accountId);
+      process.exit(EXIT_CODES.ERROR);
+    }
+  }
+  const sandboxType = sandboxTypeMap[type] || sandboxTypeMap[typePrompt.type];
 
-  if (!name) {
-    namePrompt = await createSandboxPrompt();
+  // Check usage limits and exit if parent portal has no available sandboxes for the selected type
+  try {
+    await validateSandboxUsageLimits(accountConfig, sandboxType, env);
+  } catch (err) {
+    logErrorInstance(err);
+    trackCommandUsage('sandbox-create', { successful: false }, accountId);
+    process.exit(EXIT_CODES.ERROR);
   }
 
+  if (!name) {
+    if (!force) {
+      namePrompt = await sandboxNamePrompt(sandboxType);
+    } else {
+      logger.error(i18n(`${i18nKey}.failure.optionMissing.name`));
+      trackCommandUsage('sandbox-create', { successful: false }, accountId);
+      process.exit(EXIT_CODES.ERROR);
+    }
+  }
   const sandboxName = name || namePrompt.name;
 
-  let result;
+  let sandboxSyncPromptResult = true;
+  let contactRecordsSyncPromptResult = true;
+  if (!force) {
+    const syncI18nKey = 'cli.lib.sandbox.sync';
+    const { sandboxSyncPrompt } = await promptUser([
+      {
+        name: 'sandboxSyncPrompt',
+        type: 'confirm',
+        message: i18n(`${syncI18nKey}.confirm.createFlow.${sandboxType}`, {
+          parentAccountName: getAccountName(accountConfig),
+          sandboxName,
+        }),
+      },
+    ]);
+    sandboxSyncPromptResult = sandboxSyncPrompt;
+    // We can prompt for contact records before fetching types since we're starting with a fresh sandbox in create
+    if (sandboxSyncPrompt) {
+      const { contactRecordsSyncPrompt } = await promptUser([
+        {
+          name: 'contactRecordsSyncPrompt',
+          type: 'confirm',
+          message: i18n(
+            `${syncI18nKey}.confirm.syncContactRecords.${sandboxType}`
+          ),
+        },
+      ]);
+      contactRecordsSyncPromptResult = contactRecordsSyncPrompt;
+    }
+  }
 
   try {
-    spinnies.add('sandboxCreate', {
-      text: i18n(`${i18nKey}.loading.add`, {
-        sandboxName,
-      }),
-    });
-
-    result = await createSandbox(accountId, sandboxName);
-
-    logger.log('');
-    spinnies.succeed('sandboxCreate', {
-      text: i18n(`${i18nKey}.loading.succeed`, {
-        name: result.name,
-        sandboxHubId: result.sandboxHubId,
-      }),
-    });
-  } catch (err) {
-    debugErrorAndContext(err);
-
-    trackCommandUsage('sandbox-create', { successful: false }, accountId);
-
-    spinnies.fail('sandboxCreate', {
-      text: i18n(`${i18nKey}.loading.fail`, {
-        sandboxName,
-      }),
+    const { result } = await buildSandbox({
+      name: sandboxName,
+      type: sandboxType,
+      accountConfig,
+      env,
+      force,
     });
 
-    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,
-        })
+    // Prompt user to sync assets after sandbox creation
+    const sandboxAccountConfig = getAccountConfig(result.sandbox.sandboxHubId);
+    const handleSyncSandbox = async syncTasks => {
+      await syncSandbox({
+        accountConfig: sandboxAccountConfig,
+        parentAccountConfig: accountConfig,
+        env,
+        syncTasks,
+      });
+    };
+    try {
+      let availableSyncTasks = await getAvailableSyncTypes(
+        accountConfig,
+        sandboxAccountConfig
       );
-    } else if (
-      isSpecifiedError(
-        err,
-        400,
-        'VALIDATION_ERROR',
-        'SandboxErrors.NUM_DEVELOPMENT_SANDBOXES_LIMIT_EXCEEDED_ERROR'
-      ) &&
-      err.error &&
-      err.error.message
-    ) {
-      logger.log('');
-      const devSandboxLimit = getDevSandboxLimit(err.error);
-      const plural = devSandboxLimit !== 1;
-      const hasDevelopmentSandboxes = getHasDevelopmentSandboxes(accountConfig);
-      if (hasDevelopmentSandboxes) {
-        logger.error(
-          i18n(
-            `${i18nKey}.failure.alreadyInConfig.${plural ? 'other' : 'one'}`,
-            {
-              accountName: accountConfig.name || accountId,
-              limit: devSandboxLimit,
-            }
-          )
+      if (!contactRecordsSyncPromptResult) {
+        availableSyncTasks = availableSyncTasks.filter(
+          t => t.type !== syncTypes.OBJECT_RECORDS
         );
+      }
+      if (!force) {
+        if (sandboxSyncPromptResult) {
+          await handleSyncSandbox(availableSyncTasks);
+        }
       } else {
-        const baseUrl = getHubSpotWebsiteOrigin(
-          getEnv(accountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD
-        );
-        logger.error(
-          i18n(`${i18nKey}.failure.limit.${plural ? 'other' : 'one'}`, {
-            accountName: accountConfig.name || accountId,
-            limit: devSandboxLimit,
-            devSandboxesLink: `${baseUrl}/sandboxes-developer/${accountId}/development`,
-          })
-        );
+        await handleSyncSandbox(availableSyncTasks);
       }
-      logger.log('');
-    } else {
+    } catch (err) {
       logErrorInstance(err);
+      throw err;
     }
-    process.exit(EXIT_CODES.ERROR);
-  }
-  try {
-    await sandboxCreatePersonalAccessKeyFlow(
-      env,
-      result.sandboxHubId,
-      result.name
-    );
+
+    uiFeatureHighlight([
+      'accountsUseCommand',
+      sandboxType === DEVELOPER_SANDBOX
+        ? 'projectDevCommand'
+        : 'projectUploadCommand',
+    ]);
     process.exit(EXIT_CODES.SUCCESS);
-  } catch (err) {
-    logErrorInstance(err);
+  } catch (error) {
+    trackCommandUsage('sandbox-create', { successful: false }, accountId);
+    // Errors are logged in util functions
     process.exit(EXIT_CODES.ERROR);
   }
 };
 
 exports.builder = yargs => {
+  yargs.option('f', {
+    type: 'boolean',
+    alias: 'force',
+    describe: i18n(`${i18nKey}.examples.force`),
+  });
   yargs.option('name', {
     describe: i18n(`${i18nKey}.options.name.describe`),
     type: 'string',
   });
+  yargs.option('type', {
+    describe: i18n(`${i18nKey}.options.type.describe`),
+    type: 'string',
+  });
 
   yargs.example([
     [
-      '$0 sandbox create --name=MySandboxAccount',
+      '$0 sandbox create --name=MySandboxAccount --type=STANDARD',
       i18n(`${i18nKey}.examples.default`),
     ],
   ]);

package/commands/sandbox/delete.js

@@ -26,12 +26,12 @@ const {
 const { EXIT_CODES } = require('../../lib/enums/exitCodes');
 const { promptUser } = require('../../lib/prompts/promptUtils');
 const { getHubSpotWebsiteOrigin } = require('@hubspot/cli-lib/lib/urls');
-const { ENVIRONMENTS } = require('@hubspot/cli-lib/lib/constants');
 const {
   isSpecifiedError,
 } = require('@hubspot/cli-lib/errorHandlers/apiErrors');
 const { HubSpotAuthError } = require('@hubspot/cli-lib/lib/models/Errors');
 const { getAccountName } = require('../../lib/sandboxes');
+const { getValidEnv } = require('@hubspot/cli-lib/lib/environment');
 
 const i18nKey = 'cli.commands.sandbox.subcommands.delete';
 
@@ -71,7 +71,7 @@ exports.handler = async options => {
   trackCommandUsage('sandbox-delete', null, sandboxAccountId);
 
   const baseUrl = getHubSpotWebsiteOrigin(
-    getEnv(sandboxAccountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD
+    getValidEnv(getEnv(sandboxAccountId))
   );
 
   let parentAccountId;
@@ -117,11 +117,12 @@ exports.handler = async options => {
   );
 
   if (isDefaultAccount) {
-    logger.log(
+    logger.info(
       i18n(`${i18nKey}.defaultAccountWarning`, {
         account: getAccountName(accountConfig),
       })
     );
+    logger.log('');
   }
 
   try {
@@ -187,12 +188,11 @@ exports.handler = async options => {
         );
       }
     } else if (
-      isSpecifiedError(
-        err,
-        404,
-        'OBJECT_NOT_FOUND',
-        'SandboxErrors.SANDBOX_NOT_FOUND'
-      )
+      isSpecifiedError(err, {
+        statusCode: 404,
+        category: 'OBJECT_NOT_FOUND',
+        subCategory: 'SandboxErrors.SANDBOX_NOT_FOUND',
+      })
     ) {
       logger.log('');
       logger.warn(