@hubspot/cli 5.2.0 → 5.2.1-beta.1

package/lib/localDev.js

@@ -0,0 +1,401 @@
+const { logger } = require('@hubspot/local-dev-lib/logger');
+const {
+  HUBSPOT_ACCOUNT_TYPES,
+  HUBSPOT_ACCOUNT_TYPE_STRINGS,
+} = require('@hubspot/local-dev-lib/constants/config');
+const {
+  isMissingScopeError,
+  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 { createProject } = require('@hubspot/local-dev-lib/api/projects');
+
+const {
+  confirmDefaultAccountPrompt,
+  selectSandboxTargetAccountPrompt,
+  selectDeveloperTestTargetAccountPrompt,
+} = 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');
+const { i18n } = require('./lang');
+const { EXIT_CODES } = require('./enums/exitCodes');
+const { trackCommandMetadataUsage } = require('./usageTracking');
+const {
+  isAppDeveloperAccount,
+  isDeveloperTestAccount,
+} = require('./accountTypes');
+const {
+  handleProjectUpload,
+  pollProjectBuildAndDeploy,
+} = require('./projects');
+const {
+  PROJECT_ERROR_TYPES,
+  PROJECT_BUILD_TEXT,
+  PROJECT_DEPLOY_TEXT,
+} = require('./constants');
+const {
+  logApiErrorInstance,
+  ApiErrorContext,
+} = require('./errorHandlers/apiErrors');
+
+const i18nKey = 'cli.lib.localDev';
+
+// If the user passed in the --account flag, confirm they want to use that account as
+// their target account, otherwise exit
+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`
+  );
+
+  if (!useDefaultAccount) {
+    logger.log(
+      i18n(
+        `${i18nKey}.confirmDefaultAccountIsTarget.declineDefaultAccountExplanation`,
+        {
+          useCommand: uiCommandReference('hs accounts use'),
+          devCommand: uiCommandReference('hs project dev'),
+        }
+      )
+    );
+    process.exit(EXIT_CODES.SUCCESS);
+  }
+};
+
+// Confirm the default account is a developer account if developing public apps
+const checkIfAppDeveloperAccount = accountConfig => {
+  if (!isAppDeveloperAccount(accountConfig)) {
+    logger.error(
+      i18n(
+        `${i18nKey}.checkCorrectParentAccountType.standardAccountNotSupported`
+      )
+    );
+    process.exit(EXIT_CODES.SUCCESS);
+  }
+};
+
+// If the user isn't using the recommended account type, prompt them to use or create one
+const suggestRecommendedNestedAccount = async (
+  accounts,
+  accountConfig,
+  hasPublicApps
+) => {
+  logger.log();
+  uiLine();
+  if (hasPublicApps) {
+    logger.warn(
+      i18n(
+        `${i18nKey}.suggestRecommendedNestedAccount.publicAppNonDeveloperTestAccountWarning`
+      )
+    );
+  } else if (isAppDeveloperAccount(accountConfig)) {
+    logger.warn(
+      i18n(
+        `${i18nKey}.suggestRecommendedNestedAccount.publicAppNonDeveloperTestAccountWarning`
+      )
+    );
+  } else {
+    logger.warn(
+      i18n(`${i18nKey}.suggestRecommendedNestedAccount.nonSandboxWarning`)
+    );
+  }
+  uiLine();
+  logger.log();
+
+  const targetAccountPrompt = isAppDeveloperAccount(accountConfig)
+    ? selectDeveloperTestTargetAccountPrompt
+    : selectSandboxTargetAccountPrompt;
+
+  return targetAccountPrompt(accounts, accountConfig, hasPublicApps);
+};
+
+// Create a new sandbox and return its accountId
+const createSandboxForLocalDev = async (accountId, accountConfig, env) => {
+  try {
+    await validateSandboxUsageLimits(
+      accountConfig,
+      HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+      env
+    );
+  } catch (err) {
+    if (isMissingScopeError(err)) {
+      logger.error(
+        i18n('cli.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', {
+          accountName: accountConfig.name || accountId,
+          url,
+        })
+      );
+    } else {
+      logErrorInstance(err);
+    }
+    process.exit(EXIT_CODES.ERROR);
+  }
+  try {
+    const { name } = await sandboxNamePrompt(
+      HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX
+    );
+
+    trackCommandMetadataUsage(
+      'sandbox-create',
+      { step: 'project-dev' },
+      accountId
+    );
+
+    const { result } = await buildSandbox({
+      name,
+      type: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+      accountConfig,
+      env,
+    });
+
+    const targetAccountId = result.sandbox.sandboxHubId;
+
+    const sandboxAccountConfig = getAccountConfig(result.sandbox.sandboxHubId);
+    const syncTasks = await getAvailableSyncTypes(
+      accountConfig,
+      sandboxAccountConfig
+    );
+    await syncSandbox({
+      accountConfig: sandboxAccountConfig,
+      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
+    });
+    return targetAccountId;
+  } catch (err) {
+    logErrorInstance(err);
+    process.exit(EXIT_CODES.ERROR);
+  }
+};
+
+// Create a developer test account and return its accountId
+const createDeveloperTestAccountForLocalDev = async (
+  accountId,
+  accountConfig,
+  env
+) => {
+  let currentPortalCount = 0;
+  let maxTestPortals = 10;
+  try {
+    const validateResult = await validateDevTestAccountUsageLimits(
+      accountConfig
+    );
+    if (validateResult) {
+      currentPortalCount = validateResult.results
+        ? validateResult.results.length
+        : 0;
+      maxTestPortals = validateResult.maxTestPortals;
+    }
+  } catch (err) {
+    if (isMissingScopeError(err)) {
+      logger.error(
+        i18n('cli.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,
+          }
+        )
+      );
+    } else {
+      logErrorInstance(err);
+    }
+    process.exit(EXIT_CODES.ERROR);
+  }
+
+  try {
+    const { name } = await developerTestAccountNamePrompt(currentPortalCount);
+    trackCommandMetadataUsage(
+      'developer-test-account-create',
+      { step: 'project-dev' },
+      accountId
+    );
+
+    const { result } = await buildDeveloperTestAccount({
+      name,
+      accountConfig,
+      env,
+      maxTestPortals,
+    });
+
+    return result.id;
+  } catch (err) {
+    logErrorInstance(err);
+    process.exit(EXIT_CODES.ERROR);
+  }
+};
+
+// Prompt the user to create a new project if one doesn't exist on their target account
+const createNewProjectForLocalDev = async (
+  projectConfig,
+  targetAccountId,
+  shouldCreateWithoutConfirmation
+) => {
+  // Create the project without prompting if this is a newly created sandbox
+  let shouldCreateProject = shouldCreateWithoutConfirmation;
+
+  if (!shouldCreateProject) {
+    logger.log();
+    uiLine();
+    logger.warn(
+      i18n(
+        `${i18nKey}.createNewProjectForLocalDev.projectMustExistExplanation`,
+        {
+          accountIdentifier: uiAccountDescription(targetAccountId),
+          projectName: projectConfig.name,
+        }
+      )
+    );
+    uiLine();
+
+    shouldCreateProject = await confirmPrompt(
+      i18n(`${i18nKey}.createNewProjectForLocalDev.createProject`, {
+        accountIdentifier: uiAccountDescription(targetAccountId),
+        projectName: projectConfig.name,
+      })
+    );
+  }
+
+  if (shouldCreateProject) {
+    SpinniesManager.add('createProject', {
+      text: i18n(`${i18nKey}.createNewProjectForLocalDev.creatingProject`, {
+        accountIdentifier: uiAccountDescription(targetAccountId),
+        projectName: projectConfig.name,
+      }),
+    });
+
+    try {
+      await createProject(targetAccountId, projectConfig.name);
+      SpinniesManager.succeed('createProject', {
+        text: i18n(`${i18nKey}.createNewProjectForLocalDev.createdProject`, {
+          accountIdentifier: uiAccountDescription(targetAccountId),
+          projectName: projectConfig.name,
+        }),
+        succeedColor: 'white',
+      });
+    } catch (err) {
+      SpinniesManager.fail('createProject');
+      logger.log(
+        i18n(`${i18nKey}.createNewProjectForLocalDev.failedToCreateProject`)
+      );
+      process.exit(EXIT_CODES.ERROR);
+    }
+  } else {
+    // We cannot continue if the project does not exist in the target account
+    logger.log();
+    logger.log(
+      i18n(`${i18nKey}.createNewProjectForLocalDev.choseNotToCreateProject`)
+    );
+    process.exit(EXIT_CODES.SUCCESS);
+  }
+};
+
+// Create an initial build if the project was newly created in the account
+// Return the newly deployed build
+const createInitialBuildForNewProject = async (
+  projectConfig,
+  projectDir,
+  targetAccountId
+) => {
+  const initialUploadResult = await handleProjectUpload(
+    targetAccountId,
+    projectConfig,
+    projectDir,
+    (...args) => pollProjectBuildAndDeploy(...args, true),
+    i18n(`${i18nKey}.createInitialBuildForNewProject.initialUploadMessage`)
+  );
+
+  if (initialUploadResult.uploadError) {
+    if (
+      isSpecifiedError(initialUploadResult.uploadError, {
+        subCategory: PROJECT_ERROR_TYPES.PROJECT_LOCKED,
+      })
+    ) {
+      logger.log();
+      logger.error(
+        i18n(`${i18nKey}.createInitialBuildForNewProject.projectLockedError`)
+      );
+      logger.log();
+    } else {
+      logApiErrorInstance(
+        initialUploadResult.uploadError,
+        new ApiErrorContext({
+          accountId: targetAccountId,
+          projectName: projectConfig.name,
+        })
+      );
+    }
+    process.exit(EXIT_CODES.ERROR);
+  }
+
+  if (!initialUploadResult.succeeded) {
+    let subTasks = [];
+
+    if (initialUploadResult.buildResult.status === 'FAILURE') {
+      subTasks =
+        initialUploadResult.buildResult[PROJECT_BUILD_TEXT.SUBTASK_KEY];
+    } else if (initialUploadResult.deployResult.status === 'FAILURE') {
+      subTasks =
+        initialUploadResult.deployResult[PROJECT_DEPLOY_TEXT.SUBTASK_KEY];
+    }
+
+    const failedSubTasks = subTasks.filter(task => task.status === 'FAILURE');
+
+    logger.log();
+    failedSubTasks.forEach(failedSubTask => {
+      console.error(failedSubTask.errorMessage);
+    });
+    logger.log();
+
+    process.exit(EXIT_CODES.ERROR);
+  }
+
+  return initialUploadResult.buildResult;
+};
+
+module.exports = {
+  confirmDefaultAccountIsTarget,
+  checkIfAppDeveloperAccount,
+  suggestRecommendedNestedAccount,
+  createSandboxForLocalDev,
+  createDeveloperTestAccountForLocalDev,
+  createNewProjectForLocalDev,
+  createInitialBuildForNewProject,
+};

package/lib/projectStructure.js

@@ -118,9 +118,16 @@ async function findProjectComponents(projectSourceDir) {
   return components;
 }
 
+function getProjectComponentTypes(components) {
+  const projectContents = {};
+  components.forEach(({ type }) => (projectContents[type] = true));
+  return projectContents;
+}
+
 module.exports = {
   CONFIG_FILES,
   COMPONENT_TYPES,
   findProjectComponents,
   getAppCardConfigs,
+  getProjectComponentTypes,
 };

package/lib/projects.js

@@ -26,8 +26,13 @@ const {
   getDeployStructure,
   fetchProject,
   uploadProject,
+  fetchBuildWarnLogs,
+  fetchDeployWarnLogs,
 } = require('@hubspot/local-dev-lib/api/projects');
-const { isSpecifiedError } = require('@hubspot/local-dev-lib/errors/apiErrors');
+const {
+  isSpecifiedError,
+  isSpecifiedHubSpotAuthError,
+} = require('@hubspot/local-dev-lib/errors/apiErrors');
 const { shouldIgnoreFile } = require('@hubspot/local-dev-lib/ignoreRules');
 const { getCwd, getAbsoluteFilePath } = require('@hubspot/local-dev-lib/path');
 const { downloadGithubRepoContents } = require('@hubspot/local-dev-lib/github');
@@ -39,7 +44,6 @@ const SpinniesManager = require('./ui/SpinniesManager');
 const {
   logApiErrorInstance,
   ApiErrorContext,
-  isSpecifiedHubSpotAuthError,
 } = require('./errorHandlers/apiErrors');
 const { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH } = require('./constants');
 
@@ -443,7 +447,10 @@ const pollProjectBuildAndDeploy = async (
           }
         )
       );
+
+      displayWarnLogs(accountId, projectConfig.name, buildId);
     }
+
     const deployStatus = await pollDeployStatus(
       accountId,
       projectConfig.name,
@@ -471,6 +478,14 @@ const pollProjectBuildAndDeploy = async (
     logger.error(e);
   }
 
+  if (result && result.deployResult) {
+    displayWarnLogs(
+      accountId,
+      projectConfig.name,
+      result.deployResult.deployId,
+      true
+    );
+  }
   return result;
 };
 
@@ -869,6 +884,28 @@ const createProjectComponent = async (
   );
 };
 
+const displayWarnLogs = async (
+  accountId,
+  projectName,
+  taskId,
+  isDeploy = false
+) => {
+  let result;
+
+  if (isDeploy) {
+    result = await fetchDeployWarnLogs(accountId, projectName, taskId);
+  } else {
+    result = await fetchBuildWarnLogs(accountId, projectName, taskId);
+  }
+
+  if (result && result.logs.length) {
+    result.logs.forEach(log => {
+      logger.warn(log.message);
+      logger.log('');
+    });
+  }
+};
+
 module.exports = {
   writeProjectConfig,
   getProjectConfig,
@@ -885,4 +922,5 @@ module.exports = {
   ensureProjectExists,
   logFeedbackMessage,
   createProjectComponent,
+  displayWarnLogs,
 };

package/lib/prompts/developerTestAccountNamePrompt.js

@@ -0,0 +1,29 @@
+const { promptUser } = require('./promptUtils');
+const { i18n } = require('../lang');
+const { accountNameExistsInConfig } = require('@hubspot/local-dev-lib/config');
+
+const i18nKey = 'cli.lib.prompts.developerTestAccountPrompt';
+
+const developerTestAccountNamePrompt = currentPortalCount => {
+  return promptUser([
+    {
+      name: 'name',
+      message: i18n(`${i18nKey}.name.message`),
+      validate(val) {
+        if (typeof val !== 'string') {
+          return i18n(`${i18nKey}.name.errors.invalidName`);
+        } else if (!val.length) {
+          return i18n(`${i18nKey}.name.errors.nameRequired`);
+        }
+        return accountNameExistsInConfig(val)
+          ? i18n(`${i18nKey}.name.errors.accountNameExists`, { name: val })
+          : true;
+      },
+      default: `Developer test account ${currentPortalCount + 1}`,
+    },
+  ]);
+};
+
+module.exports = {
+  developerTestAccountNamePrompt,
+};

package/lib/prompts/projectDevTargetAccountPrompt.js

@@ -1,28 +1,36 @@
 const { promptUser } = require('./promptUtils');
 const { i18n } = require('../lang');
 const { uiAccountDescription, uiCommandReference } = require('../ui');
-const { isSandbox } = require('../sandboxes');
+const { isSandbox, isDeveloperTestAccount } = require('../accountTypes');
 const { getAccountId } = require('@hubspot/local-dev-lib/config');
 const { getSandboxUsageLimits } = require('@hubspot/local-dev-lib/sandboxes');
 const {
   HUBSPOT_ACCOUNT_TYPES,
+  HUBSPOT_ACCOUNT_TYPE_STRINGS,
 } = require('@hubspot/local-dev-lib/constants/config');
 const { logger } = require('@hubspot/local-dev-lib/logger');
+const {
+  fetchDeveloperTestAccounts,
+} = require('@hubspot/local-dev-lib/developerTestAccounts');
 
 const i18nKey = 'cli.lib.prompts.projectDevTargetAccountPrompt';
 
-const mapSandboxAccount = accountConfig => ({
+const mapNestedAccount = accountConfig => ({
   name: uiAccountDescription(accountConfig.portalId, false),
   value: {
     targetAccountId: getAccountId(accountConfig.name),
-    createNewSandbox: false,
+    createNestedAccount: false,
+    parentAccountId: accountConfig.parentAccountId,
   },
 });
 
-const selectTargetAccountPrompt = async (accounts, defaultAccountConfig) => {
-  let sandboxUsage = {};
+const selectSandboxTargetAccountPrompt = async (
+  accounts,
+  defaultAccountConfig
+) => {
   const defaultAccountId = getAccountId(defaultAccountConfig.name);
-
+  let choices = [];
+  let sandboxUsage = {};
   try {
     sandboxUsage = await getSandboxUsageLimits(defaultAccountId);
   } catch (err) {
@@ -48,20 +56,19 @@ const selectTargetAccountPrompt = async (accounts, defaultAccountConfig) => {
       });
     }
   }
-
   // Order choices by Developer Sandbox -> Standard Sandbox
-  const choices = [
+  choices = [
     ...sandboxAccounts
       .filter(a => a.accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)
-      .map(mapSandboxAccount),
+      .map(mapNestedAccount),
     ...sandboxAccounts
       .filter(a => a.accountType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX)
-      .map(mapSandboxAccount),
+      .map(mapNestedAccount),
     {
       name: i18n(`${i18nKey}.createNewSandboxOption`),
       value: {
         targetAccountId: null,
-        createNewSandbox: true,
+        createNestedAccount: true,
       },
       disabled: disabledMessage,
     },
@@ -69,17 +76,80 @@ const selectTargetAccountPrompt = async (accounts, defaultAccountConfig) => {
       name: i18n(`${i18nKey}.chooseDefaultAccountOption`),
       value: {
         targetAccountId: defaultAccountId,
-        createNewSandbox: false,
+        createNestedAccount: false,
       },
     },
   ];
 
+  return selectTargetAccountPrompt(
+    defaultAccountId,
+    'sandbox account',
+    choices
+  );
+};
+
+const selectDeveloperTestTargetAccountPrompt = async (
+  accounts,
+  defaultAccountConfig
+) => {
+  const defaultAccountId = getAccountId(defaultAccountConfig.name);
+  let choices = [];
+  let devTestAccountUsage = undefined;
+  try {
+    devTestAccountUsage = await fetchDeveloperTestAccounts(defaultAccountId);
+  } catch (err) {
+    logger.debug('Unable to fetch developer test account usage limits: ', err);
+  }
+
+  const devTestAccounts = accounts
+    .reverse()
+    .filter(
+      config =>
+        isDeveloperTestAccount(config) &&
+        config.parentAccountId === defaultAccountId
+    );
+  let disabledMessage = false;
+  if (
+    devTestAccountUsage &&
+    devTestAccountUsage.results.length >= devTestAccountUsage.maxTestPortals
+  ) {
+    disabledMessage = i18n(`${i18nKey}.developerTestAccountLimit`, {
+      authCommand: uiCommandReference('hs auth'),
+      limit: devTestAccountUsage.maxTestPortals,
+    });
+  }
+
+  choices = [
+    ...devTestAccounts.map(mapNestedAccount),
+    {
+      name: i18n(`${i18nKey}.createNewDeveloperTestAccountOption`),
+      value: {
+        targetAccountId: null,
+        createNestedAccount: true,
+      },
+      disabled: disabledMessage,
+    },
+  ];
+
+  return selectTargetAccountPrompt(
+    defaultAccountId,
+    HUBSPOT_ACCOUNT_TYPE_STRINGS[HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST],
+    choices
+  );
+};
+
+const selectTargetAccountPrompt = async (
+  defaultAccountId,
+  accountType,
+  choices
+) => {
   const { targetAccountInfo } = await promptUser([
     {
       name: 'targetAccountInfo',
       type: 'list',
       message: i18n(`${i18nKey}.promptMessage`, {
         accountIdentifier: uiAccountDescription(defaultAccountId),
+        accountType,
       }),
       choices,
     },
@@ -103,6 +173,7 @@ const confirmDefaultAccountPrompt = async (accountName, accountType) => {
 };
 
 module.exports = {
-  selectTargetAccountPrompt,
+  selectSandboxTargetAccountPrompt,
+  selectDeveloperTestTargetAccountPrompt,
   confirmDefaultAccountPrompt,
 };

package/lib/prompts/sandboxesPrompt.js

@@ -5,7 +5,7 @@ const { uiAccountDescription } = require('../ui');
 const {
   HUBSPOT_ACCOUNT_TYPES,
 } = require('@hubspot/local-dev-lib/constants/config');
-const { isSandbox } = require('../sandboxes');
+const { isSandbox } = require('../accountTypes');
 
 const i18nKey = 'cli.lib.prompts.sandboxesPrompt';
 

package/lib/sandboxSync.js

@@ -2,11 +2,11 @@ const SpinniesManager = require('./ui/SpinniesManager');
 const { getHubSpotWebsiteOrigin } = require('@hubspot/local-dev-lib/urls');
 const { logger } = require('@hubspot/local-dev-lib/logger');
 const { i18n } = require('./lang');
+const { isDevelopmentSandbox } = require('./accountTypes');
 const {
   getAvailableSyncTypes,
   pollSyncTaskStatus,
   syncTypes,
-  isDevelopmentSandbox,
 } = require('./sandboxes');
 const { initiateSync } = require('@hubspot/local-dev-lib/sandboxes');
 const {