@hubspot/cli 7.7.21-experimental.0 → 7.7.21-experimental.1

package/lib/projects/localDev/helpers.js

@@ -1,144 +1,162 @@
-import { HUBSPOT_ACCOUNT_TYPES, HUBSPOT_ACCOUNT_TYPE_STRINGS, } from '@hubspot/local-dev-lib/constants/config';
-import { isMissingScopeError, isSpecifiedError, } from '@hubspot/local-dev-lib/errors/index';
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { getAccountConfig, getEnv } from '@hubspot/local-dev-lib/config';
-import { createProject } from '@hubspot/local-dev-lib/api/projects';
-import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
-import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
-import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
-import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
-import { confirmDefaultAccountPrompt, selectSandboxTargetAccountPrompt, selectDeveloperTestTargetAccountPrompt, confirmUseExistingDeveloperTestAccountPrompt, } from '../../prompts/projectDevTargetAccountPrompt.js';
-import { confirmPrompt, listPrompt } from '../../prompts/promptUtils.js';
-import { validateSandboxUsageLimits, getAvailableSyncTypes, } from '../../sandboxes.js';
-import { syncSandbox } from '../../sandboxSync.js';
-import { validateDevTestAccountUsageLimits } from '../../developerTestAccounts.js';
-import { uiLine, uiAccountDescription } from '../../ui/index.js';
-import SpinniesManager from '../../ui/SpinniesManager.js';
-import { EXIT_CODES } from '../../enums/exitCodes.js';
-import { trackCommandMetadataUsage } from '../../usageTracking.js';
-import { isAppDeveloperAccount, isDeveloperTestAccount, isUnifiedAccount, } from '../../accountTypes.js';
-import { handleProjectUpload } from '../../projects/upload.js';
-import { pollProjectBuildAndDeploy } from '../../projects/buildAndDeploy.js';
-import { PROJECT_ERROR_TYPES, PROJECT_BUILD_TEXT, PROJECT_DEPLOY_TEXT, } from '../../constants.js';
-import { logError, ApiErrorContext, debugError, } from '../../errorHandlers/index.js';
-import { buildSandbox, buildDeveloperTestAccount, saveAccountToConfig, } from '../../buildAccount.js';
-import { hubspotAccountNamePrompt } from '../../prompts/accountNamePrompt.js';
-import { lib } from '../../../lang/en.js';
-import { uiLogger } from '../../ui/logger.js';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+exports.hasSandboxes = hasSandboxes;
+exports.selectAccountTypePrompt = selectAccountTypePrompt;
+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 sandboxHubs_1 = require("@hubspot/local-dev-lib/api/sandboxHubs");
+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 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 en_1 = require("../../../lang/en");
+const logger_1 = require("../../ui/logger");
 // If the user passed in the --account flag, confirm they want to use that account as
 // their target account, otherwise exit
