@hubspot/cli 6.2.1 → 6.2.2-experimental.0

package/lib/localDev.js

@@ -1,491 +1,335 @@
+"use strict";
 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/index');
+const { HUBSPOT_ACCOUNT_TYPES, HUBSPOT_ACCOUNT_TYPE_STRINGS, } = require('@hubspot/local-dev-lib/constants/config');
+const { isMissingScopeError, isSpecifiedError, } = require('@hubspot/local-dev-lib/errors/index');
 const { getHubSpotWebsiteOrigin } = require('@hubspot/local-dev-lib/urls');
 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 { ENVIRONMENTS, } = require('@hubspot/local-dev-lib/constants/environments');
+const { confirmDefaultAccountPrompt, selectSandboxTargetAccountPrompt, selectDeveloperTestTargetAccountPrompt, confirmUseExistingDeveloperTestAccountPrompt, } = require('./prompts/projectDevTargetAccountPrompt');
 const { confirmPrompt } = require('./prompts/promptUtils');
-const {
-  validateSandboxUsageLimits,
-  getAvailableSyncTypes,
-} = require('./sandboxes');
+const { validateSandboxUsageLimits, getAvailableSyncTypes, } = require('./sandboxes');
 const { syncSandbox } = require('./sandboxSync');
-const {
-  validateDevTestAccountUsageLimits,
-} = require('./developerTestAccounts');
+const { validateDevTestAccountUsageLimits, } = require('./developerTestAccounts');
 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 { isAppDeveloperAccount, isDeveloperTestAccount, } = require('./accountTypes');
+const { handleProjectUpload, pollProjectBuildAndDeploy, } = require('./projects');
+const { PROJECT_ERROR_TYPES, PROJECT_BUILD_TEXT, PROJECT_DEPLOY_TEXT, } = require('./constants');
 const { logError, ApiErrorContext } = require('./errorHandlers/index');
-const {
-  PERSONAL_ACCESS_KEY_AUTH_METHOD,
-} = require('@hubspot/local-dev-lib/constants/auth');
+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';
-
 // 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,
