@hubspot/cli 7.0.2-experimental.0 → 7.0.2

package/lib/localDev.js

@@ -1,161 +1,181 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-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 { 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 { confirmPrompt } = require('./prompts/promptUtils');
-const { validateSandboxUsageLimits, getAvailableSyncTypes, } = require('./sandboxes');
-const { syncSandbox } = require('./sandboxSync');
-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 } = require('./projects/upload');
-const { pollProjectBuildAndDeploy } = require('./projects/buildAndDeploy');
-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 { buildNewAccount, saveAccountToConfig } = require('./buildAccount');
-const { hubspotAccountNamePrompt } = require('./prompts/accountNamePrompt');
+exports.confirmDefaultAccountIsTarget = confirmDefaultAccountIsTarget;
+exports.checkIfDefaultAccountIsSupported = checkIfDefaultAccountIsSupported;
+exports.checkIfParentAccountIsAuthed = checkIfParentAccountIsAuthed;
+exports.checkIfAccountFlagIsSupported = checkIfAccountFlagIsSupported;
+exports.suggestRecommendedNestedAccount = suggestRecommendedNestedAccount;
+exports.createSandboxForLocalDev = createSandboxForLocalDev;
+exports.createDeveloperTestAccountForLocalDev = createDeveloperTestAccountForLocalDev;
+exports.useExistingDevTestAccount = useExistingDevTestAccount;
+exports.createNewProjectForLocalDev = createNewProjectForLocalDev;
+exports.createInitialBuildForNewProject = createInitialBuildForNewProject;
+exports.getAccountHomeUrl = getAccountHomeUrl;
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const config_1 = require("@hubspot/local-dev-lib/constants/config");
+const index_1 = require("@hubspot/local-dev-lib/errors/index");
+const urls_1 = require("@hubspot/local-dev-lib/urls");
+const config_2 = require("@hubspot/local-dev-lib/config");
+const projects_1 = require("@hubspot/local-dev-lib/api/projects");
+const environments_1 = require("@hubspot/local-dev-lib/constants/environments");
+const auth_1 = require("@hubspot/local-dev-lib/constants/auth");
+const getAccountIdentifier_1 = require("@hubspot/local-dev-lib/config/getAccountIdentifier");
+const projectDevTargetAccountPrompt_1 = require("./prompts/projectDevTargetAccountPrompt");
+const promptUtils_1 = require("./prompts/promptUtils");
+const sandboxes_1 = require("./sandboxes");
+const sandboxSync_1 = require("./sandboxSync");
+const developerTestAccounts_1 = require("./developerTestAccounts");
+const ui_1 = require("./ui");
+const SpinniesManager_1 = __importDefault(require("./ui/SpinniesManager"));
+const lang_1 = require("./lang");
+const exitCodes_1 = require("./enums/exitCodes");
+const usageTracking_1 = require("./usageTracking");
+const accountTypes_1 = require("./accountTypes");
+const upload_1 = require("./projects/upload");
+const buildAndDeploy_1 = require("./projects/buildAndDeploy");
+const constants_1 = require("./constants");
+const index_2 = require("./errorHandlers/index");
+const buildAccount_1 = require("./buildAccount");
+const accountNamePrompt_1 = 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]);
+async function confirmDefaultAccountIsTarget(accountConfig) {
+    if (!accountConfig.name || !accountConfig.accountType) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.confirmDefaultAccountIsTarget.configError`, {
+            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
+        }));
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    logger_1.logger.log();
+    const useDefaultAccount = await (0, projectDevTargetAccountPrompt_1.confirmDefaultAccountPrompt)(accountConfig.name, config_1.HUBSPOT_ACCOUNT_TYPE_STRINGS[accountConfig.accountType]);
     if (!useDefaultAccount) {
-        logger.log(i18n(`${i18nKey}.confirmDefaultAccountIsTarget.declineDefaultAccountExplanation`, {
-            useCommand: uiCommandReference('hs accounts use'),
-            devCommand: uiCommandReference('hs project dev'),
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.confirmDefaultAccountIsTarget.declineDefaultAccountExplanation`, {
+            useCommand: (0, ui_1.uiCommandReference)('hs accounts use'),
+            devCommand: (0, ui_1.uiCommandReference)('hs project dev'),
         }));
