@hubspot/cli 7.7.0-experimental.3 → 7.7.0

package/commands/project/dev/deprecatedFlow.js

@@ -1,81 +1,84 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deprecatedProjectDevFlow = deprecatedProjectDevFlow;
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const config_1 = require("@hubspot/local-dev-lib/config");
-const environment_1 = require("@hubspot/local-dev-lib/environment");
-const structure_1 = require("../../../lib/projects/structure");
-const Projects_1 = require("../../../types/Projects");
-const lang_1 = require("../../../lib/lang");
-const exitCodes_1 = require("../../../lib/enums/exitCodes");
-const ui_1 = require("../../../lib/ui");
-const SpinniesManager_1 = __importDefault(require("../../../lib/ui/SpinniesManager"));
-const LocalDevManager_1 = __importDefault(require("../../../lib/projects/localDev/LocalDevManager"));
-const helpers_1 = require("../../../lib/projects/localDev/helpers");
-const process_1 = require("../../../lib/process");
-const accountTypes_1 = require("../../../lib/accountTypes");
-const ensureProjectExists_1 = require("../../../lib/projects/ensureProjectExists");
-async function deprecatedProjectDevFlow(args, accountConfig, projectConfig, projectDir) {
-    const { providedAccountId, derivedAccountId } = args;
-    const env = (0, environment_1.getValidEnv)((0, config_1.getEnv)(derivedAccountId));
-    const components = await (0, structure_1.findProjectComponents)(projectDir);
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { getAccountConfig, getConfigAccounts, getEnv, } from '@hubspot/local-dev-lib/config';
+import { getValidEnv } from '@hubspot/local-dev-lib/environment';
+import { findProjectComponents, getProjectComponentTypes, } from '../../../lib/projects/structure.js';
+import { ComponentTypes } from '../../../types/Projects.js';
+import { i18n } from '../../../lib/lang.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { uiCommandReference } from '../../../lib/ui/index.js';
+import SpinniesManager from '../../../lib/ui/SpinniesManager.js';
+import LocalDevManager from '../../../lib/projects/localDev/LocalDevManager.js';
+import { confirmDefaultAccountIsTarget, suggestRecommendedNestedAccount, checkIfAccountFlagIsSupported, checkIfDefaultAccountIsSupported, createSandboxForLocalDev, createDeveloperTestAccountForLocalDev, useExistingDevTestAccount, checkIfParentAccountIsAuthed, hasSandboxes, } from '../../../lib/projects/localDev/helpers/account.js';
+import { createInitialBuildForNewProject, createNewProjectForLocalDev, } from '../../../lib/projects/localDev/helpers/project.js';
+import { handleExit } from '../../../lib/process.js';
+import { isSandbox, isDeveloperTestAccount, } from '../../../lib/accountTypes.js';
+import { ensureProjectExists } from '../../../lib/projects/ensureProjectExists.js';
+export async function deprecatedProjectDevFlow({ args, accountId, projectConfig, projectDir, }) {
+    const { userProvidedAccount, derivedAccountId } = args;
+    const env = getValidEnv(getEnv(derivedAccountId));
+    const components = await findProjectComponents(projectDir);
     const runnableComponents = components.filter(component => component.runnable);
-    const componentTypes = (0, structure_1.getProjectComponentTypes)(runnableComponents);
-    const hasPrivateApps = !!componentTypes[Projects_1.ComponentTypes.PrivateApp];
-    const hasPublicApps = !!componentTypes[Projects_1.ComponentTypes.PublicApp];
+    const componentTypes = getProjectComponentTypes(runnableComponents);
+    const hasPrivateApps = !!componentTypes[ComponentTypes.PrivateApp];
+    const hasPublicApps = !!componentTypes[ComponentTypes.PublicApp];
+    const accountConfig = getAccountConfig(accountId);
+    if (!accountConfig) {
+        logger.error(i18n('commands.project.subcommands.dev.errors.noAccount', {
+            accountId: accountId,
+            authCommand: uiCommandReference('hs auth'),
+        }));
+        process.exit(EXIT_CODES.ERROR);
+    }
     if (runnableComponents.length === 0) {
-        logger_1.logger.error((0, lang_1.i18n)(`commands.project.subcommands.dev.errors.noRunnableComponents`, {
+        logger.error(i18n(`commands.project.subcommands.dev.errors.noRunnableComponents`, {
             projectDir,
-            command: (0, ui_1.uiCommandReference)('hs project add'),
+            command: uiCommandReference('hs project add'),
         }));
-        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+        process.exit(EXIT_CODES.SUCCESS);
     }
     else if (hasPrivateApps && hasPublicApps) {
-        logger_1.logger.error((0, lang_1.i18n)(`commands.project.subcommands.dev.errors.invalidProjectComponents`));
-        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+        logger.error(i18n(`commands.project.subcommands.dev.errors.invalidProjectComponents`));
+        process.exit(EXIT_CODES.SUCCESS);
     }
-    const accounts = (0, config_1.getConfigAccounts)();
+    const accounts = getConfigAccounts();
     if (!accounts) {
-        logger_1.logger.error((0, lang_1.i18n)(`commands.project.subcommands.dev.errors.noAccountsInConfig`, {
-            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
+        logger.error(i18n(`commands.project.subcommands.dev.errors.noAccountsInConfig`, {
+            authCommand: uiCommandReference('hs auth'),
         }));
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        process.exit(EXIT_CODES.ERROR);
     }
     let bypassRecommendedAccountPrompt = false;
-    if ((0, accountTypes_1.isDeveloperTestAccount)(accountConfig)) {
+    if (isDeveloperTestAccount(accountConfig)) {
         bypassRecommendedAccountPrompt = true;
     }
-    else if (!hasPublicApps && (0, accountTypes_1.isSandbox)(accountConfig)) {
+    else if (!hasPublicApps && isSandbox(accountConfig)) {
         bypassRecommendedAccountPrompt = true;
     }
     else if (!hasPublicApps) {
-        const defaultAccountHasSandboxes = await (0, helpers_1.hasSandboxes)(accountConfig);
+        const defaultAccountHasSandboxes = await hasSandboxes(accountConfig);
         bypassRecommendedAccountPrompt = !defaultAccountHasSandboxes;
     }
     // targetProjectAccountId and targetTestingAccountId are set to null if --account flag is not provided.
     // By setting them to null, we can later check if they need to be assigned based on the default account configuration and the type of app.
-    let targetProjectAccountId = providedAccountId ? derivedAccountId : null;
+    let targetProjectAccountId = userProvidedAccount ? derivedAccountId : null;
     // The account that we are locally testing against
-    let targetTestingAccountId = providedAccountId ? derivedAccountId : null;
+    let targetTestingAccountId = userProvidedAccount ? derivedAccountId : null;
     // Check that the default account or flag option is valid for the type of app in this project
-    if (providedAccountId) {
-        (0, helpers_1.checkIfAccountFlagIsSupported)(accountConfig, hasPublicApps);
+    if (userProvidedAccount) {
+        checkIfAccountFlagIsSupported(accountConfig, hasPublicApps);
         if (hasPublicApps) {
             targetProjectAccountId = accountConfig.parentAccountId || null;
         }
     }
     else {
-        await (0, helpers_1.checkIfDefaultAccountIsSupported)(accountConfig, hasPublicApps);
+        await checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps);
     }
     // The user is targeting an account type that we recommend developing on
     if (!targetProjectAccountId && bypassRecommendedAccountPrompt) {
         targetTestingAccountId = derivedAccountId;
-        await (0, helpers_1.confirmDefaultAccountIsTarget)(accountConfig);
+        await confirmDefaultAccountIsTarget(accountConfig);
         if (hasPublicApps) {
-            (0, helpers_1.checkIfParentAccountIsAuthed)(accountConfig);
+            checkIfParentAccountIsAuthed(accountConfig);
             targetProjectAccountId = accountConfig.parentAccountId || null;
         }
         else {
@@ -85,49 +88,49 @@ async function deprecatedProjectDevFlow(args, accountConfig, projectConfig, proj
     let createNewSandbox = false;
     let createNewDeveloperTestAccount = false;
     if (!targetProjectAccountId) {
-        const { targetAccountId, parentAccountId, createNestedAccount, notInConfigAccount, } = await (0, helpers_1.suggestRecommendedNestedAccount)(accounts, accountConfig, hasPublicApps);
+        const { targetAccountId, parentAccountId, createNestedAccount, notInConfigAccount, } = await suggestRecommendedNestedAccount(accounts, accountConfig, hasPublicApps);
         targetProjectAccountId = hasPublicApps
             ? parentAccountId || null
             : targetAccountId;
         targetTestingAccountId = targetAccountId;
         // Only used for developer test accounts that are not yet in the config
         if (notInConfigAccount) {
-            await (0, helpers_1.useExistingDevTestAccount)(env, notInConfigAccount);
+            await useExistingDevTestAccount(env, notInConfigAccount);
         }
         createNewSandbox = hasPrivateApps && createNestedAccount;
         createNewDeveloperTestAccount = hasPublicApps && createNestedAccount;
     }
     if (createNewSandbox) {
-        targetProjectAccountId = await (0, helpers_1.createSandboxForLocalDev)(derivedAccountId, accountConfig, env);
+        targetProjectAccountId = await createSandboxForLocalDev(derivedAccountId, accountConfig, env);
         // We will be running our tests against this new sandbox account
         targetTestingAccountId = targetProjectAccountId;
     }
     if (createNewDeveloperTestAccount) {
-        targetTestingAccountId = await (0, helpers_1.createDeveloperTestAccountForLocalDev)(derivedAccountId, accountConfig, env);
+        targetTestingAccountId = await createDeveloperTestAccountForLocalDev(derivedAccountId, accountConfig, env);
         targetProjectAccountId = derivedAccountId;
     }
     if (!targetProjectAccountId || !targetTestingAccountId) {
-        logger_1.logger.error((0, lang_1.i18n)(`commands.project.subcommands.dev.errors.noAccount`));
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        logger.error(i18n(`commands.project.subcommands.dev.errors.noAccount`));
+        process.exit(EXIT_CODES.ERROR);
     }
     // eslint-disable-next-line prefer-const
-    let { projectExists, project } = await (0, ensureProjectExists_1.ensureProjectExists)(targetProjectAccountId, projectConfig.name, {
+    let { projectExists, project } = await ensureProjectExists(targetProjectAccountId, projectConfig.name, {
         allowCreate: false,
         noLogs: true,
         withPolling: createNewSandbox,
     });
     let deployedBuild;
     let isGithubLinked = false;
-    SpinniesManager_1.default.init();
+    SpinniesManager.init();
     if (projectExists && project) {
         deployedBuild = project.deployedBuild;
         isGithubLinked = Boolean(project.sourceIntegration && project.sourceIntegration.source === 'GITHUB');
     }
     else {
-        project = await (0, helpers_1.createNewProjectForLocalDev)(projectConfig, targetProjectAccountId, createNewSandbox, hasPublicApps);
-        deployedBuild = await (0, helpers_1.createInitialBuildForNewProject)(projectConfig, projectDir, targetProjectAccountId);
+        project = await createNewProjectForLocalDev(projectConfig, targetProjectAccountId, createNewSandbox, hasPublicApps);
+        deployedBuild = await createInitialBuildForNewProject(projectConfig, projectDir, targetProjectAccountId);
     }
-    const LocalDev = new LocalDevManager_1.default({
+    const LocalDev = new LocalDevManager({
         runnableComponents,
         debug: args.debug,
         deployedBuild,
@@ -140,5 +143,5 @@ async function deprecatedProjectDevFlow(args, accountConfig, projectConfig, proj
         env,
     });
     await LocalDev.start();
-    (0, process_1.handleExit)(({ isSIGHUP }) => LocalDev.stop(!isSIGHUP));
+    handleExit(({ isSIGHUP }) => LocalDev.stop(!isSIGHUP));
 }

package/commands/project/dev/index.d.ts

@@ -1,5 +1,5 @@
 import { Argv, CommandModule } from 'yargs';
-import { ProjectDevArgs } from '../../../types/Yargs';
+import { ProjectDevArgs } from '../../../types/Yargs.js';
 export declare const builder: (yargs: Argv) => Promise<Argv<ProjectDevArgs>>;
 declare const projectDevCommand: CommandModule<unknown, ProjectDevArgs>;
 export default projectDevCommand;

package/commands/project/dev/index.js

@@ -1,88 +1,131 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.builder = void 0;
-const usageTracking_1 = require("../../../lib/usageTracking");
-const lang_1 = require("../../../lib/lang");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const config_1 = require("@hubspot/local-dev-lib/config");
-const config_2 = require("../../../lib/projects/config");
-const exitCodes_1 = require("../../../lib/enums/exitCodes");
-const ui_1 = require("../../../lib/ui");
-const deprecatedFlow_1 = require("./deprecatedFlow");
-const unifiedFlow_1 = require("./unifiedFlow");
-const buildAndDeploy_1 = require("../../../lib/projects/buildAndDeploy");
-const yargsUtils_1 = require("../../../lib/yargsUtils");
-const projectProfiles_1 = require("../../../lib/projectProfiles");
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { getProjectConfig, validateProjectConfig, } from '../../../lib/projects/config.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { uiLine } from '../../../lib/ui/index.js';
+import { deprecatedProjectDevFlow } from './deprecatedFlow.js';
+import { unifiedProjectDevFlow } from './unifiedFlow.js';
+import { useV3Api } from '../../../lib/projects/platformVersion.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+import { loadProfile, exitIfUsingProfiles, } from '../../../lib/projectProfiles.js';
+import { commands } from '../../../lang/en.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { logger } from '@hubspot/local-dev-lib/logger';
 const command = 'dev';
-const describe = (0, ui_1.uiBetaTag)((0, lang_1.i18n)(`commands.project.subcommands.dev.describe`), false);
+const describe = commands.project.dev.describe;
+function validateAccountFlags(testingAccount, projectAccount, userProvidedAccount, useV3) {
+    // Legacy projects do not support targetTestingAccount and targetProjectAccount
+    if (testingAccount && projectAccount && !useV3) {
+        uiLogger.error(commands.project.dev.errors.unsupportedAccountFlagLegacy);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    if (userProvidedAccount && useV3) {
+        uiLogger.error(commands.project.dev.errors.unsupportedAccountFlagV3);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
 async function handler(args) {
-    const { derivedAccountId, providedAccountId } = args;
-    const { projectConfig, projectDir } = await (0, config_2.getProjectConfig)();
-    (0, config_2.validateProjectConfig)(projectConfig, projectDir);
+    const { derivedAccountId, userProvidedAccount, testingAccount, projectAccount, } = args;
+    const { projectConfig, projectDir } = await getProjectConfig();
+    validateProjectConfig(projectConfig, projectDir);
+    const useV3 = useV3Api(projectConfig.platformVersion);
     if (!projectDir) {
-        logger_1.logger.error((0, lang_1.i18n)(`commands.project.subcommands.dev.errors.noProjectConfig`, {
-            accountId: derivedAccountId,
-            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
-        }));
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        uiLogger.error(commands.project.dev.errors.noProjectConfig);
+        process.exit(EXIT_CODES.ERROR);
     }
-    let targetAccountId = providedAccountId;
+    validateAccountFlags(testingAccount, projectAccount, userProvidedAccount, useV3);
+    logger.log(commands.project.dev.logs.header);
+    if (useV3) {
+        uiLogger.log(commands.project.dev.logs.learnMoreMessageV3);
+    }
+    else {
+        uiLogger.log(commands.project.dev.logs.learnMoreMessageLegacy);
+    }
+    let targetProjectAccountId;
     let profile;
-    if (!targetAccountId && (0, buildAndDeploy_1.useV3Api)(projectConfig.platformVersion)) {
+    // Using the new --projectAccount flag
+    if (projectAccount) {
+        targetProjectAccountId = getAccountId(projectAccount);
+        if (targetProjectAccountId) {
+            uiLogger.log('');
+            uiLogger.log(commands.project.dev.logs.projectAccountFlagExplanation(targetProjectAccountId));
+        }
+        // Using the legacy --account flag
+    }
+    else if (userProvidedAccount && derivedAccountId) {
+        targetProjectAccountId = derivedAccountId;
+    }
+    if (!targetProjectAccountId && useV3Api(projectConfig.platformVersion)) {
         if (args.profile) {
-            (0, projectProfiles_1.logProfileHeader)(args.profile);
-            profile = (0, projectProfiles_1.loadProfile)(projectConfig, projectDir, args.profile);
+            profile = loadProfile(projectConfig, projectDir, args.profile);
             if (!profile) {
-                (0, ui_1.uiLine)();
-                process.exit(exitCodes_1.EXIT_CODES.ERROR);
+                uiLine();
+                process.exit(EXIT_CODES.ERROR);
             }
-            targetAccountId = profile.accountId;
-            (0, projectProfiles_1.logProfileFooter)(profile);
+            targetProjectAccountId = profile.accountId;
+            uiLogger.log('');
+            uiLogger.log(commands.project.dev.logs.profileProjectAccountExplanation(targetProjectAccountId, args.profile));
         }
         else {
             // A profile must be specified if this project has profiles configured
-            await (0, projectProfiles_1.exitIfUsingProfiles)(projectConfig, projectDir);
+            await exitIfUsingProfiles(projectConfig, projectDir);
         }
     }
-    if (!targetAccountId) {
-        // The user is not using profiles, so we can use the derived accountId
-        targetAccountId = derivedAccountId;
-    }
-    (0, usageTracking_1.trackCommandUsage)('project-dev', {}, targetAccountId);
-    const accountConfig = (0, config_1.getAccountConfig)(targetAccountId);
-    (0, ui_1.uiBetaTag)((0, lang_1.i18n)(`commands.project.subcommands.dev.logs.betaMessage`));
-    logger_1.logger.log((0, ui_1.uiLink)((0, lang_1.i18n)(`commands.project.subcommands.dev.logs.learnMoreLocalDevServer`), 'https://developers.hubspot.com/docs/platform/project-cli-commands#start-a-local-development-server'));
-    if (!accountConfig) {
-        logger_1.logger.error((0, lang_1.i18n)(`commands.project.subcommands.dev.errors.noAccount`, {
-            accountId: (0, ui_1.uiAccountDescription)(targetAccountId),
-            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
-        }));
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    if (!targetProjectAccountId) {
+        // The user is not using profile or account flags, so we can use the derived accountId
+        targetProjectAccountId = derivedAccountId;
+        if (useV3) {
+            uiLogger.log('');
+            uiLogger.log(commands.project.dev.logs.defaultProjectAccountExplanation(targetProjectAccountId));
+        }
     }
-    if ((0, buildAndDeploy_1.useV3Api)(projectConfig.platformVersion)) {
-        await (0, unifiedFlow_1.unifiedProjectDevFlow)(args, accountConfig, projectConfig, projectDir, profile);
+    trackCommandUsage('project-dev', {}, targetProjectAccountId);
+    if (useV3Api(projectConfig.platformVersion)) {
+        const targetTestingAccountId = (testingAccount && getAccountId(testingAccount)) || undefined;
+        await unifiedProjectDevFlow({
+            args,
+            targetProjectAccountId,
+            providedTargetTestingAccountId: targetTestingAccountId,
+            projectConfig,
+            projectDir,
+            profileConfig: profile,
+        });
     }
     else {
-        await (0, deprecatedFlow_1.deprecatedProjectDevFlow)(args, accountConfig, projectConfig, projectDir);
+        await deprecatedProjectDevFlow({
+            args,
+            accountId: targetProjectAccountId,
+            projectConfig,
+            projectDir,
+        });
     }
 }
 function projectDevBuilder(yargs) {
     yargs.option('profile', {
         type: 'string',
         alias: 'p',
-        description: (0, lang_1.i18n)(`commands.project.subcommands.dev.options.profile`),
+        description: commands.project.dev.options.profile,
+        hidden: true,
+    });
+    yargs.options('testing-account', {
+        type: 'string',
+        description: commands.project.dev.options.testingAccount,
+        hidden: true,
+        implies: ['project-account'],
+    });
+    yargs.options('project-account', {
+        type: 'string',
+        description: commands.project.dev.options.projectAccount,
         hidden: true,
+        implies: ['testingAccount'],
     });
-    yargs.example([
-        [
-            '$0 project dev',
-            (0, lang_1.i18n)(`commands.project.subcommands.dev.examples.default`),
-        ],
-    ]);
+    yargs.example([['$0 project dev', commands.project.dev.examples.default]]);
     yargs.conflicts('profile', 'account');
+    yargs.conflicts('profile', 'testing-account');
+    yargs.conflicts('profile', 'project-account');
     return yargs;
 }
-exports.builder = (0, yargsUtils_1.makeYargsBuilder)(projectDevBuilder, command, describe, {
+export const builder = makeYargsBuilder(projectDevBuilder, command, describe, {
     useGlobalOptions: true,
     useAccountOptions: true,
     useConfigOptions: true,
@@ -92,6 +135,6 @@ const projectDevCommand = {
     command,
     describe,
     handler,
-    builder: exports.builder,
+    builder,
 };
-exports.default = projectDevCommand;
+export default projectDevCommand;

package/commands/project/dev/unifiedFlow.d.ts

@@ -1,6 +1,14 @@
 import { ArgumentsCamelCase } from 'yargs';
-import { HsProfileFile } from '@hubspot/project-parsing-lib/src/lib/types';
-import { CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
-import { ProjectDevArgs } from '../../../types/Yargs';
-import { ProjectConfig } from '../../../types/Projects';
-export declare function unifiedProjectDevFlow(args: ArgumentsCamelCase<ProjectDevArgs>, accountConfig: CLIAccount, projectConfig: ProjectConfig, projectDir: string, profileConfig?: HsProfileFile): Promise<void>;
+import { HsProfileFile } from '@hubspot/project-parsing-lib/src/lib/types.js';
+import { ProjectDevArgs } from '../../../types/Yargs.js';
+import { ProjectConfig } from '../../../types/Projects.js';
+type UnifiedProjectDevFlowArgs = {
+    args: ArgumentsCamelCase<ProjectDevArgs>;
+    targetProjectAccountId: number;
+    providedTargetTestingAccountId?: number;
+    projectConfig: ProjectConfig;
+    projectDir: string;
+    profileConfig?: HsProfileFile;
+};
+export declare function unifiedProjectDevFlow({ args, targetProjectAccountId, providedTargetTestingAccountId, projectConfig, projectDir, }: UnifiedProjectDevFlowArgs): Promise<void>;
+export {};