-    HUBSPOT_ACCOUNT_TYPE_STRINGS[accountConfig.accountType]
-  );
-
-  if (!useDefaultAccount) {
-    logger.log(
-      i18n(
-        `${i18nKey}.confirmDefaultAccountIsTarget.declineDefaultAccountExplanation`,
-        {
-          useCommand: uiCommandReference('hs accounts use'),
-          devCommand: uiCommandReference('hs project dev'),
-        }
-      )
-    );
-    process.exit(EXIT_CODES.SUCCESS);
-  }
+const confirmDefaultAccountIsTarget = async (accountConfig) => {
+    logger.log();
+    const useDefaultAccount = await confirmDefaultAccountPrompt(accountConfig.name, HUBSPOT_ACCOUNT_TYPE_STRINGS[accountConfig.accountType]);
+    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 supported for the type of apps being developed
 const checkIfDefaultAccountIsSupported = (accountConfig, hasPublicApps) => {
-  if (
-    hasPublicApps &&
-    !(
-      isAppDeveloperAccount(accountConfig) ||
-      isDeveloperTestAccount(accountConfig)
-    )
-  ) {
-    logger.error(
-      i18n(`${i18nKey}.checkIfDefaultAccountIsSupported.publicApp`, {
-        useCommand: uiCommandReference('hs accounts use'),
-        authCommand: uiCommandReference('hs auth'),
-      })
-    );
-    process.exit(EXIT_CODES.SUCCESS);
-  } else if (!hasPublicApps && isAppDeveloperAccount(accountConfig)) {
-    logger.error(
-      i18n(`${i18nKey}.checkIfDefaultAccountIsSupported.privateApp`, {
-        useCommand: uiCommandReference('hs accounts use'),
-        authCommand: uiCommandReference('hs auth'),
-      })
-    );
-    process.exit(EXIT_CODES.SUCCESS);
-  }
+    if (hasPublicApps &&
+        !(isAppDeveloperAccount(accountConfig) ||
+            isDeveloperTestAccount(accountConfig))) {
+        logger.error(i18n(`${i18nKey}.checkIfDefaultAccountIsSupported.publicApp`, {
+            useCommand: uiCommandReference('hs accounts use'),
+            authCommand: uiCommandReference('hs auth'),
+        }));
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    else if (!hasPublicApps && isAppDeveloperAccount(accountConfig)) {
+        logger.error(i18n(`${i18nKey}.checkIfDefaultAccountIsSupported.privateApp`, {
+            useCommand: uiCommandReference('hs accounts use'),
+            authCommand: uiCommandReference('hs auth'),
+        }));
+        process.exit(EXIT_CODES.SUCCESS);
+    }
 };
-
 const checkIfParentAccountIsAuthed = accountConfig => {
-  if (!getAccountConfig(accountConfig.parentAccountId)) {
-    logger.error(
-      i18n(`${i18nKey}.checkIfParentAccountIsAuthed.notAuthedError`, {
-        accountId: accountConfig.parentAccountId,
-        accountIdentifier: uiAccountDescription(accountConfig.portalId),
-        authCommand: uiCommandReference(
-          `hs auth --account=${accountConfig.parentAccountId}`
-        ),
-      })
-    );
-    process.exit(EXIT_CODES.SUCCESS);
-  }
+    if (!getAccountConfig(accountConfig.parentAccountId)) {
+        logger.error(i18n(`${i18nKey}.checkIfParentAccountIsAuthed.notAuthedError`, {
+            accountId: accountConfig.parentAccountId,
+            accountIdentifier: uiAccountDescription(accountConfig.portalId),
+            authCommand: uiCommandReference(`hs auth --account=${accountConfig.parentAccountId}`),
+        }));
+        process.exit(EXIT_CODES.SUCCESS);
+    }
 };
-
 // Confirm the default account is a developer account if developing public apps
 const checkIfAccountFlagIsSupported = (accountConfig, hasPublicApps) => {
-  if (hasPublicApps) {
-    if (!isDeveloperTestAccount) {
-      logger.error(
-        i18n(`${i18nKey}.validateAccountOption.invalidPublicAppAccount`, {
-          useCommand: uiCommandReference('hs accounts use'),
-          devCommand: uiCommandReference('hs project dev'),
-        })
-      );
-      process.exit(EXIT_CODES.SUCCESS);
+    if (hasPublicApps) {
+        if (!isDeveloperTestAccount) {
+            logger.error(i18n(`${i18nKey}.validateAccountOption.invalidPublicAppAccount`, {
+                useCommand: uiCommandReference('hs accounts use'),
+                devCommand: uiCommandReference('hs project dev'),
+            }));
+            process.exit(EXIT_CODES.SUCCESS);
+        }
+        checkIfParentAccountIsAuthed(accountConfig);
+    }
+    else if (isAppDeveloperAccount(accountConfig)) {
+        logger.error(i18n(`${i18nKey}.validateAccountOption.invalidPrivateAppAccount`, {
+            useCommand: uiCommandReference('hs accounts use'),
+        }));
+        process.exit(EXIT_CODES.SUCCESS);
     }
-    checkIfParentAccountIsAuthed(accountConfig);
-  } else if (isAppDeveloperAccount(accountConfig)) {
-    logger.error(
-      i18n(`${i18nKey}.validateAccountOption.invalidPrivateAppAccount`, {
-        useCommand: uiCommandReference('hs accounts use'),
-      })
-    );
-    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.log(
-      i18n(
-        `${i18nKey}.validateAccountOption.publicAppNonDeveloperTestAccountWarning`
-      )
-    );
-  } else {
-    logger.log(i18n(`${i18nKey}.validateAccountOption.nonSandboxWarning`));
-  }
-  uiLine();
-  logger.log();
-
-  const targetAccountPrompt = isAppDeveloperAccount(accountConfig)
-    ? selectDeveloperTestTargetAccountPrompt
-    : selectSandboxTargetAccountPrompt;
-
-  return targetAccountPrompt(accounts, accountConfig, hasPublicApps);
+const suggestRecommendedNestedAccount = async (accounts, accountConfig, hasPublicApps) => {
+    logger.log();
+    uiLine();
+    if (hasPublicApps) {
+        logger.log(i18n(`${i18nKey}.validateAccountOption.publicAppNonDeveloperTestAccountWarning`));
+    }
+    else {
+        logger.log(i18n(`${i18nKey}.validateAccountOption.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('lib.sandbox.create.failure.scopes.message', {
-          accountName: accountConfig.name || accountId,
-        })
-      );
-      const websiteOrigin = getHubSpotWebsiteOrigin(env);
-      const url = `${websiteOrigin}/personal-access-key/${accountId}`;
-      logger.info(
-        i18n('lib.sandbox.create.failure.scopes.instructions', {
-          accountName: accountConfig.name || accountId,
-          url,
-        })
-      );
-    } else {
-      logError(err);
+    try {
+        await validateSandboxUsageLimits(accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, env);
+    }
+    catch (err) {
+        if (isMissingScopeError(err)) {
+            logger.error(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('lib.sandbox.create.failure.scopes.instructions', {
+                accountName: accountConfig.name || accountId,
+                url,
+            }));
+        }
+        else {
+            logError(err);
+        }
+        process.exit(EXIT_CODES.ERROR);
+    }
+    try {
+        const { name } = await hubspotAccountNamePrompt({
+            accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        });
+        trackCommandMetadataUsage('sandbox-create', { step: 'project-dev' }, accountId);
+        const { result } = await buildNewAccount({
+            name,
+            accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+            accountConfig,
+            env,
+        });
+        const targetAccountId = result.sandbox.sandboxHubId;
+        const sandboxAccountConfig = getAccountConfig(result.sandbox.sandboxHubId);
+        const syncTasks = await getAvailableSyncTypes(accountConfig, sandboxAccountConfig);
+        // For v1 sandboxes, keep sync here. Once we migrate to v2, this will be handled by BE automatically
+        await syncSandbox({
+            accountConfig: sandboxAccountConfig,
+            parentAccountConfig: accountConfig,
+            env,
+            syncTasks,
+            slimInfoMessage: true,
+        });
+        return targetAccountId;
+    }
+    catch (err) {
+        logError(err);
+        process.exit(EXIT_CODES.ERROR);
     }
-    process.exit(EXIT_CODES.ERROR);
-  }
-  try {
-    const { name } = await hubspotAccountNamePrompt({
-      accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-    });
-
-    trackCommandMetadataUsage(
-      'sandbox-create',
-      { step: 'project-dev' },
-      accountId
-    );
-
-    const { result } = await buildNewAccount({
-      name,
-      accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-      accountConfig,
-      env,
-    });
-
-    const targetAccountId = result.sandbox.sandboxHubId;
-
-    const sandboxAccountConfig = getAccountConfig(result.sandbox.sandboxHubId);
-    const syncTasks = await getAvailableSyncTypes(
-      accountConfig,
-      sandboxAccountConfig
-    );
-    // For v1 sandboxes, keep sync here. Once we migrate to v2, this will be handled by BE automatically
-    await syncSandbox({
-      accountConfig: sandboxAccountConfig,
-      parentAccountConfig: accountConfig,
-      env,
-      syncTasks,
-      slimInfoMessage: true,
-    });
-    return targetAccountId;
-  } catch (err) {
-    logError(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;
+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('lib.developerTestAccount.create.failure.scopes.message', {
-          accountName: accountConfig.name || accountId,
-        })
-      );
-      const websiteOrigin = getHubSpotWebsiteOrigin(env);
-      const url = `${websiteOrigin}/personal-access-key/${accountId}`;
-      logger.info(
-        i18n('lib.developerTestAccount.create.failure.scopes.instructions', {
-          accountName: accountConfig.name || accountId,
-          url,
-        })
-      );
-    } else {
-      logError(err);
+    catch (err) {
+        if (isMissingScopeError(err)) {
+            logger.error(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('lib.developerTestAccount.create.failure.scopes.instructions', {
+                accountName: accountConfig.name || accountId,
+                url,
+            }));
+        }
+        else {
+            logError(err);
+        }
+        process.exit(EXIT_CODES.ERROR);
+    }
+    try {
+        const { name } = await hubspotAccountNamePrompt({
+            currentPortalCount,
+            accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+        });
+        trackCommandMetadataUsage('developer-test-account-create', { step: 'project-dev' }, accountId);
+        const { result } = await buildNewAccount({
+            name,
+            accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+            accountConfig,
+            env,
+            portalLimit: maxTestPortals,
+        });
+        return result.id;
+    }
+    catch (err) {
+        logError(err);
+        process.exit(EXIT_CODES.ERROR);
     }
-    process.exit(EXIT_CODES.ERROR);
-  }
-
-  try {
-    const { name } = await hubspotAccountNamePrompt({
-      currentPortalCount,
-      accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
-    });
-    trackCommandMetadataUsage(
-      'developer-test-account-create',
-      { step: 'project-dev' },
-      accountId
-    );
-
-    const { result } = await buildNewAccount({
-      name,
-      accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
-      accountConfig,
-      env,
-      portalLimit: maxTestPortals,
-    });
-
-    return result.id;
-  } catch (err) {
-    logError(err);
-    process.exit(EXIT_CODES.ERROR);
-  }
 };
-
 // 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,
-    })
-  );
+    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,
-  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.log(explanationString);
-    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 {
-      const { data: project } = await createProject(
-        targetAccountId,
-        projectConfig.name
-      );
-      SpinniesManager.succeed('createProject', {
-        text: i18n(`${i18nKey}.createNewProjectForLocalDev.createdProject`, {
-          accountIdentifier: uiAccountDescription(targetAccountId),
-          projectName: projectConfig.name,
-        }),
-        succeedColor: 'white',
-      });
-      return project;
-    } catch (err) {
-      SpinniesManager.fail('createProject');
-      logger.log(
-        i18n(`${i18nKey}.createNewProjectForLocalDev.failedToCreateProject`)
-      );
-      process.exit(EXIT_CODES.ERROR);
+const createNewProjectForLocalDev = async (projectConfig, targetAccountId, 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.log(explanationString);
+        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 {
+            const { data: project } = await createProject(targetAccountId, projectConfig.name);
+            SpinniesManager.succeed('createProject', {
+                text: i18n(`${i18nKey}.createNewProjectForLocalDev.createdProject`, {
+                    accountIdentifier: uiAccountDescription(targetAccountId),
+                    projectName: projectConfig.name,
+                }),
+                succeedColor: 'white',
+            });
+            return project;
+        }
+        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);
     }
-  } 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 {
-      logError(
-        initialUploadResult.uploadError,
-        new ApiErrorContext({
-          accountId: targetAccountId,
-          projectName: projectConfig.name,
-        })
-      );
+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 {
+            logError(initialUploadResult.uploadError, new ApiErrorContext({
+                accountId: targetAccountId,
+                projectName: projectConfig.name,
+            }));
+        }
+        process.exit(EXIT_CODES.ERROR);
     }
-    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];
+    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 => {
+            logger.error(failedSubTask.errorMessage);
+        });
+        logger.log();
+        process.exit(EXIT_CODES.ERROR);
     }
-
-    const failedSubTasks = subTasks.filter(task => task.status === 'FAILURE');
-
-    logger.log();
-    failedSubTasks.forEach(failedSubTask => {
-      logger.error(failedSubTask.errorMessage);
-    });
-    logger.log();
-
-    process.exit(EXIT_CODES.ERROR);
-  }
-
-  return initialUploadResult.buildResult;
+    return initialUploadResult.buildResult;
 };
-
 const getAccountHomeUrl = accountId => {
-  const baseUrl = getHubSpotWebsiteOrigin(
-    getEnv(accountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD
-  );
-  return `${baseUrl}/home?portalId=${accountId}`;
+    const baseUrl = getHubSpotWebsiteOrigin(getEnv(accountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
+    return `${baseUrl}/home?portalId=${accountId}`;
 };
-
 module.exports = {
-  confirmDefaultAccountIsTarget,
-  checkIfDefaultAccountIsSupported,
-  checkIfAccountFlagIsSupported,
-  suggestRecommendedNestedAccount,
-  createSandboxForLocalDev,
-  createDeveloperTestAccountForLocalDev,
-  useExistingDevTestAccount,
-  createNewProjectForLocalDev,
-  createInitialBuildForNewProject,
-  getAccountHomeUrl,
-  checkIfParentAccountIsAuthed,
+    confirmDefaultAccountIsTarget,
+    checkIfDefaultAccountIsSupported,
+    checkIfAccountFlagIsSupported,
+    suggestRecommendedNestedAccount,
+    createSandboxForLocalDev,
+    createDeveloperTestAccountForLocalDev,
+    useExistingDevTestAccount,
+    createNewProjectForLocalDev,
+    createInitialBuildForNewProject,
+    getAccountHomeUrl,
+    checkIfParentAccountIsAuthed,
 };