-export async function confirmDefaultAccountIsTarget(accountConfig) {
+async function confirmDefaultAccountIsTarget(accountConfig) {
     if (!accountConfig.name || !accountConfig.accountType) {
-        uiLogger.error(lib.localDevHelpers.confirmDefaultAccountIsTarget.configError);
-        process.exit(EXIT_CODES.ERROR);
+        logger_1.uiLogger.error(en_1.lib.localDevHelpers.confirmDefaultAccountIsTarget.configError);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
-    uiLogger.log('');
-    const useDefaultAccount = await confirmDefaultAccountPrompt(accountConfig.name, HUBSPOT_ACCOUNT_TYPE_STRINGS[accountConfig.accountType]);
+    logger_1.uiLogger.log('');
+    const useDefaultAccount = await (0, projectDevTargetAccountPrompt_1.confirmDefaultAccountPrompt)(accountConfig.name, config_1.HUBSPOT_ACCOUNT_TYPE_STRINGS[accountConfig.accountType]);
     if (!useDefaultAccount) {
-        uiLogger.log(lib.localDevHelpers.confirmDefaultAccountIsTarget
+        logger_1.uiLogger.log(en_1.lib.localDevHelpers.confirmDefaultAccountIsTarget
             .declineDefaultAccountExplanation);
-        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
-export async function checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps) {
-    const defaultAccountIsUnified = await isUnifiedAccount(accountConfig);
+async function checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps) {
+    const defaultAccountIsUnified = await (0, accountTypes_1.isUnifiedAccount)(accountConfig);
     if (hasPublicApps &&
-        !(isAppDeveloperAccount(accountConfig) ||
-            isDeveloperTestAccount(accountConfig) ||
+        !((0, accountTypes_1.isAppDeveloperAccount)(accountConfig) ||
+            (0, accountTypes_1.isDeveloperTestAccount)(accountConfig) ||
             defaultAccountIsUnified)) {
-        uiLogger.error(lib.localDevHelpers.checkIfDefaultAccountIsSupported.publicApp);
-        process.exit(EXIT_CODES.SUCCESS);
+        logger_1.uiLogger.error(en_1.lib.localDevHelpers.checkIfDefaultAccountIsSupported.publicApp);
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
-    else if (!hasPublicApps && isAppDeveloperAccount(accountConfig)) {
-        uiLogger.error(lib.localDevHelpers.checkIfDefaultAccountIsSupported.privateApp);
-        process.exit(EXIT_CODES.SUCCESS);
+    else if (!hasPublicApps && (0, accountTypes_1.isAppDeveloperAccount)(accountConfig)) {
+        logger_1.uiLogger.error(en_1.lib.localDevHelpers.checkIfDefaultAccountIsSupported.privateApp);
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
 }
-export function checkIfParentAccountIsAuthed(accountConfig) {
+function checkIfParentAccountIsAuthed(accountConfig) {
     if (!accountConfig.parentAccountId ||
-        !getAccountConfig(accountConfig.parentAccountId)) {
-        uiLogger.error(lib.localDevHelpers.checkIfParentAccountIsAuthed.notAuthedError(accountConfig.parentAccountId || '', uiAccountDescription(getAccountIdentifier(accountConfig))));
-        process.exit(EXIT_CODES.SUCCESS);
+        !(0, config_2.getAccountConfig)(accountConfig.parentAccountId)) {
+        logger_1.uiLogger.error(en_1.lib.localDevHelpers.checkIfParentAccountIsAuthed.notAuthedError(accountConfig.parentAccountId || '', (0, ui_1.uiAccountDescription)((0, getAccountIdentifier_1.getAccountIdentifier)(accountConfig))));
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
 }
 // Confirm the default account is a developer account if developing public apps
-export function checkIfAccountFlagIsSupported(accountConfig, hasPublicApps) {
+function checkIfAccountFlagIsSupported(accountConfig, hasPublicApps) {
     if (hasPublicApps) {
-        if (!isDeveloperTestAccount(accountConfig)) {
-            uiLogger.error(lib.localDevHelpers.validateAccountOption.invalidPublicAppAccount);
-            process.exit(EXIT_CODES.SUCCESS);
+        if (!(0, accountTypes_1.isDeveloperTestAccount)(accountConfig)) {
+            logger_1.uiLogger.error(en_1.lib.localDevHelpers.validateAccountOption.invalidPublicAppAccount);
+            process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
         }
         checkIfParentAccountIsAuthed(accountConfig);
     }
-    else if (isAppDeveloperAccount(accountConfig)) {
-        uiLogger.error(lib.localDevHelpers.validateAccountOption.invalidPrivateAppAccount);
-        process.exit(EXIT_CODES.SUCCESS);
+    else if ((0, accountTypes_1.isAppDeveloperAccount)(accountConfig)) {
+        logger_1.uiLogger.error(en_1.lib.localDevHelpers.validateAccountOption.invalidPrivateAppAccount);
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
 }
 // If the user isn't using the recommended account type, prompt them to use or create one
-export async function suggestRecommendedNestedAccount(accounts, accountConfig, hasPublicApps) {
-    uiLogger.log('');
-    uiLine();
+async function suggestRecommendedNestedAccount(accounts, accountConfig, hasPublicApps) {
+    logger_1.uiLogger.log('');
+    (0, ui_1.uiLine)();
     if (hasPublicApps) {
-        uiLogger.log(lib.localDevHelpers.validateAccountOption
+        logger_1.uiLogger.log(en_1.lib.localDevHelpers.validateAccountOption
             .publicAppNonDeveloperTestAccountWarning);
     }
     else {
-        uiLogger.log(lib.localDevHelpers.validateAccountOption.nonSandboxWarning);
+        logger_1.uiLogger.log(en_1.lib.localDevHelpers.validateAccountOption.nonSandboxWarning);
     }
-    uiLine();
-    uiLogger.log('');
+    (0, ui_1.uiLine)();
+    logger_1.uiLogger.log('');
     const targetAccountPrompt = hasPublicApps
-        ? selectDeveloperTestTargetAccountPrompt
-        : selectSandboxTargetAccountPrompt;
+        ? projectDevTargetAccountPrompt_1.selectDeveloperTestTargetAccountPrompt
+        : projectDevTargetAccountPrompt_1.selectSandboxTargetAccountPrompt;
     return targetAccountPrompt(accounts, accountConfig);
 }
 // Create a new sandbox and return its accountId
-export async function createSandboxForLocalDev(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)) {
-            uiLogger.error(lib.sandbox.create.developer.failure.scopes.message);
-            const websiteOrigin = getHubSpotWebsiteOrigin(env);
+        if ((0, index_1.isMissingScopeError)(err)) {
+            logger_1.uiLogger.error(en_1.lib.sandbox.create.developer.failure.scopes.message);
+            const websiteOrigin = (0, urls_1.getHubSpotWebsiteOrigin)(env);
             const url = `${websiteOrigin}/personal-access-key/${accountId}`;
-            uiLogger.info(lib.sandbox.create.developer.failure.scopes.instructions(accountConfig.name || accountId, url));
+            logger_1.uiLogger.info(en_1.lib.sandbox.create.developer.failure.scopes.instructions(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,
+        const { name } = await (0, accountNamePrompt_1.hubspotAccountNamePrompt)({
+            accountType: config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
         });
-        trackCommandMetadataUsage('sandbox-create', { step: 'project-dev' }, accountId);
-        const result = await buildSandbox(name, accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, env);
+        (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 sandboxAccountConfig = (0, config_2.getAccountConfig)(result.sandbox.sandboxHubId);
         if (!sandboxAccountConfig) {
-            uiLogger.error(lib.sandbox.create.developer.failure.generic);
-            process.exit(EXIT_CODES.ERROR);
+            logger_1.uiLogger.error(en_1.lib.sandbox.create.developer.failure.generic);
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
         }
-        const syncTasks = await getAvailableSyncTypes(accountConfig, sandboxAccountConfig);
+        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
-export async function createDeveloperTestAccountForLocalDev(accountId, accountConfig, env) {
+async function createDeveloperTestAccountForLocalDev(accountId, accountConfig, env, useV3 = false) {
     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
@@ -147,102 +165,102 @@ export async function createDeveloperTestAccountForLocalDev(accountId, accountCo
         }
     }
     catch (err) {
-        if (isMissingScopeError(err)) {
-            uiLogger.error(lib.developerTestAccount.create.failure.scopes.message);
-            const websiteOrigin = getHubSpotWebsiteOrigin(env);
+        if ((0, index_1.isMissingScopeError)(err)) {
+            logger_1.uiLogger.error(en_1.lib.developerTestAccount.create.failure.scopes.message);
+            const websiteOrigin = (0, urls_1.getHubSpotWebsiteOrigin)(env);
             const url = `${websiteOrigin}/personal-access-key/${accountId}`;
-            uiLogger.info(lib.developerTestAccount.create.failure.scopes.instructions(accountConfig.name || accountId, url));
+            logger_1.uiLogger.info(en_1.lib.developerTestAccount.create.failure.scopes.instructions(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,
+            accountType: config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
         });
-        trackCommandMetadataUsage('developer-test-account-create', { step: 'project-dev' }, accountId);
-        const result = await buildDeveloperTestAccount(name, accountConfig, env, maxTestPortals);
+        (0, usageTracking_1.trackCommandMetadataUsage)('developer-test-account-create', { step: 'project-dev' }, accountId);
+        const result = await (0, buildAccount_1.buildDeveloperTestAccount)(name, accountConfig, env, maxTestPortals, useV3);
         return result;
     }
     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
-export async function useExistingDevTestAccount(env, account) {
-    const useExistingDevTestAcct = await confirmUseExistingDeveloperTestAccountPrompt(account);
+async function useExistingDevTestAccount(env, account) {
+    const useExistingDevTestAcct = await (0, projectDevTargetAccountPrompt_1.confirmUseExistingDeveloperTestAccountPrompt)(account);
     if (!useExistingDevTestAcct) {
-        uiLogger.log('');
-        uiLogger.log(lib.localDevHelpers.confirmDefaultAccountIsTarget
+        logger_1.uiLogger.log('');
+        logger_1.uiLogger.log(en_1.lib.localDevHelpers.confirmDefaultAccountIsTarget
             .declineDefaultAccountExplanation);
-        uiLogger.log('');
-        process.exit(EXIT_CODES.SUCCESS);
+        logger_1.uiLogger.log('');
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
-    const devTestAcctConfigName = await saveAccountToConfig(account.id, account.accountName, env);
-    uiLogger.success(lib.developerTestAccount.create.success.configFileUpdated(devTestAcctConfigName, PERSONAL_ACCESS_KEY_AUTH_METHOD.name));
+    const devTestAcctConfigName = await (0, buildAccount_1.saveAccountToConfig)(account.id, account.accountName, env);
+    logger_1.uiLogger.success(en_1.lib.developerTestAccount.create.success.configFileUpdated(devTestAcctConfigName, 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
-export async function createNewProjectForLocalDev(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 explanationLangFunction = hasPublicApps
-            ? lib.localDevHelpers.createNewProjectForLocalDev
+            ? en_1.lib.localDevHelpers.createNewProjectForLocalDev
                 .publicAppProjectMustExistExplanation
-            : lib.localDevHelpers.createNewProjectForLocalDev
+            : en_1.lib.localDevHelpers.createNewProjectForLocalDev
                 .projectMustExistExplanation;
         const explanationString = explanationLangFunction(projectConfig.name, targetAccountId);
-        uiLogger.log('');
-        uiLine();
-        uiLogger.log(explanationString);
-        uiLine();
-        shouldCreateProject = await confirmPrompt(lib.localDevHelpers.createNewProjectForLocalDev.createProject(projectConfig.name, uiAccountDescription(targetAccountId)));
+        logger_1.uiLogger.log('');
+        (0, ui_1.uiLine)();
+        logger_1.uiLogger.log(explanationString);
+        (0, ui_1.uiLine)();
+        shouldCreateProject = await (0, promptUtils_1.confirmPrompt)(en_1.lib.localDevHelpers.createNewProjectForLocalDev.createProject(projectConfig.name, (0, ui_1.uiAccountDescription)(targetAccountId)));
     }
     if (shouldCreateProject) {
-        SpinniesManager.add('createProject', {
-            text: lib.localDevHelpers.createNewProjectForLocalDev.creatingProject(projectConfig.name, uiAccountDescription(targetAccountId)),
+        SpinniesManager_1.default.add('createProject', {
+            text: en_1.lib.localDevHelpers.createNewProjectForLocalDev.creatingProject(projectConfig.name, (0, ui_1.uiAccountDescription)(targetAccountId)),
         });
         try {
-            const { data: project } = await createProject(targetAccountId, projectConfig.name);
-            SpinniesManager.succeed('createProject', {
-                text: lib.localDevHelpers.createNewProjectForLocalDev.createdProject(projectConfig.name, uiAccountDescription(targetAccountId)),
+            const { data: project } = await (0, projects_1.createProject)(targetAccountId, projectConfig.name);
+            SpinniesManager_1.default.succeed('createProject', {
+                text: en_1.lib.localDevHelpers.createNewProjectForLocalDev.createdProject(projectConfig.name, (0, ui_1.uiAccountDescription)(targetAccountId)),
                 succeedColor: 'white',
             });
             return project;
         }
         catch (err) {
-            SpinniesManager.fail('createProject');
-            uiLogger.log(lib.localDevHelpers.createNewProjectForLocalDev.failedToCreateProject);
-            process.exit(EXIT_CODES.ERROR);
+            SpinniesManager_1.default.fail('createProject');
+            logger_1.uiLogger.log(en_1.lib.localDevHelpers.createNewProjectForLocalDev.failedToCreateProject);
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
         }
     }
     else {
         // We cannot continue if the project does not exist in the target account
-        uiLogger.log('');
-        uiLogger.log(lib.localDevHelpers.createNewProjectForLocalDev.choseNotToCreateProject);
-        process.exit(EXIT_CODES.SUCCESS);
+        logger_1.uiLogger.log('');
+        logger_1.uiLogger.log(en_1.lib.localDevHelpers.createNewProjectForLocalDev.choseNotToCreateProject);
+        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
 }
 function projectUploadCallback(accountId, projectConfig, tempFile, buildId) {
     if (!buildId) {
-        uiLogger.error(lib.localDevHelpers.createInitialBuildForNewProject.genericError);
-        process.exit(EXIT_CODES.ERROR);
+        logger_1.uiLogger.error(en_1.lib.localDevHelpers.createInitialBuildForNewProject.genericError);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
-    return pollProjectBuildAndDeploy(accountId, projectConfig, tempFile, buildId, true);
+    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
-export async function createInitialBuildForNewProject(projectConfig, projectDir, targetAccountId, sendIR, profile) {
-    const { result: initialUploadResult, uploadError } = await handleProjectUpload({
+async function createInitialBuildForNewProject(projectConfig, projectDir, targetAccountId, sendIR, profile) {
+    const { result: initialUploadResult, uploadError } = await (0, upload_1.handleProjectUpload)({
         accountId: targetAccountId,
         projectConfig,
         projectDir,
         callbackFunc: projectUploadCallback,
-        uploadMessage: lib.localDevHelpers.createInitialBuildForNewProject
+        uploadMessage: en_1.lib.localDevHelpers.createInitialBuildForNewProject
             .initialUploadMessage,
         forceCreate: true,
         skipValidation: true,
@@ -250,80 +268,80 @@ export async function createInitialBuildForNewProject(projectConfig, projectDir,
         profile,
     });
     if (uploadError) {
-        if (isSpecifiedError(uploadError, {
-            subCategory: PROJECT_ERROR_TYPES.PROJECT_LOCKED,
+        if ((0, index_1.isSpecifiedError)(uploadError, {
+            subCategory: constants_1.PROJECT_ERROR_TYPES.PROJECT_LOCKED,
         })) {
-            uiLogger.log('');
-            uiLogger.error(lib.localDevHelpers.createInitialBuildForNewProject.projectLockedError);
-            uiLogger.log('');
+            logger_1.uiLogger.log('');
+            logger_1.uiLogger.error(en_1.lib.localDevHelpers.createInitialBuildForNewProject.projectLockedError);
+            logger_1.uiLogger.log('');
         }
         else {
-            logError(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) {
         let subTasks = [];
         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') {
             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');
-        uiLogger.log('');
+        logger_1.uiLogger.log('');
         failedSubTasks.forEach(failedSubTask => {
-            uiLogger.error(failedSubTask.errorMessage);
+            logger_1.uiLogger.error(failedSubTask.errorMessage);
         });
-        uiLogger.log('');
-        process.exit(EXIT_CODES.ERROR);
+        logger_1.uiLogger.log('');
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
     return initialUploadResult.buildResult;
 }
-export function 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}`;
 }
-export async function hasSandboxes(account) {
-    const accountId = getAccountIdentifier(account);
+async function hasSandboxes(account) {
+    const accountId = (0, getAccountIdentifier_1.getAccountIdentifier)(account);
     if (!accountId) {
         return false;
     }
     try {
-        const { data: { usage }, } = await getSandboxUsageLimits(accountId);
+        const { data: { usage }, } = await (0, sandboxHubs_1.getSandboxUsageLimits)(accountId);
         return usage.STANDARD.limit > 0 || usage.DEVELOPER.limit > 0;
     }
     catch (e) {
-        debugError(e);
+        (0, index_2.debugError)(e);
         return false;
     }
 }
 // Top level prompt to choose the type of account to test on
-export async function selectAccountTypePrompt(accountConfig) {
+async function selectAccountTypePrompt(accountConfig) {
     const hasAccessToSandboxes = await hasSandboxes(accountConfig);
-    const result = await listPrompt(lib.localDevHelpers.selectAccountTypePrompt.message, {
+    const result = await (0, promptUtils_1.listPrompt)(en_1.lib.localDevHelpers.selectAccountTypePrompt.message, {
         choices: [
             {
-                name: lib.localDevHelpers.selectAccountTypePrompt
+                name: en_1.lib.localDevHelpers.selectAccountTypePrompt
                     .developerTestAccountOption,
-                value: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+                value: config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
             },
             {
-                name: lib.localDevHelpers.selectAccountTypePrompt
+                name: en_1.lib.localDevHelpers.selectAccountTypePrompt
                     .sandboxAccountOption,
-                value: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+                value: config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
                 disabled: !hasAccessToSandboxes
-                    ? lib.localDevHelpers.selectAccountTypePrompt
+                    ? en_1.lib.localDevHelpers.selectAccountTypePrompt
                         .sandboxAccountOptionDisabled
                     : false,
             },
             {
-                name: lib.localDevHelpers.selectAccountTypePrompt
+                name: en_1.lib.localDevHelpers.selectAccountTypePrompt
                     .productionAccountOption,
                 value: null,
             },

package/lib/projects/structure.d.ts

@@ -1,6 +1,6 @@
-import { ComponentTypes, Component, GenericComponentConfig, PublicAppComponentConfig, PrivateAppComponentConfig, AppCardComponentConfig } from '../../types/Projects.js';
-import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
-import { AppIRNode } from '../../types/ProjectComponents.js';
+import { ComponentTypes, Component, GenericComponentConfig, PublicAppComponentConfig, PrivateAppComponentConfig, AppCardComponentConfig } from '../../types/Projects';
+import { IntermediateRepresentationNode, IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
+import { AppIRNode } from '../../types/ProjectComponents';
 export declare const CONFIG_FILES: {
     [k in ComponentTypes]: string;
 };
@@ -15,4 +15,4 @@ export declare function getProjectComponentTypes(components: Array<Component>):
 export declare function getComponentUid(component?: Component | null): string | null;
 export declare function componentIsApp(component?: Component | null): component is Component<PublicAppComponentConfig | PrivateAppComponentConfig>;
 export declare function componentIsPublicApp(component?: Component | null): component is Component<PublicAppComponentConfig>;
-export declare function isAppIRNode(component: IntermediateRepresentationNodeLocalDev): component is AppIRNode;
+export declare function isAppIRNode(component: IntermediateRepresentationNodeLocalDev | IntermediateRepresentationNode): component is AppIRNode;