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

package/commands/project/__tests__/devUnifiedFlow.test.js

@@ -1,54 +1,49 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = __importDefault(require("path"));
-const config_1 = require("@hubspot/local-dev-lib/constants/config");
-const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
-const config_2 = require("@hubspot/local-dev-lib/config");
-const environment_1 = require("@hubspot/local-dev-lib/environment");
-const errorHandlers_1 = require("../../../lib/errorHandlers");
-const ensureProjectExists_1 = require("../../../lib/projects/ensureProjectExists");
-const helpers_1 = require("../../../lib/projects/localDev/helpers");
-const projectDevTargetAccountPrompt_1 = require("../../../lib/prompts/projectDevTargetAccountPrompt");
-const SpinniesManager_1 = __importDefault(require("../../../lib/ui/SpinniesManager"));
-const LocalDevProcess_1 = __importDefault(require("../../../lib/projects/localDev/LocalDevProcess"));
-const LocalDevWatcher_1 = __importDefault(require("../../../lib/projects/localDev/LocalDevWatcher"));
-const LocalDevWebsocketServer_1 = __importDefault(require("../../../lib/projects/localDev/LocalDevWebsocketServer"));
-const process_1 = require("../../../lib/process");
-const accountTypes_1 = require("../../../lib/accountTypes");
-const ui_1 = require("../../../lib/ui");
-const logger_1 = require("../../../lib/ui/logger");
-const en_1 = require("../../../lang/en");
-const unifiedFlow_1 = require("../dev/unifiedFlow");
-const environments_1 = require("@hubspot/local-dev-lib/constants/environments");
-const vitest_1 = require("vitest");
+import path from 'path';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { translateForLocalDev } from '@hubspot/project-parsing-lib';
+import { getConfigAccounts, getAccountConfig, } from '@hubspot/local-dev-lib/config';
+import { getValidEnv } from '@hubspot/local-dev-lib/environment';
+import { logError } from '../../../lib/errorHandlers/index.js';
+import { ensureProjectExists } from '../../../lib/projects/ensureProjectExists.js';
+import { createInitialBuildForNewProject, createNewProjectForLocalDev, useExistingDevTestAccount, createDeveloperTestAccountForLocalDev, selectAccountTypePrompt, } from '../../../lib/projects/localDev/helpers.js';
+import { selectDeveloperTestTargetAccountPrompt, selectSandboxTargetAccountPrompt, } from '../../../lib/prompts/projectDevTargetAccountPrompt.js';
+import SpinniesManager from '../../../lib/ui/SpinniesManager.js';
+import LocalDevProcess from '../../../lib/projects/localDev/LocalDevProcess.js';
+import LocalDevWatcher from '../../../lib/projects/localDev/LocalDevWatcher.js';
+import LocalDevWebsocketServer from '../../../lib/projects/localDev/LocalDevWebsocketServer.js';
+import { handleExit, handleKeypress } from '../../../lib/process.js';
+import { isTestAccountOrSandbox, isUnifiedAccount, } from '../../../lib/accountTypes.js';
+import { uiLine } from '../../../lib/ui/index.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { commands } from '../../../lang/en.js';
+import { unifiedProjectDevFlow } from '../dev/unifiedFlow.js';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+import { vi } from 'vitest';
 // Mock @hubspot/ui-extensions-dev-server