-        process.exit(EXIT_CODES.SUCCESS);
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
-};
+}
 // Confirm the default account is supported for the type of apps being developed
-const checkIfDefaultAccountIsSupported = (accountConfig, hasPublicApps) => {
+function checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps) {
     if (hasPublicApps &&
-        !(isAppDeveloperAccount(accountConfig) ||
-            isDeveloperTestAccount(accountConfig))) {
-        logger.error(i18n(`${i18nKey}.checkIfDefaultAccountIsSupported.publicApp`, {
-            useCommand: uiCommandReference('hs accounts use'),
-            authCommand: uiCommandReference('hs auth'),
+        !((0, accountTypes_1.isAppDeveloperAccount)(accountConfig) ||
+            (0, accountTypes_1.isDeveloperTestAccount)(accountConfig))) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.checkIfDefaultAccountIsSupported.publicApp`, {
+            useCommand: (0, ui_1.uiCommandReference)('hs accounts use'),
+            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
         }));
-        process.exit(EXIT_CODES.SUCCESS);
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
-    else if (!hasPublicApps && isAppDeveloperAccount(accountConfig)) {
-        logger.error(i18n(`${i18nKey}.checkIfDefaultAccountIsSupported.privateApp`, {
-            useCommand: uiCommandReference('hs accounts use'),
-            authCommand: uiCommandReference('hs auth'),
+    else if (!hasPublicApps && (0, accountTypes_1.isAppDeveloperAccount)(accountConfig)) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.checkIfDefaultAccountIsSupported.privateApp`, {
+            useCommand: (0, ui_1.uiCommandReference)('hs accounts use'),
+            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
         }));
-        process.exit(EXIT_CODES.SUCCESS);
+        process.exit(exitCodes_1.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}`),
+}
+function checkIfParentAccountIsAuthed(accountConfig) {
+    if (!accountConfig.parentAccountId ||
+        !(0, config_2.getAccountConfig)(accountConfig.parentAccountId)) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.checkIfParentAccountIsAuthed.notAuthedError`, {
+            accountId: accountConfig.parentAccountId || '',
+            accountIdentifier: (0, ui_1.uiAccountDescription)((0, getAccountIdentifier_1.getAccountIdentifier)(accountConfig)),
+            authCommand: (0, ui_1.uiCommandReference)(`hs auth --account=${accountConfig.parentAccountId}`),
         }));
-        process.exit(EXIT_CODES.SUCCESS);
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
-};
+}
 // Confirm the default account is a developer account if developing public apps