-vitest_1.vi.mock('@hubspot/ui-extensions-dev-server', () => ({
+vi.mock('@hubspot/ui-extensions-dev-server', () => ({
     DevModeUnifiedInterface: {
-        setup: vitest_1.vi.fn().mockResolvedValue(undefined),
-        start: vitest_1.vi.fn().mockResolvedValue(undefined),
-        fileChange: vitest_1.vi.fn().mockResolvedValue(undefined),
-        cleanup: vitest_1.vi.fn().mockResolvedValue(undefined),
+        setup: vi.fn().mockResolvedValue(undefined),
+        start: vi.fn().mockResolvedValue(undefined),
+        fileChange: vi.fn().mockResolvedValue(undefined),
+        cleanup: vi.fn().mockResolvedValue(undefined),
     },
 }));
 // Mock all dependencies
-vitest_1.vi.mock('@hubspot/project-parsing-lib');
-vitest_1.vi.mock('@hubspot/local-dev-lib/config');
-vitest_1.vi.mock('@hubspot/local-dev-lib/environment');
-vitest_1.vi.mock('../../../lib/errorHandlers');
-vitest_1.vi.mock('../../../lib/projects/ensureProjectExists');
-vitest_1.vi.mock('../../../lib/projects/localDev/helpers');
-vitest_1.vi.mock('../../../lib/prompts/projectDevTargetAccountPrompt');
-vitest_1.vi.mock('../../../lib/ui/SpinniesManager');
-vitest_1.vi.mock('../../../lib/projects/localDev/LocalDevProcess');
-vitest_1.vi.mock('../../../lib/projects/localDev/LocalDevWatcher');
-vitest_1.vi.mock('../../../lib/projects/localDev/LocalDevWebsocketServer');
-vitest_1.vi.mock('../../../lib/process');
-vitest_1.vi.mock('../../../lib/accountTypes');
-vitest_1.vi.mock('../../../lib/ui');
-vitest_1.vi.mock('../../../lib/ui/logger');
+vi.mock('@hubspot/project-parsing-lib');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/environment');
+vi.mock('../../../lib/errorHandlers');
+vi.mock('../../../lib/projects/ensureProjectExists');
+vi.mock('../../../lib/projects/localDev/helpers');
+vi.mock('../../../lib/prompts/projectDevTargetAccountPrompt');
+vi.mock('../../../lib/ui/SpinniesManager');
+vi.mock('../../../lib/projects/localDev/LocalDevProcess');
+vi.mock('../../../lib/projects/localDev/LocalDevWatcher');
+vi.mock('../../../lib/projects/localDev/LocalDevWebsocketServer');
+vi.mock('../../../lib/process');
+vi.mock('../../../lib/accountTypes');
+vi.mock('../../../lib/ui');
+vi.mock('../../../lib/ui/logger');
 describe('unifiedProjectDevFlow', () => {
     const mockArgs = {
         profile: 'test-profile',
@@ -66,7 +61,7 @@ describe('unifiedProjectDevFlow', () => {
         srcDir: 'src',
         platformVersion: '1.0.0',
     };
-    const mockProjectDir = '/test/project';
+    const mockProjectDir = '/test/project.js';
     const mockTargetProjectAccountId = 123;
     const mockProvidedTargetTestingAccountId = 456;
     const mockProfileConfig = {
@@ -75,7 +70,7 @@ describe('unifiedProjectDevFlow', () => {
     const mockAccountConfig = {
         accountId: 123,
         name: 'test-account',
-        accountType: config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD,
+        accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
     };
     const mockProject = {
         id: 1,
@@ -98,58 +93,58 @@ describe('unifiedProjectDevFlow', () => {
         },
     };
     const mockLocalDevProcess = {
-        start: vitest_1.vi.fn().mockResolvedValue(undefined),
-        stop: vitest_1.vi.fn().mockResolvedValue(undefined),
+        start: vi.fn().mockResolvedValue(undefined),
+        stop: vi.fn().mockResolvedValue(undefined),
     };
     const mockLocalDevWatcher = {
-        start: vitest_1.vi.fn(),
-        stop: vitest_1.vi.fn().mockResolvedValue(undefined),
+        start: vi.fn(),
+        stop: vi.fn().mockResolvedValue(undefined),
     };
     const mockWebsocketServer = {
-        start: vitest_1.vi.fn().mockResolvedValue(undefined),
-        shutdown: vitest_1.vi.fn().mockResolvedValue(undefined),
+        start: vi.fn().mockResolvedValue(undefined),
+        shutdown: vi.fn().mockResolvedValue(undefined),
     };
     beforeEach(() => {
-        vitest_1.vi.clearAllMocks();
+        vi.clearAllMocks();
         // Mock process.exit
-        vitest_1.vi.spyOn(global.process, 'exit').mockImplementation((code) => {
+        vi.spyOn(global.process, 'exit').mockImplementation((code) => {
             throw new Error(`Process.exit called with code ${code}`);
         });
         // Setup default mocks
-        environment_1.getValidEnv.mockReturnValue(environments_1.ENVIRONMENTS.PROD);
-        project_parsing_lib_1.translateForLocalDev.mockResolvedValue({
+        getValidEnv.mockReturnValue(ENVIRONMENTS.PROD);
+        translateForLocalDev.mockResolvedValue({
             intermediateNodesIndexedByUid: mockProjectNodes,
         });
-        config_2.getAccountConfig.mockReturnValue(mockAccountConfig);
-        config_2.getConfigAccounts.mockReturnValue([mockAccountConfig]);
-        accountTypes_1.isUnifiedAccount.mockResolvedValue(true);
-        accountTypes_1.isTestAccountOrSandbox.mockReturnValue(false);
-        ensureProjectExists_1.ensureProjectExists.mockResolvedValue({
+        getAccountConfig.mockReturnValue(mockAccountConfig);
+        getConfigAccounts.mockReturnValue([mockAccountConfig]);
+        isUnifiedAccount.mockResolvedValue(true);
+        isTestAccountOrSandbox.mockReturnValue(false);
+        ensureProjectExists.mockResolvedValue({
             projectExists: true,
             project: mockProject,
         });
-        SpinniesManager_1.default.init.mockImplementation(() => { });
-        LocalDevProcess_1.default.mockImplementation(() => mockLocalDevProcess);
-        LocalDevWatcher_1.default.mockImplementation(() => mockLocalDevWatcher);
-        LocalDevWebsocketServer_1.default.mockImplementation(() => mockWebsocketServer);
-        process_1.handleKeypress.mockImplementation(() => { });
-        process_1.handleExit.mockImplementation(() => { });
-        logger_1.uiLogger.debug.mockImplementation(() => { });
-        logger_1.uiLogger.error.mockImplementation(() => { });
-        logger_1.uiLogger.log.mockImplementation(() => { });
-        ui_1.uiLine.mockImplementation(() => { });
+        SpinniesManager.init.mockImplementation(() => { });
+        LocalDevProcess.mockImplementation(() => mockLocalDevProcess);
+        LocalDevWatcher.mockImplementation(() => mockLocalDevWatcher);
+        LocalDevWebsocketServer.mockImplementation(() => mockWebsocketServer);
+        handleKeypress.mockImplementation(() => { });
+        handleExit.mockImplementation(() => { });
+        uiLogger.debug.mockImplementation(() => { });
+        uiLogger.error.mockImplementation(() => { });
+        uiLogger.log.mockImplementation(() => { });
+        uiLine.mockImplementation(() => { });
     });
     describe('successful flow', () => {
         it('should complete successfully with existing project and provided testing account', async () => {
-            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+            await unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(project_parsing_lib_1.translateForLocalDev).toHaveBeenCalledWith({
-                projectSourceDir: path_1.default.join(mockProjectDir, mockProjectConfig.srcDir),
+            expect(translateForLocalDev).toHaveBeenCalledWith({
+                projectSourceDir: path.join(mockProjectDir, mockProjectConfig.srcDir),
                 platformVersion: mockProjectConfig.platformVersion,
                 accountId: mockTargetProjectAccountId,
             }, { profile: mockArgs.profile });
@@ -158,26 +153,26 @@ describe('unifiedProjectDevFlow', () => {
             expect(mockWebsocketServer.start).toHaveBeenCalled();
         });
         it('should complete successfully with profile config', async () => {
-            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+            await unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
                 profileConfig: mockProfileConfig,
             });
-            expect(LocalDevProcess_1.default).toHaveBeenCalledWith(expect.objectContaining({
+            expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
                 targetTestingAccountId: mockProfileConfig.accountId,
             }));
         });
         it('should use target project account as testing account when it is a test account', async () => {
-            accountTypes_1.isTestAccountOrSandbox.mockReturnValue(true);
-            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+            isTestAccountOrSandbox.mockReturnValue(true);
+            await unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(LocalDevProcess_1.default).toHaveBeenCalledWith(expect.objectContaining({
+            expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
                 targetTestingAccountId: mockTargetProjectAccountId,
             }));
         });
@@ -185,145 +180,145 @@ describe('unifiedProjectDevFlow', () => {
     describe('error handling', () => {
         it('should exit with error code when translation fails', async () => {
             const translationError = new Error('Translation failed');
-            project_parsing_lib_1.translateForLocalDev.mockRejectedValue(translationError);
-            await expect((0, unifiedFlow_1.unifiedProjectDevFlow)({
+            translateForLocalDev.mockRejectedValue(translationError);
+            await expect(unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             })).rejects.toThrow('Process.exit called with code 1');
-            expect(errorHandlers_1.logError).toHaveBeenCalledWith(translationError);
+            expect(logError).toHaveBeenCalledWith(translationError);
         });
         it('should exit with success when no runnable components found', async () => {
-            project_parsing_lib_1.translateForLocalDev.mockResolvedValue({
+            translateForLocalDev.mockResolvedValue({
                 intermediateNodesIndexedByUid: {},
             });
-            await expect((0, unifiedFlow_1.unifiedProjectDevFlow)({
+            await expect(unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             })).rejects.toThrow('Process.exit called with code 0');
-            expect(logger_1.uiLogger.error).toHaveBeenCalledWith(en_1.commands.project.dev.errors.noRunnableComponents);
+            expect(uiLogger.error).toHaveBeenCalledWith(commands.project.dev.errors.noRunnableComponents);
         });
         it('should exit with error when account config not found', async () => {
-            config_2.getAccountConfig.mockReturnValue(null);
-            await expect((0, unifiedFlow_1.unifiedProjectDevFlow)({
+            getAccountConfig.mockReturnValue(null);
+            await expect(unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             })).rejects.toThrow('Process.exit called with code 1');
-            expect(logger_1.uiLogger.error).toHaveBeenCalledWith(en_1.commands.project.dev.errors.noAccount(mockTargetProjectAccountId));
+            expect(uiLogger.error).toHaveBeenCalledWith(commands.project.dev.errors.noAccount(mockTargetProjectAccountId));
         });
         it('should exit with error when account is not combined and no profile', async () => {
-            accountTypes_1.isUnifiedAccount.mockResolvedValue(false);
-            await expect((0, unifiedFlow_1.unifiedProjectDevFlow)({
+            isUnifiedAccount.mockResolvedValue(false);
+            await expect(unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             })).rejects.toThrow('Process.exit called with code 1');
-            expect(logger_1.uiLogger.error).toHaveBeenCalledWith(en_1.commands.project.dev.errors.accountNotCombined);
+            expect(uiLogger.error).toHaveBeenCalledWith(commands.project.dev.errors.accountNotCombined);
         });
     });
     describe('account type selection and prompting', () => {
         beforeEach(() => {
             // Reset to require prompting
-            accountTypes_1.isTestAccountOrSandbox.mockReturnValue(false);
+            isTestAccountOrSandbox.mockReturnValue(false);
         });
         it('should prompt for account type when no testing account provided', async () => {
-            helpers_1.selectAccountTypePrompt.mockResolvedValue(config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST);
-            projectDevTargetAccountPrompt_1.selectDeveloperTestTargetAccountPrompt.mockResolvedValue({
+            selectAccountTypePrompt.mockResolvedValue(HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST);
+            selectDeveloperTestTargetAccountPrompt.mockResolvedValue({
                 targetAccountId: 456,
             });
-            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+            await unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(helpers_1.selectAccountTypePrompt).toHaveBeenCalledWith(mockAccountConfig);
-            expect(projectDevTargetAccountPrompt_1.selectDeveloperTestTargetAccountPrompt).toHaveBeenCalled();
+            expect(selectAccountTypePrompt).toHaveBeenCalledWith(mockAccountConfig);
+            expect(selectDeveloperTestTargetAccountPrompt).toHaveBeenCalled();
         });
         it('should handle developer test account creation', async () => {
-            helpers_1.selectAccountTypePrompt.mockResolvedValue(config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST);
-            projectDevTargetAccountPrompt_1.selectDeveloperTestTargetAccountPrompt.mockResolvedValue({
+            selectAccountTypePrompt.mockResolvedValue(HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST);
+            selectDeveloperTestTargetAccountPrompt.mockResolvedValue({
                 createNestedAccount: true,
             });
-            helpers_1.createDeveloperTestAccountForLocalDev.mockResolvedValue(999);
-            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+            createDeveloperTestAccountForLocalDev.mockResolvedValue(999);
+            await unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(helpers_1.createDeveloperTestAccountForLocalDev).toHaveBeenCalledWith(mockTargetProjectAccountId, mockAccountConfig, environments_1.ENVIRONMENTS.PROD);
-            expect(LocalDevProcess_1.default).toHaveBeenCalledWith(expect.objectContaining({
+            expect(createDeveloperTestAccountForLocalDev).toHaveBeenCalledWith(mockTargetProjectAccountId, mockAccountConfig, ENVIRONMENTS.PROD);
+            expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
                 targetTestingAccountId: 999,
             }));
         });
         it('should handle existing developer test account not in config', async () => {
             const notInConfigAccount = { accountId: 777, name: 'external-account' };
-            helpers_1.selectAccountTypePrompt.mockResolvedValue(config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST);
-            projectDevTargetAccountPrompt_1.selectDeveloperTestTargetAccountPrompt.mockResolvedValue({
+            selectAccountTypePrompt.mockResolvedValue(HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST);
+            selectDeveloperTestTargetAccountPrompt.mockResolvedValue({
                 notInConfigAccount,
             });
-            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+            await unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(helpers_1.useExistingDevTestAccount).toHaveBeenCalledWith(environments_1.ENVIRONMENTS.PROD, notInConfigAccount);
+            expect(useExistingDevTestAccount).toHaveBeenCalledWith(ENVIRONMENTS.PROD, notInConfigAccount);
         });
         it('should handle sandbox account selection', async () => {
-            helpers_1.selectAccountTypePrompt.mockResolvedValue(config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX);
-            projectDevTargetAccountPrompt_1.selectSandboxTargetAccountPrompt.mockResolvedValue({
+            selectAccountTypePrompt.mockResolvedValue(HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX);
+            selectSandboxTargetAccountPrompt.mockResolvedValue({
                 targetAccountId: 888,
             });
-            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+            await unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(projectDevTargetAccountPrompt_1.selectSandboxTargetAccountPrompt).toHaveBeenCalled();
-            expect(LocalDevProcess_1.default).toHaveBeenCalledWith(expect.objectContaining({
+            expect(selectSandboxTargetAccountPrompt).toHaveBeenCalled();
+            expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
                 targetTestingAccountId: 888,
             }));
         });
     });
     describe('project creation', () => {
         it('should create new project when project does not exist', async () => {
-            ensureProjectExists_1.ensureProjectExists.mockResolvedValue({
+            ensureProjectExists.mockResolvedValue({
                 projectExists: false,
                 project: null,
             });
-            helpers_1.createNewProjectForLocalDev.mockResolvedValue(mockProject);
-            helpers_1.createInitialBuildForNewProject.mockResolvedValue({
+            createNewProjectForLocalDev.mockResolvedValue(mockProject);
+            createInitialBuildForNewProject.mockResolvedValue({
                 buildId: 456,
             });
-            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+            await unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(helpers_1.createNewProjectForLocalDev).toHaveBeenCalledWith(mockProjectConfig, mockTargetProjectAccountId, false, false);
-            expect(helpers_1.createInitialBuildForNewProject).toHaveBeenCalledWith(mockProjectConfig, mockProjectDir, mockTargetProjectAccountId, true, mockArgs.profile);
+            expect(createNewProjectForLocalDev).toHaveBeenCalledWith(mockProjectConfig, mockTargetProjectAccountId, false, false);
+            expect(createInitialBuildForNewProject).toHaveBeenCalledWith(mockProjectConfig, mockProjectDir, mockTargetProjectAccountId, true, mockArgs.profile);
         });
         it('should use existing project and build when project exists', async () => {
-            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+            await unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(helpers_1.createNewProjectForLocalDev).not.toHaveBeenCalled();
-            expect(LocalDevProcess_1.default).toHaveBeenCalledWith(expect.objectContaining({
+            expect(createNewProjectForLocalDev).not.toHaveBeenCalled();
+            expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
                 deployedBuild: mockProject.deployedBuild,
                 projectId: mockProject.id,
                 projectName: mockProject.name,
@@ -334,32 +329,32 @@ describe('unifiedProjectDevFlow', () => {
                 ...mockProject,
                 sourceIntegration: { source: 'GITHUB' },
             };
-            ensureProjectExists_1.ensureProjectExists.mockResolvedValue({
+            ensureProjectExists.mockResolvedValue({
                 projectExists: true,
                 project: githubLinkedProject,
             });
-            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+            await unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(LocalDevProcess_1.default).toHaveBeenCalledWith(expect.objectContaining({
+            expect(LocalDevProcess).toHaveBeenCalledWith(expect.objectContaining({
                 isGithubLinked: true,
             }));
         });
     });
     describe('local dev process setup', () => {
         it('should initialize LocalDevProcess with correct parameters', async () => {
-            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+            await unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(LocalDevProcess_1.default).toHaveBeenCalledWith({
+            expect(LocalDevProcess).toHaveBeenCalledWith({
                 initialProjectNodes: mockProjectNodes,
                 debug: mockArgs.debug,
                 deployedBuild: mockProject.deployedBuild,
@@ -371,22 +366,22 @@ describe('unifiedProjectDevFlow', () => {
                 projectDir: mockProjectDir,
                 projectName: mockProject.name,
                 projectId: mockProject.id,
-                env: environments_1.ENVIRONMENTS.PROD,
+                env: ENVIRONMENTS.PROD,
             });
         });
         it('should set up keypress and exit handlers', async () => {
-            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+            await unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(process_1.handleKeypress).toHaveBeenCalledWith(expect.any(Function));
-            expect(process_1.handleExit).toHaveBeenCalledWith(expect.any(Function));
+            expect(handleKeypress).toHaveBeenCalledWith(expect.any(Function));
+            expect(handleExit).toHaveBeenCalledWith(expect.any(Function));
         });
         it('should start all required services', async () => {
-            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+            await unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
@@ -396,24 +391,24 @@ describe('unifiedProjectDevFlow', () => {
             expect(mockLocalDevProcess.start).toHaveBeenCalled();
             expect(mockLocalDevWatcher.start).toHaveBeenCalled();
             expect(mockWebsocketServer.start).toHaveBeenCalled();
-            expect(SpinniesManager_1.default.init).toHaveBeenCalled();
+            expect(SpinniesManager.init).toHaveBeenCalled();
         });
     });
     describe('UI messaging', () => {
         beforeEach(() => {
-            accountTypes_1.isTestAccountOrSandbox.mockReturnValue(false);
+            isTestAccountOrSandbox.mockReturnValue(false);
         });
         it('should display account type information when prompting', async () => {
-            helpers_1.selectAccountTypePrompt.mockResolvedValue(config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD);
-            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+            selectAccountTypePrompt.mockResolvedValue(HUBSPOT_ACCOUNT_TYPES.STANDARD);
+            await unifiedProjectDevFlow({
                 args: mockArgs,
                 targetProjectAccountId: mockTargetProjectAccountId,
                 projectConfig: mockProjectConfig,
                 projectDir: mockProjectDir,
             });
-            expect(ui_1.uiLine).toHaveBeenCalled();
-            expect(logger_1.uiLogger.log).toHaveBeenCalledWith(en_1.commands.project.dev.logs.accountTypeInformation);
-            expect(logger_1.uiLogger.log).toHaveBeenCalledWith(en_1.commands.project.dev.logs.learnMoreMessage);
+            expect(uiLine).toHaveBeenCalled();
+            expect(uiLogger.log).toHaveBeenCalledWith(commands.project.dev.logs.accountTypeInformation);
+            expect(uiLogger.log).toHaveBeenCalledWith(commands.project.dev.logs.learnMoreMessage);
         });
     });
 });

package/commands/project/__tests__/download.test.js

@@ -1,38 +1,33 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const yargs_1 = __importDefault(require("yargs"));
-const commonOpts_1 = require("../../../lib/commonOpts");
-const download_1 = __importDefault(require("../download"));
+import yargs from 'yargs';
+import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
+import projectDownloadCommand from '../download.js';
 vi.mock('../../../lib/commonOpts');
 describe('commands/project/download', () => {
-    const yargsMock = yargs_1.default;
+    const yargsMock = yargs;
     describe('command', () => {
         it('should have the correct command structure', () => {
-            expect(download_1.default.command).toEqual('download');
+            expect(projectDownloadCommand.command).toEqual('download');
         });
     });
     describe('describe', () => {
         it('should provide a description', () => {
-            expect(download_1.default.describe).toBeDefined();
+            expect(projectDownloadCommand.describe).toBeDefined();
         });
     });
     describe('builder', () => {
         it('should support the correct options', () => {
-            download_1.default.builder(yargsMock);
-            expect(commonOpts_1.addAccountOptions).toHaveBeenCalledTimes(1);
-            expect(commonOpts_1.addAccountOptions).toHaveBeenCalledWith(yargsMock);
-            expect(commonOpts_1.addConfigOptions).toHaveBeenCalledTimes(1);
-            expect(commonOpts_1.addConfigOptions).toHaveBeenCalledWith(yargsMock);
-            expect(commonOpts_1.addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
-            expect(commonOpts_1.addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
+            projectDownloadCommand.builder(yargsMock);
+            expect(addAccountOptions).toHaveBeenCalledTimes(1);
+            expect(addAccountOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
         });
         it('should define project, dest, and build options', () => {
             const optionsSpy = vi.spyOn(yargsMock, 'options');
             const exampleSpy = vi.spyOn(yargsMock, 'example');
-            download_1.default.builder(yargsMock);
+            projectDownloadCommand.builder(yargsMock);
             expect(optionsSpy).toHaveBeenCalledWith(expect.objectContaining({
                 project: expect.any(Object),
                 dest: expect.any(Object),