-const checkIfAccountFlagIsSupported = (accountConfig, hasPublicApps) => {
+function checkIfAccountFlagIsSupported(accountConfig, hasPublicApps) {
     if (hasPublicApps) {
-        if (!isDeveloperTestAccount(accountConfig)) {
-            logger.error(i18n(`${i18nKey}.validateAccountOption.invalidPublicAppAccount`, {
-                useCommand: uiCommandReference('hs accounts use'),
-                devCommand: uiCommandReference('hs project dev'),
+        if (!(0, accountTypes_1.isDeveloperTestAccount)(accountConfig)) {
+            logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.validateAccountOption.invalidPublicAppAccount`, {
+                useCommand: (0, ui_1.uiCommandReference)('hs accounts use'),
+                devCommand: (0, ui_1.uiCommandReference)('hs project dev'),
             }));
-            process.exit(EXIT_CODES.SUCCESS);
+            process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
         }
         checkIfParentAccountIsAuthed(accountConfig);
     }
-    else if (isAppDeveloperAccount(accountConfig)) {
-        logger.error(i18n(`${i18nKey}.validateAccountOption.invalidPrivateAppAccount`, {
-            useCommand: uiCommandReference('hs accounts use'),
+    else if ((0, accountTypes_1.isAppDeveloperAccount)(accountConfig)) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.validateAccountOption.invalidPrivateAppAccount`, {
+            useCommand: (0, ui_1.uiCommandReference)('hs accounts use'),
         }));
-        process.exit(EXIT_CODES.SUCCESS);
+        process.exit(exitCodes_1.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();
+async function suggestRecommendedNestedAccount(accounts, accountConfig, hasPublicApps) {
+    logger_1.logger.log();
+    (0, ui_1.uiLine)();
     if (hasPublicApps) {
-        logger.log(i18n(`${i18nKey}.validateAccountOption.publicAppNonDeveloperTestAccountWarning`));
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validateAccountOption.publicAppNonDeveloperTestAccountWarning`));
     }
     else {
-        logger.log(i18n(`${i18nKey}.validateAccountOption.nonSandboxWarning`));
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validateAccountOption.nonSandboxWarning`));
     }
-    uiLine();
-    logger.log();
-    const targetAccountPrompt = isAppDeveloperAccount(accountConfig)
-        ? selectDeveloperTestTargetAccountPrompt
-        : selectSandboxTargetAccountPrompt;
-    return targetAccountPrompt(accounts, accountConfig, hasPublicApps);
-};
+    (0, ui_1.uiLine)();
+    logger_1.logger.log();
+    const targetAccountPrompt = (0, accountTypes_1.isAppDeveloperAccount)(accountConfig)
+        ? projectDevTargetAccountPrompt_1.selectDeveloperTestTargetAccountPrompt
+        : projectDevTargetAccountPrompt_1.selectSandboxTargetAccountPrompt;
+    return targetAccountPrompt(accounts, accountConfig);
+}
 // Create a new sandbox and return its accountId
-const createSandboxForLocalDev = async (accountId, accountConfig, env) => {
+async function createSandboxForLocalDev(accountId, accountConfig, env) {
     try {
-        await validateSandboxUsageLimits(accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, env);
+        await (0, sandboxes_1.validateSandboxUsageLimits)(accountConfig, config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, env);
     }
     catch (err) {
-        if (isMissingScopeError(err)) {
-            logger.error(i18n('lib.sandbox.create.failure.scopes.message', {
+        if ((0, index_1.isMissingScopeError)(err)) {
+            logger_1.logger.error((0, lang_1.i18n)('lib.sandbox.create.failure.scopes.message', {
                 accountName: accountConfig.name || accountId,
             }));
-            const websiteOrigin = getHubSpotWebsiteOrigin(env);
+            const websiteOrigin = (0, urls_1.getHubSpotWebsiteOrigin)(env);
             const url = `${websiteOrigin}/personal-access-key/${accountId}`;
-            logger.info(i18n('lib.sandbox.create.failure.scopes.instructions', {
+            logger_1.logger.info((0, lang_1.i18n)('lib.sandbox.create.failure.scopes.instructions', {
                 accountName: accountConfig.name || accountId,
                 url,
             }));
         }
         else {
-            logError(err);
+            (0, index_2.logError)(err);
         }
-        process.exit(EXIT_CODES.ERROR);
+        process.exit(exitCodes_1.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 { name } = await (0, accountNamePrompt_1.hubspotAccountNamePrompt)({
+            accountType: config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
         });
+        (0, usageTracking_1.trackCommandMetadataUsage)('sandbox-create', { step: 'project-dev' }, accountId);
+        const result = await (0, buildAccount_1.buildSandbox)(name, accountConfig, config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, env);
         const targetAccountId = result.sandbox.sandboxHubId;
-        const sandboxAccountConfig = getAccountConfig(result.sandbox.sandboxHubId);
-        const syncTasks = await getAvailableSyncTypes(accountConfig, sandboxAccountConfig);
+        const sandboxAccountConfig = (0, config_2.getAccountConfig)(result.sandbox.sandboxHubId);
+        if (!sandboxAccountConfig) {
+            logger_1.logger.error((0, lang_1.i18n)('lib.sandbox.create.failure.generic'));
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+        const syncTasks = await (0, sandboxes_1.getAvailableSyncTypes)(accountConfig, sandboxAccountConfig);
         // For v1 sandboxes, keep sync here. Once we migrate to v2, this will be handled by BE automatically
-        await syncSandbox(sandboxAccountConfig, accountConfig, env, syncTasks, true);
+        await (0, sandboxSync_1.syncSandbox)(sandboxAccountConfig, accountConfig, env, syncTasks, true);
         return targetAccountId;
     }
     catch (err) {
-        logError(err);
-        process.exit(EXIT_CODES.ERROR);
+        (0, index_2.logError)(err);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
-};
+}
 // Create a developer test account and return its accountId
-const createDeveloperTestAccountForLocalDev = async (accountId, accountConfig, env) => {
+async function createDeveloperTestAccountForLocalDev(accountId, accountConfig, env) {
     let currentPortalCount = 0;
     let maxTestPortals = 10;
     try {
-        const validateResult = await validateDevTestAccountUsageLimits(accountConfig);
+        const validateResult = await (0, developerTestAccounts_1.validateDevTestAccountUsageLimits)(accountConfig);
         if (validateResult) {
             currentPortalCount = validateResult.results
                 ? validateResult.results.length
@@ -164,96 +184,86 @@ const createDeveloperTestAccountForLocalDev = async (accountId, accountConfig, e
         }
     }
     catch (err) {
-        if (isMissingScopeError(err)) {
-            logger.error(i18n('lib.developerTestAccount.create.failure.scopes.message', {
+        if ((0, index_1.isMissingScopeError)(err)) {
+            logger_1.logger.error((0, lang_1.i18n)('lib.developerTestAccount.create.failure.scopes.message', {
                 accountName: accountConfig.name || accountId,
             }));
-            const websiteOrigin = getHubSpotWebsiteOrigin(env);
+            const websiteOrigin = (0, urls_1.getHubSpotWebsiteOrigin)(env);
             const url = `${websiteOrigin}/personal-access-key/${accountId}`;
-            logger.info(i18n('lib.developerTestAccount.create.failure.scopes.instructions', {
+            logger_1.logger.info((0, lang_1.i18n)('lib.developerTestAccount.create.failure.scopes.instructions', {
                 accountName: accountConfig.name || accountId,
                 url,
             }));
         }
         else {
-            logError(err);
+            (0, index_2.logError)(err);
         }
-        process.exit(EXIT_CODES.ERROR);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
     try {
-        const { name } = await hubspotAccountNamePrompt({
+        const { name } = await (0, accountNamePrompt_1.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,
+            accountType: config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
         });
+        (0, usageTracking_1.trackCommandMetadataUsage)('developer-test-account-create', { step: 'project-dev' }, accountId);
+        const result = await (0, buildAccount_1.buildDeveloperTestAccount)(name, accountConfig, env, maxTestPortals);
         return result.id;
     }
     catch (err) {
-        logError(err);
-        process.exit(EXIT_CODES.ERROR);
+        (0, index_2.logError)(err);
+        process.exit(exitCodes_1.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);
+async function useExistingDevTestAccount(env, account) {
+    const useExistingDevTestAcct = await (0, projectDevTargetAccountPrompt_1.confirmUseExistingDeveloperTestAccountPrompt)(account);
     if (!useExistingDevTestAcct) {
-        logger.log('');
-        logger.log(i18n(`${i18nKey}.confirmDefaultAccountIsTarget.declineDefaultAccountExplanation`, {
-            useCommand: uiCommandReference('hs accounts use'),
-            devCommand: uiCommandReference('hs project dev'),
+        logger_1.logger.log('');
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.confirmDefaultAccountIsTarget.declineDefaultAccountExplanation`, {
+            useCommand: (0, ui_1.uiCommandReference)('hs accounts use'),
+            devCommand: (0, ui_1.uiCommandReference)('hs project dev'),
         }));
-        logger.log('');
-        process.exit(EXIT_CODES.SUCCESS);
+        logger_1.logger.log('');
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
-    const devTestAcctConfigName = await saveAccountToConfig({
-        env,
-        accountName: account.accountName,
-        accountId: account.id,
-    });
-    logger.success(i18n(`lib.developerTestAccount.create.success.configFileUpdated`, {
+    const devTestAcctConfigName = await (0, buildAccount_1.saveAccountToConfig)(account.id, account.accountName, env);
+    logger_1.logger.success((0, lang_1.i18n)(`lib.developerTestAccount.create.success.configFileUpdated`, {
         accountName: devTestAcctConfigName,
-        authType: PERSONAL_ACCESS_KEY_AUTH_METHOD.name,
+        authType: auth_1.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) => {
+async function createNewProjectForLocalDev(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
+        const explanationString = (0, lang_1.i18n)(hasPublicApps
             ? `${i18nKey}.createNewProjectForLocalDev.publicAppProjectMustExistExplanation`
             : `${i18nKey}.createNewProjectForLocalDev.projectMustExistExplanation`, {
-            accountIdentifier: uiAccountDescription(targetAccountId),
+            accountIdentifier: (0, ui_1.uiAccountDescription)(targetAccountId),
             projectName: projectConfig.name,
         });
-        logger.log();
-        uiLine();
-        logger.log(explanationString);
-        uiLine();
-        shouldCreateProject = await confirmPrompt(i18n(`${i18nKey}.createNewProjectForLocalDev.createProject`, {
-            accountIdentifier: uiAccountDescription(targetAccountId),
+        logger_1.logger.log();
+        (0, ui_1.uiLine)();
+        logger_1.logger.log(explanationString);
+        (0, ui_1.uiLine)();
+        shouldCreateProject = await (0, promptUtils_1.confirmPrompt)((0, lang_1.i18n)(`${i18nKey}.createNewProjectForLocalDev.createProject`, {
+            accountIdentifier: (0, ui_1.uiAccountDescription)(targetAccountId),
             projectName: projectConfig.name,
         }));
     }
     if (shouldCreateProject) {
-        SpinniesManager.add('createProject', {
-            text: i18n(`${i18nKey}.createNewProjectForLocalDev.creatingProject`, {
-                accountIdentifier: uiAccountDescription(targetAccountId),
+        SpinniesManager_1.default.add('createProject', {
+            text: (0, lang_1.i18n)(`${i18nKey}.createNewProjectForLocalDev.creatingProject`, {
+                accountIdentifier: (0, ui_1.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),
+            const { data: project } = await (0, projects_1.createProject)(targetAccountId, projectConfig.name);
+            SpinniesManager_1.default.succeed('createProject', {
+                text: (0, lang_1.i18n)(`${i18nKey}.createNewProjectForLocalDev.createdProject`, {
+                    accountIdentifier: (0, ui_1.uiAccountDescription)(targetAccountId),
                     projectName: projectConfig.name,
                 }),
                 succeedColor: 'white',
@@ -261,72 +271,68 @@ const createNewProjectForLocalDev = async (projectConfig, targetAccountId, shoul
             return project;
         }
         catch (err) {
-            SpinniesManager.fail('createProject');
-            logger.log(i18n(`${i18nKey}.createNewProjectForLocalDev.failedToCreateProject`));
-            process.exit(EXIT_CODES.ERROR);
+            SpinniesManager_1.default.fail('createProject');
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createNewProjectForLocalDev.failedToCreateProject`));
+            process.exit(exitCodes_1.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);
+        logger_1.logger.log();
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createNewProjectForLocalDev.choseNotToCreateProject`));
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
-};
+}
+function projectUploadCallback(accountId, projectConfig, tempFile, buildId) {
+    if (!buildId) {
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.createInitialBuildForNewProject.initialUploadMessage`, {
+            uploadCommand: (0, ui_1.uiCommandReference)('hs project upload'),
+        }));
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    return (0, buildAndDeploy_1.pollProjectBuildAndDeploy)(accountId, projectConfig, tempFile, buildId, true);
+}
 // 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,
+async function createInitialBuildForNewProject(projectConfig, projectDir, targetAccountId) {
+    const { result: initialUploadResult, uploadError } = await (0, upload_1.handleProjectUpload)(targetAccountId, projectConfig, projectDir, projectUploadCallback, (0, lang_1.i18n)(`${i18nKey}.createInitialBuildForNewProject.initialUploadMessage`));
+    if (uploadError) {
+        if ((0, index_1.isSpecifiedError)(uploadError, {
+            subCategory: constants_1.PROJECT_ERROR_TYPES.PROJECT_LOCKED,
         })) {
-            logger.log();
-            logger.error(i18n(`${i18nKey}.createInitialBuildForNewProject.projectLockedError`));
-            logger.log();
+            logger_1.logger.log();
+            logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.createInitialBuildForNewProject.projectLockedError`));
+            logger_1.logger.log();
         }
         else {
-            logError(initialUploadResult.uploadError, new ApiErrorContext({
+            (0, index_2.logError)(uploadError, new index_2.ApiErrorContext({
                 accountId: targetAccountId,
                 projectName: projectConfig.name,
             }));
         }
-        process.exit(EXIT_CODES.ERROR);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
-    if (!initialUploadResult.succeeded) {
+    if (!initialUploadResult?.succeeded) {
         let subTasks = [];
-        if (initialUploadResult.buildResult.status === 'FAILURE') {
+        if (initialUploadResult?.buildResult.status === 'FAILURE') {
             subTasks =
-                initialUploadResult.buildResult[PROJECT_BUILD_TEXT.SUBTASK_KEY];
+                initialUploadResult.buildResult[constants_1.PROJECT_BUILD_TEXT.SUBTASK_KEY];
         }
-        else if (initialUploadResult.deployResult.status === 'FAILURE') {
+        else if (initialUploadResult?.deployResult?.status === 'FAILURE') {
             subTasks =
-                initialUploadResult.deployResult[PROJECT_DEPLOY_TEXT.SUBTASK_KEY];
+                initialUploadResult.deployResult[constants_1.PROJECT_DEPLOY_TEXT.SUBTASK_KEY];
         }
         const failedSubTasks = subTasks.filter(task => task.status === 'FAILURE');
-        logger.log();
+        logger_1.logger.log();
         failedSubTasks.forEach(failedSubTask => {
-            logger.error(failedSubTask.errorMessage);
+            logger_1.logger.error(failedSubTask.errorMessage);
         });
-        logger.log();
-        process.exit(EXIT_CODES.ERROR);
+        logger_1.logger.log();
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
     return initialUploadResult.buildResult;
-};
-const getAccountHomeUrl = accountId => {
-    const baseUrl = getHubSpotWebsiteOrigin(getEnv(accountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
+}
+function getAccountHomeUrl(accountId) {
+    const baseUrl = (0, urls_1.getHubSpotWebsiteOrigin)((0, config_2.getEnv)(accountId) === 'qa' ? environments_1.ENVIRONMENTS.QA : environments_1.ENVIRONMENTS.PROD);
     return `${baseUrl}/home?portalId=${accountId}`;
-};
-module.exports = {
-    confirmDefaultAccountIsTarget,
-    checkIfDefaultAccountIsSupported,
-    checkIfAccountFlagIsSupported,
-    suggestRecommendedNestedAccount,
-    createSandboxForLocalDev,
-    createDeveloperTestAccountForLocalDev,
-    useExistingDevTestAccount,
-    createNewProjectForLocalDev,
-    createInitialBuildForNewProject,
-    getAccountHomeUrl,
-    checkIfParentAccountIsAuthed,
-};
+}

package/lib/polling.d.ts

@@ -1,9 +1,17 @@
 import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
-import { ValueOf } from '@hubspot/local-dev-lib/types/Utils';
-import { POLLING_STATUS } from './constants';
+export declare const DEFAULT_POLLING_STATES: {
+    readonly STARTED: "STARTED";
+    readonly SUCCESS: "SUCCESS";
+    readonly ERROR: "ERROR";
+    readonly REVERTED: "REVERTED";
+    readonly FAILURE: "FAILURE";
+};
 type GenericPollingResponse = {
-    status: ValueOf<typeof POLLING_STATUS>;
+    status: string;
 };
-type PollingCallback<T extends GenericPollingResponse> = (accountId: number, taskId: number | string) => HubSpotPromise<T>;
-export declare function poll<T extends GenericPollingResponse>(callback: PollingCallback<T>, accountId: number, taskId: number | string): Promise<T>;
+type PollingCallback<T extends GenericPollingResponse> = () => HubSpotPromise<T>;
+export declare function poll<T extends GenericPollingResponse>(callback: PollingCallback<T>, statusLookup?: {
+    successStates: string[];
+    errorStates: string[];
+}): Promise<T>;
 export {};

package/lib/polling.js

@@ -1,20 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_POLLING_STATES = void 0;
 exports.poll = poll;
 const constants_1 = require("./constants");
-function poll(callback, accountId, taskId) {
+exports.DEFAULT_POLLING_STATES = {
+    STARTED: 'STARTED',
+    SUCCESS: 'SUCCESS',
+    ERROR: 'ERROR',
+    REVERTED: 'REVERTED',
+    FAILURE: 'FAILURE',
+};
+const DEFAULT_POLLING_STATUS_LOOKUP = {
+    successStates: [exports.DEFAULT_POLLING_STATES.SUCCESS],
+    errorStates: [
+        exports.DEFAULT_POLLING_STATES.ERROR,
+        exports.DEFAULT_POLLING_STATES.REVERTED,
+        exports.DEFAULT_POLLING_STATES.FAILURE,
+    ],
+};
+function poll(callback, statusLookup = DEFAULT_POLLING_STATUS_LOOKUP) {
     return new Promise((resolve, reject) => {
         const pollInterval = setInterval(async () => {
             try {
-                const { data: pollResp } = await callback(accountId, taskId);
+                const { data: pollResp } = await callback();
                 const { status } = pollResp;
-                if (status === constants_1.POLLING_STATUS.SUCCESS) {
+                if (statusLookup.successStates.includes(status)) {
                     clearInterval(pollInterval);
                     resolve(pollResp);
                 }
-                else if (status === constants_1.POLLING_STATUS.ERROR ||
-                    status === constants_1.POLLING_STATUS.REVERTED ||
-                    status === constants_1.POLLING_STATUS.FAILURE) {
+                else if (statusLookup.errorStates.includes(status)) {
                     clearInterval(pollInterval);
                     reject(pollResp);
                 }
@@ -23,6 +37,6 @@ function poll(callback, accountId, taskId) {
                 clearInterval(pollInterval);
                 reject(error);
             }
-        }, constants_1.POLLING_DELAY);
+        }, constants_1.DEFAULT_POLLING_DELAY);
     });
 }

package/lib/projects/buildAndDeploy.d.ts

@@ -1,16 +1,10 @@
 import { FileResult } from 'tmp';
 import { Build } from '@hubspot/local-dev-lib/types/Build';
 import { Deploy } from '@hubspot/local-dev-lib/types/Deploy';
-import { ProjectConfig, ProjectTask } from '../../types/Projects';
+import { ProjectConfig, ProjectTask, ProjectPollResult } from '../../types/Projects';
 type PollTaskStatusFunction<T extends ProjectTask> = (accountId: number, taskName: string, taskId: number, deployedBuildId: number | null, silenceLogs: boolean) => Promise<T>;
 export declare const pollBuildStatus: PollTaskStatusFunction<Build>;
 export declare const pollDeployStatus: PollTaskStatusFunction<Deploy>;
-type ProjectPollResult = {
-    succeeded: boolean;
-    buildId: number;
-    buildResult: Build;
-    deployResult: Deploy | null;
-};
 export declare function displayWarnLogs(accountId: number, projectName: string, taskId: number, isDeploy?: boolean): Promise<void>;
 export declare function pollProjectBuildAndDeploy(accountId: number, projectConfig: ProjectConfig, tempFile: FileResult, buildId: number, silenceLogs?: boolean): Promise<ProjectPollResult>;
 export {};