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

package/lib/app/__tests__/migrate.test.js

@@ -1,18 +1,23 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
-import { getCwd, sanitizeFileName } from '@hubspot/local-dev-lib/path';
-import { extractZipArchive } from '@hubspot/local-dev-lib/archive';
-import { validateUid } from '@hubspot/project-parsing-lib';
-import { UNMIGRATABLE_REASONS } from '@hubspot/local-dev-lib/constants/projects';
-import { MIGRATION_STATUS } from '@hubspot/local-dev-lib/types/Migration';
-import { downloadProject } from '@hubspot/local-dev-lib/api/projects';
-import fs from 'fs';
-import { confirmPrompt, inputPrompt, listPrompt, } from '../../prompts/promptUtils.js';
-import { ensureProjectExists } from '../../projects/ensureProjectExists.js';
-import { poll } from '../../polling.js';
-import { CLI_UNMIGRATABLE_REASONS, continueMigration, initializeMigration, listAppsForMigration, } from '../../../api/migrate.js';
-import { lib } from '../../../lang/en.js';
-import { hasFeature } from '../../hasFeature.js';
-import { getUnmigratableReason, generateFilterAppsByProjectNameFunction, buildErrorMessageFromMigrationStatus, fetchMigrationApps, promptForAppToMigrate, selectAppToMigrate, handleMigrationSetup, beginMigration, pollMigrationStatus, finalizeMigration, downloadProjectFiles, migrateApp2025_2, logInvalidAccountError, } from '../migrate.js';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const path_1 = require("@hubspot/local-dev-lib/path");
+const archive_1 = require("@hubspot/local-dev-lib/archive");
+const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
+const projects_1 = require("@hubspot/local-dev-lib/constants/projects");
+const Migration_1 = require("@hubspot/local-dev-lib/types/Migration");
+const projects_2 = require("@hubspot/local-dev-lib/api/projects");
+const fs_1 = __importDefault(require("fs"));
+const promptUtils_1 = require("../../prompts/promptUtils");
+const ensureProjectExists_1 = require("../../projects/ensureProjectExists");
+const polling_1 = require("../../polling");
+const migrate_1 = require("../../../api/migrate");
+const en_1 = require("../../../lang/en");
+const hasFeature_1 = require("../../hasFeature");
+const migrate_2 = require("../migrate");
 vi.mock('@hubspot/local-dev-lib/logger');
 vi.mock('@hubspot/local-dev-lib/path');
 vi.mock('@hubspot/local-dev-lib/archive');
@@ -28,22 +33,22 @@ vi.mock('../../../api/migrate');
 vi.mock('../../hasFeature');
 vi.mock('../../projects/urls');
 vi.mock('fs');
-const mockedLogger = logger;
-const mockedGetCwd = getCwd;
-const mockedSanitizeFileName = sanitizeFileName;
-const mockedExtractZipArchive = extractZipArchive;
-const mockedValidateUid = validateUid;
-const mockedDownloadProject = downloadProject;
-const mockedConfirmPrompt = confirmPrompt;
-const mockedInputPrompt = inputPrompt;
-const mockedListPrompt = listPrompt;
-const mockedEnsureProjectExists = ensureProjectExists;
-const mockedPoll = poll;
-const mockedListAppsForMigration = listAppsForMigration;
-const mockedInitializeMigration = initializeMigration;
-const mockedContinueMigration = continueMigration;
-const mockedHasFeature = hasFeature;
-const mockedFs = fs;
+const mockedLogger = logger_1.logger;
+const mockedGetCwd = path_1.getCwd;
+const mockedSanitizeFileName = path_1.sanitizeFileName;
+const mockedExtractZipArchive = archive_1.extractZipArchive;
+const mockedValidateUid = project_parsing_lib_1.validateUid;
+const mockedDownloadProject = projects_2.downloadProject;
+const mockedConfirmPrompt = promptUtils_1.confirmPrompt;
+const mockedInputPrompt = promptUtils_1.inputPrompt;
+const mockedListPrompt = promptUtils_1.listPrompt;
+const mockedEnsureProjectExists = ensureProjectExists_1.ensureProjectExists;
+const mockedPoll = polling_1.poll;
+const mockedListAppsForMigration = migrate_1.listAppsForMigration;
+const mockedInitializeMigration = migrate_1.initializeMigration;
+const mockedContinueMigration = migrate_1.continueMigration;
+const mockedHasFeature = hasFeature_1.hasFeature;
+const mockedFs = fs_1.default;
 const createMockMigratableApp = (id, name, projectName) => ({
     appId: id,
     appName: name,
@@ -73,8 +78,8 @@ const PROJECT_DEST = '/mock/dest';
 const MOCK_CWD = '/mock/cwd';
 const MOCK_PROJECT_DIR = '/mock/project/dir';
 const mockUnmigratableApps = [
-    createMockUnmigratableApp(3, 'App 3', UNMIGRATABLE_REASONS.UP_TO_DATE),
-    createMockUnmigratableApp(4, 'App 4', UNMIGRATABLE_REASONS.IS_A_PRIVATE_APP),
+    createMockUnmigratableApp(3, 'App 3', projects_1.UNMIGRATABLE_REASONS.UP_TO_DATE),
+    createMockUnmigratableApp(4, 'App 4', projects_1.UNMIGRATABLE_REASONS.IS_A_PRIVATE_APP),
 ];
 describe('lib/app/migrate', () => {
     beforeEach(() => {
@@ -88,38 +93,38 @@ describe('lib/app/migrate', () => {
         const testCases = [
             {
                 name: 'UP_TO_DATE',
-                reason: UNMIGRATABLE_REASONS.UP_TO_DATE,
-                expected: lib.migrate.errors.unmigratableReasons.upToDate,
+                reason: projects_1.UNMIGRATABLE_REASONS.UP_TO_DATE,
+                expected: en_1.lib.migrate.errors.unmigratableReasons.upToDate,
             },
             {
                 name: 'IS_A_PRIVATE_APP',
-                reason: UNMIGRATABLE_REASONS.IS_A_PRIVATE_APP,
-                expected: lib.migrate.errors.unmigratableReasons.isPrivateApp,
+                reason: projects_1.UNMIGRATABLE_REASONS.IS_A_PRIVATE_APP,
+                expected: en_1.lib.migrate.errors.unmigratableReasons.isPrivateApp,
             },
             {
                 name: 'LISTED_IN_MARKETPLACE',
-                reason: UNMIGRATABLE_REASONS.LISTED_IN_MARKETPLACE,
-                expected: lib.migrate.errors.unmigratableReasons.listedInMarketplace,
+                reason: projects_1.UNMIGRATABLE_REASONS.LISTED_IN_MARKETPLACE,
+                expected: en_1.lib.migrate.errors.unmigratableReasons.listedInMarketplace,
             },
             {
                 name: 'PROJECT_CONNECTED_TO_GITHUB',
-                reason: UNMIGRATABLE_REASONS.PROJECT_CONNECTED_TO_GITHUB,
-                expected: lib.migrate.errors.unmigratableReasons.projectConnectedToGitHub(PROJECT_NAME, ACCOUNT_ID),
+                reason: projects_1.UNMIGRATABLE_REASONS.PROJECT_CONNECTED_TO_GITHUB,
+                expected: en_1.lib.migrate.errors.unmigratableReasons.projectConnectedToGitHub(PROJECT_NAME, ACCOUNT_ID),
             },
             {
                 name: 'PART_OF_PROJECT_ALREADY',
-                reason: CLI_UNMIGRATABLE_REASONS.PART_OF_PROJECT_ALREADY,
-                expected: lib.migrate.errors.unmigratableReasons.partOfProjectAlready,
+                reason: migrate_1.CLI_UNMIGRATABLE_REASONS.PART_OF_PROJECT_ALREADY,
+                expected: en_1.lib.migrate.errors.unmigratableReasons.partOfProjectAlready,
             },
             {
                 name: 'UNKNOWN_REASON',
                 reason: 'UNKNOWN_REASON',
-                expected: lib.migrate.errors.unmigratableReasons.generic('UNKNOWN_REASON'),
+                expected: en_1.lib.migrate.errors.unmigratableReasons.generic('UNKNOWN_REASON'),
             },
         ];
         testCases.forEach(testCase => {
             it(`should return the correct message for ${testCase.name}`, () => {
-                const result = getUnmigratableReason(testCase.reason, PROJECT_NAME, ACCOUNT_ID);
+                const result = (0, migrate_2.getUnmigratableReason)(testCase.reason, PROJECT_NAME, ACCOUNT_ID);
                 expect(result).toBe(testCase.expected);
             });
         });
@@ -127,14 +132,14 @@ describe('lib/app/migrate', () => {
     describe('generateFilterAppsByProjectNameFunction', () => {
         it('should return a function that filters by project name when projectConfig is provided', () => {
             const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
-            const filterFn = generateFilterAppsByProjectNameFunction(projectConfig);
+            const filterFn = (0, migrate_2.generateFilterAppsByProjectNameFunction)(projectConfig);
             const matchingApp = createMockMigratableApp(1, 'App 1', PROJECT_NAME);
             const nonMatchingApp = createMockMigratableApp(2, 'App 2', 'Other Project');
             expect(filterFn(matchingApp)).toBe(true);
             expect(filterFn(nonMatchingApp)).toBe(false);
         });
         it('should return a function that always returns true when projectConfig is not provided', () => {
-            const filterFn = generateFilterAppsByProjectNameFunction(undefined);
+            const filterFn = (0, migrate_2.generateFilterAppsByProjectNameFunction)(undefined);
             const app1 = createMockMigratableApp(1, 'App 1', PROJECT_NAME);
             const app2 = createMockMigratableApp(2, 'App 2', 'Other Project');
             expect(filterFn(app1)).toBe(true);
@@ -145,17 +150,17 @@ describe('lib/app/migrate', () => {
         it('should return projectErrorDetail when there are no component errors', () => {
             const error = {
                 id: 123,
-                status: MIGRATION_STATUS.FAILURE,
+                status: Migration_1.MIGRATION_STATUS.FAILURE,
                 projectErrorDetail: 'Project error',
                 componentErrors: [],
             };
-            const result = buildErrorMessageFromMigrationStatus(error);
+            const result = (0, migrate_2.buildErrorMessageFromMigrationStatus)(error);
             expect(result).toBe('Project error');
         });
         it('should return formatted error message with component errors', () => {
             const error = {
                 id: 123,
-                status: MIGRATION_STATUS.FAILURE,
+                status: Migration_1.MIGRATION_STATUS.FAILURE,
                 projectErrorDetail: 'Project error',
                 componentErrors: [
                     {
@@ -169,7 +174,7 @@ describe('lib/app/migrate', () => {
                     },
                 ],
             };
-            const result = buildErrorMessageFromMigrationStatus(error);
+            const result = (0, migrate_2.buildErrorMessageFromMigrationStatus)(error);
             expect(result).toBe('Project error: \n\t- CARD (card1): Card error\n\t- FUNCTION: Function error');
         });
     });
@@ -187,18 +192,18 @@ describe('lib/app/migrate', () => {
             setupMockApps([
                 createMockMigratableApp(1, 'App 1', PROJECT_NAME),
                 createMockMigratableApp(2, 'App 2', PROJECT_NAME),
-            ], [createMockUnmigratableApp(3, 'App 3', UNMIGRATABLE_REASONS.UP_TO_DATE)]);
+            ], [createMockUnmigratableApp(3, 'App 3', projects_1.UNMIGRATABLE_REASONS.UP_TO_DATE)]);
         });
         it('should return all apps when no projectConfig is provided', async () => {
             setupMockApps([createMockMigratableApp(1, 'App 1')]);
-            const result = await fetchMigrationApps(undefined, ACCOUNT_ID, PLATFORM_VERSION);
+            const result = await (0, migrate_2.fetchMigrationApps)(undefined, ACCOUNT_ID, PLATFORM_VERSION);
             expect(result).toHaveLength(1);
             expect(result[0].appId).toBe(1);
         });
         it('should filter apps by project name when projectConfig is provided', async () => {
             const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
             setupMockApps([createMockMigratableApp(1, 'App 1', PROJECT_NAME)]);
-            const result = await fetchMigrationApps(undefined, ACCOUNT_ID, PLATFORM_VERSION, projectConfig);
+            const result = await (0, migrate_2.fetchMigrationApps)(undefined, ACCOUNT_ID, PLATFORM_VERSION, projectConfig);
             expect(result).toHaveLength(1);
             expect(result[0].projectName).toBe(PROJECT_NAME);
         });
@@ -208,36 +213,36 @@ describe('lib/app/migrate', () => {
                 createMockMigratableApp(1, 'App 1', PROJECT_NAME),
                 createMockMigratableApp(2, 'App 2', PROJECT_NAME),
             ]);
-            await expect(fetchMigrationApps(undefined, ACCOUNT_ID, PLATFORM_VERSION, projectConfig)).rejects.toThrow(lib.migrate.errors.project.multipleApps);
+            await expect((0, migrate_2.fetchMigrationApps)(undefined, ACCOUNT_ID, PLATFORM_VERSION, projectConfig)).rejects.toThrow(en_1.lib.migrate.errors.project.multipleApps);
         });
         it('should throw an error when no apps are found for a project', async () => {
             const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
             setupMockApps([], []);
-            await expect(fetchMigrationApps(undefined, ACCOUNT_ID, PLATFORM_VERSION, projectConfig)).rejects.toThrow(lib.migrate.errors.noAppsForProject(PROJECT_NAME));
+            await expect((0, migrate_2.fetchMigrationApps)(undefined, ACCOUNT_ID, PLATFORM_VERSION, projectConfig)).rejects.toThrow(en_1.lib.migrate.errors.noAppsForProject(PROJECT_NAME));
         });
         it('should throw an error when no migratable apps are found', async () => {
             setupMockApps([], mockUnmigratableApps);
-            await expect(fetchMigrationApps(undefined, ACCOUNT_ID, PLATFORM_VERSION)).rejects.toThrow(/No apps in account/);
+            await expect((0, migrate_2.fetchMigrationApps)(undefined, ACCOUNT_ID, PLATFORM_VERSION)).rejects.toThrow(/No apps in account/);
         });
         it('should throw an error when appId is provided but not found', async () => {
-            await expect(fetchMigrationApps(999, ACCOUNT_ID, PLATFORM_VERSION)).rejects.toThrow(/No apps in account/);
+            await expect((0, migrate_2.fetchMigrationApps)(999, ACCOUNT_ID, PLATFORM_VERSION)).rejects.toThrow(/No apps in account/);
         });
     });
     describe('promptForAppToMigrate', () => {
         const mockApps = [
             createMockMigratableApp(1, 'App 1'),
-            createMockUnmigratableApp(2, 'App 2', UNMIGRATABLE_REASONS.UP_TO_DATE),
+            createMockUnmigratableApp(2, 'App 2', projects_1.UNMIGRATABLE_REASONS.UP_TO_DATE),
         ];
         beforeEach(() => {
             mockedListPrompt.mockResolvedValue(mockApps[0]);
         });
         it('should prompt the user to select an app', async () => {
-            await promptForAppToMigrate(mockApps, ACCOUNT_ID);
-            expect(mockedListPrompt).toHaveBeenCalledWith(lib.migrate.prompt.chooseApp, expect.any(Object));
+            await (0, migrate_2.promptForAppToMigrate)(mockApps, ACCOUNT_ID);
+            expect(mockedListPrompt).toHaveBeenCalledWith(en_1.lib.migrate.prompt.chooseApp, expect.any(Object));
         });
         it('should return the selected app', async () => {
             mockedListPrompt.mockResolvedValue({ appId: mockApps[0].appId });
-            const result = await promptForAppToMigrate(mockApps, ACCOUNT_ID);
+            const result = await (0, migrate_2.promptForAppToMigrate)(mockApps, ACCOUNT_ID);
             expect(result).toBe(mockApps[0].appId);
         });
     });
@@ -252,26 +257,26 @@ describe('lib/app/migrate', () => {
                     { id: '2', componentType: 'FUNCTION', isSupported: false },
                 ],
             },
-            createMockUnmigratableApp(2, 'App 2', UNMIGRATABLE_REASONS.UP_TO_DATE),
+            createMockUnmigratableApp(2, 'App 2', projects_1.UNMIGRATABLE_REASONS.UP_TO_DATE),
         ];
         beforeEach(() => {
             mockedListPrompt.mockResolvedValue({ appId: 1 });
             mockedConfirmPrompt.mockResolvedValue(true);
         });
         it('should throw an error when appId is provided but not found', async () => {
-            await expect(selectAppToMigrate(mockApps, ACCOUNT_ID, 999)).rejects.toThrow(lib.migrate.errors.appWithAppIdNotFound(999));
+            await expect((0, migrate_2.selectAppToMigrate)(mockApps, ACCOUNT_ID, 999)).rejects.toThrow(en_1.lib.migrate.errors.appWithAppIdNotFound(999));
         });
         it('should call listPrompt when appId is not provided', async () => {
-            await selectAppToMigrate(mockApps, ACCOUNT_ID);
-            expect(mockedListPrompt).toHaveBeenCalledWith(lib.migrate.prompt.chooseApp, expect.any(Object));
+            await (0, migrate_2.selectAppToMigrate)(mockApps, ACCOUNT_ID);
+            expect(mockedListPrompt).toHaveBeenCalledWith(en_1.lib.migrate.prompt.chooseApp, expect.any(Object));
         });
         it('should return proceed: false and appIdToMigrate when user cancels', async () => {
             mockedConfirmPrompt.mockResolvedValue(false);
-            const result = await selectAppToMigrate(mockApps, ACCOUNT_ID);
+            const result = await (0, migrate_2.selectAppToMigrate)(mockApps, ACCOUNT_ID);
             expect(result).toEqual({ proceed: false, appIdToMigrate: 1 });
         });
         it('should return proceed: true and appIdToMigrate when user confirms', async () => {
-            const result = await selectAppToMigrate(mockApps, ACCOUNT_ID);
+            const result = await (0, migrate_2.selectAppToMigrate)(mockApps, ACCOUNT_ID);
             expect(result).toEqual({ proceed: true, appIdToMigrate: 1 });
         });
     });
@@ -300,7 +305,7 @@ describe('lib/app/migrate', () => {
         }
         it('should return early when user cancels', async () => {
             mockedConfirmPrompt.mockResolvedValueOnce(false);
-            const result = await handleMigrationSetup(ACCOUNT_ID, defaultOptions);
+            const result = await (0, migrate_2.handleMigrationSetup)(ACCOUNT_ID, defaultOptions);
             expect(result).toEqual({});
         });
         it('should return project details when projectConfig is provided', async () => {
@@ -312,7 +317,7 @@ describe('lib/app/migrate', () => {
                     unmigratableApps: [],
                 },
             });
-            const result = await handleMigrationSetup(ACCOUNT_ID, defaultOptions, projectConfig);
+            const result = await (0, migrate_2.handleMigrationSetup)(ACCOUNT_ID, defaultOptions, projectConfig);
             expect(result).toEqual({
                 appIdToMigrate: 1,
                 projectName: PROJECT_NAME,
@@ -322,18 +327,18 @@ describe('lib/app/migrate', () => {
         it('should prompt for project name when not provided', async () => {
             const optionsWithoutName = { ...defaultOptions, name: undefined };
             mockedInputPrompt.mockResolvedValue('New Project');
-            await handleMigrationSetup(ACCOUNT_ID, optionsWithoutName);
-            expect(mockedInputPrompt).toHaveBeenCalledWith(lib.migrate.prompt.inputName, expect.any(Object));
+            await (0, migrate_2.handleMigrationSetup)(ACCOUNT_ID, optionsWithoutName);
+            expect(mockedInputPrompt).toHaveBeenCalledWith(en_1.lib.migrate.prompt.inputName, expect.any(Object));
         });
         it('should prompt for project destination when not provided', async () => {
             const optionsWithoutDest = { ...defaultOptions, dest: undefined };
             mockedInputPrompt.mockResolvedValue('/mock/new/dest');
-            await handleMigrationSetup(ACCOUNT_ID, optionsWithoutDest);
-            expect(mockedInputPrompt).toHaveBeenCalledWith(lib.migrate.prompt.inputDest, expect.any(Object));
+            await (0, migrate_2.handleMigrationSetup)(ACCOUNT_ID, optionsWithoutDest);
+            expect(mockedInputPrompt).toHaveBeenCalledWith(en_1.lib.migrate.prompt.inputDest, expect.any(Object));
         });
         it('should throw an error when project already exists', async () => {
             mockedEnsureProjectExists.mockResolvedValue({ projectExists: true });
-            await expect(handleMigrationSetup(ACCOUNT_ID, defaultOptions)).rejects.toThrow(lib.migrate.errors.project.alreadyExists(PROJECT_NAME));
+            await expect((0, migrate_2.handleMigrationSetup)(ACCOUNT_ID, defaultOptions)).rejects.toThrow(en_1.lib.migrate.errors.project.alreadyExists(PROJECT_NAME));
         });
     });
     describe('beginMigration', () => {
@@ -343,14 +348,14 @@ describe('lib/app/migrate', () => {
                 data: { migrationId: MIGRATION_ID },
             });
             mockedPoll.mockResolvedValue({
-                status: MIGRATION_STATUS.INPUT_REQUIRED,
+                status: Migration_1.MIGRATION_STATUS.INPUT_REQUIRED,
                 // @ts-expect-error
                 componentsRequiringUids: {},
             });
             mockedInputPrompt.mockResolvedValue('test-uid');
         });
         it('should initialize migration and return migrationId and uidMap', async () => {
-            const result = await beginMigration(ACCOUNT_ID, APP_ID, PLATFORM_VERSION);
+            const result = await (0, migrate_2.beginMigration)(ACCOUNT_ID, APP_ID, PLATFORM_VERSION);
             expect(result).toEqual({
                 migrationId: MIGRATION_ID,
                 uidMap: {},
@@ -359,7 +364,7 @@ describe('lib/app/migrate', () => {
         it('should prompt for UIDs when components require them', async () => {
             const componentHint = 'test-card';
             mockedPoll.mockResolvedValue({
-                status: MIGRATION_STATUS.INPUT_REQUIRED,
+                status: Migration_1.MIGRATION_STATUS.INPUT_REQUIRED,
                 // @ts-expect-error
                 componentsRequiringUids: {
                     '1': {
@@ -368,26 +373,26 @@ describe('lib/app/migrate', () => {
                     },
                 },
             });
-            await beginMigration(ACCOUNT_ID, APP_ID, PLATFORM_VERSION);
-            expect(mockedInputPrompt).toHaveBeenCalledWith(lib.migrate.prompt.uidForComponent("card 'test-card' (ID: 1)"), {
+            await (0, migrate_2.beginMigration)(ACCOUNT_ID, APP_ID, PLATFORM_VERSION);
+            expect(mockedInputPrompt).toHaveBeenCalledWith(en_1.lib.migrate.prompt.uidForComponent("card 'test-card' (ID: 1)"), {
                 defaultAnswer: componentHint,
                 validate: expect.any(Function),
             });
         });
         it('should throw an error when migration fails', async () => {
             mockedPoll.mockRejectedValue(new Error('Failed'));
-            await expect(beginMigration(ACCOUNT_ID, APP_ID, PLATFORM_VERSION)).rejects.toThrow(/Migration Failed/);
+            await expect((0, migrate_2.beginMigration)(ACCOUNT_ID, APP_ID, PLATFORM_VERSION)).rejects.toThrow(/Migration Failed/);
         });
     });
     describe('pollMigrationStatus', () => {
         it('should call poll with checkMigrationStatusV2', async () => {
             const mockStatus = {
                 id: MIGRATION_ID,
-                status: MIGRATION_STATUS.SUCCESS,
+                status: Migration_1.MIGRATION_STATUS.SUCCESS,
                 buildId: BUILD_ID,
             };
             mockedPoll.mockResolvedValue(mockStatus);
-            const result = await pollMigrationStatus(ACCOUNT_ID, MIGRATION_ID);
+            const result = await (0, migrate_2.pollMigrationStatus)(ACCOUNT_ID, MIGRATION_ID);
             expect(mockedPoll).toHaveBeenCalledWith(expect.any(Function), expect.any(Object));
             expect(result).toBe(mockStatus);
         });
@@ -400,18 +405,18 @@ describe('lib/app/migrate', () => {
                 data: { migrationId: MIGRATION_ID },
             });
             mockedPoll.mockResolvedValue({
-                status: MIGRATION_STATUS.SUCCESS,
+                status: Migration_1.MIGRATION_STATUS.SUCCESS,
                 // @ts-expect-error
                 buildId: BUILD_ID,
             });
         });
         it('should continue migration and return buildId', async () => {
-            const result = await finalizeMigration(ACCOUNT_ID, MIGRATION_ID, uidMap, PROJECT_NAME);
+            const result = await (0, migrate_2.finalizeMigration)(ACCOUNT_ID, MIGRATION_ID, uidMap, PROJECT_NAME);
             expect(result).toBe(BUILD_ID);
         });
         it('should throw an error when migration fails', async () => {
             mockedPoll.mockRejectedValue(new Error('Test error'));
-            await expect(finalizeMigration(ACCOUNT_ID, MIGRATION_ID, uidMap, PROJECT_NAME)).rejects.toThrow(/Migration Failed/);
+            await expect((0, migrate_2.finalizeMigration)(ACCOUNT_ID, MIGRATION_ID, uidMap, PROJECT_NAME)).rejects.toThrow(/Migration Failed/);
         });
     });
     describe('downloadProjectFiles', () => {
@@ -425,7 +430,7 @@ describe('lib/app/migrate', () => {
             mockedSanitizeFileName.mockReturnValue(PROJECT_NAME);
         });
         it('should download and extract project files', async () => {
-            await downloadProjectFiles(ACCOUNT_ID, PROJECT_NAME, BUILD_ID, PROJECT_DEST);
+            await (0, migrate_2.downloadProjectFiles)(ACCOUNT_ID, PROJECT_NAME, BUILD_ID, PROJECT_DEST);
             expect(mockedDownloadProject).toHaveBeenCalledWith(ACCOUNT_ID, PROJECT_NAME, BUILD_ID);
             expect(mockedExtractZipArchive).toHaveBeenCalledWith(expect.any(Buffer), PROJECT_NAME, expect.stringContaining(PROJECT_DEST), {
                 includesRootDir: true,
@@ -437,7 +442,7 @@ describe('lib/app/migrate', () => {
                 projectConfig: { name: PROJECT_NAME, srcDir: 'src' },
                 projectDir: MOCK_PROJECT_DIR,
             };
-            await downloadProjectFiles(ACCOUNT_ID, PROJECT_NAME, BUILD_ID, PROJECT_DEST, projectConfig);
+            await (0, migrate_2.downloadProjectFiles)(ACCOUNT_ID, PROJECT_NAME, BUILD_ID, PROJECT_DEST, projectConfig);
             expect(mockedFs.renameSync).toHaveBeenCalledWith(`${MOCK_PROJECT_DIR}/src`, `${MOCK_PROJECT_DIR}/archive`);
             expect(mockedExtractZipArchive).toHaveBeenCalledWith(expect.any(Buffer), PROJECT_NAME, MOCK_PROJECT_DIR, {
                 includesRootDir: true,
@@ -447,7 +452,7 @@ describe('lib/app/migrate', () => {
         it('should throw an error when download fails', async () => {
             const error = new Error('Download failed');
             mockedDownloadProject.mockRejectedValue(error);
-            await expect(downloadProjectFiles(ACCOUNT_ID, PROJECT_NAME, BUILD_ID, PROJECT_DEST)).rejects.toThrow(error);
+            await expect((0, migrate_2.downloadProjectFiles)(ACCOUNT_ID, PROJECT_NAME, BUILD_ID, PROJECT_DEST)).rejects.toThrow(error);
         });
     });
     describe('migrateApp2025_2', () => {
@@ -463,27 +468,27 @@ describe('lib/app/migrate', () => {
         });
         it('should throw an error when account is not ungated for unified apps', async () => {
             mockedHasFeature.mockResolvedValueOnce(false);
-            await expect(migrateApp2025_2(ACCOUNT_ID, options)).rejects.toThrowError(/isn't enrolled in the required product beta to access this command./);
+            await expect((0, migrate_2.migrateApp2025_2)(ACCOUNT_ID, options)).rejects.toThrowError(/isn't enrolled in the required product beta to access this command./);
         });
         it('should throw an error when projectConfig is invalid', async () => {
             const invalidProjectConfig = {
                 projectConfig: undefined,
                 projectDir: '/mock/project/dir',
             };
-            await expect(migrateApp2025_2(ACCOUNT_ID, options, invalidProjectConfig)).rejects.toThrow(/The project configuration file is invalid/);
+            await expect((0, migrate_2.migrateApp2025_2)(ACCOUNT_ID, options, invalidProjectConfig)).rejects.toThrow(/The project configuration file is invalid/);
         });
         it('should throw an error when project does not exist', async () => {
             const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
             mockedEnsureProjectExists.mockResolvedValueOnce({
                 projectExists: false,
             });
-            await expect(migrateApp2025_2(ACCOUNT_ID, options, projectConfig)).rejects.toThrow(/Migrations are only supported for existing projects/);
+            await expect((0, migrate_2.migrateApp2025_2)(ACCOUNT_ID, options, projectConfig)).rejects.toThrow(/Migrations are only supported for existing projects/);
         });
     });
     describe('logInvalidAccountError', () => {
         it('should log the invalid account error message', () => {
-            logInvalidAccountError();
-            expect(mockedLogger.error).toHaveBeenCalledWith(lib.migrate.errors.invalidAccountTypeTitle);
+            (0, migrate_2.logInvalidAccountError)();
+            expect(mockedLogger.error).toHaveBeenCalledWith(en_1.lib.migrate.errors.invalidAccountTypeTitle);
             expect(mockedLogger.log).toHaveBeenCalledWith(expect.stringContaining('Only public apps created in a developer account can be converted to a project component'));
         });
     });

package/lib/app/__tests__/migrate_legacy.test.js

@@ -1,14 +1,16 @@
-import { fetchPublicAppMetadata as _fetchPublicAppMetadata } from '@hubspot/local-dev-lib/api/appsDev';
-import { downloadProject as _downloadProject, migrateApp as _migrateNonProjectApp_v2023_2, } from '@hubspot/local-dev-lib/api/projects';
-import { extractZipArchive } from '@hubspot/local-dev-lib/archive';
-import { promptUser as _promptUser } from '../../prompts/promptUtils.js';
-import { EXIT_CODES } from '../../enums/exitCodes.js';
-import { isAppDeveloperAccount as _isAppDeveloperAccount, isUnifiedAccount as _isUnifiedAccount, } from '../../accountTypes.js';
-import { selectPublicAppForMigrationPrompt as _selectPublicAppForMigrationPrompt } from '../../prompts/selectPublicAppForMigrationPrompt.js';
-import { projectNameAndDestPrompt as _projectNameAndDestPrompt } from '../../prompts/projectNameAndDestPrompt.js';
-import { ensureProjectExists as _ensureProjectExists } from '../../projects/ensureProjectExists.js';
-import { poll as _poll } from '../../polling.js';
-import { migrateApp2023_2 } from '../migrate_legacy.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const appsDev_1 = require("@hubspot/local-dev-lib/api/appsDev");
+const projects_1 = require("@hubspot/local-dev-lib/api/projects");
+const archive_1 = require("@hubspot/local-dev-lib/archive");
+const promptUtils_1 = require("../../prompts/promptUtils");
+const exitCodes_1 = require("../../enums/exitCodes");
+const accountTypes_1 = require("../../accountTypes");
+const selectPublicAppForMigrationPrompt_1 = require("../../prompts/selectPublicAppForMigrationPrompt");
+const projectNameAndDestPrompt_1 = require("../../prompts/projectNameAndDestPrompt");
+const ensureProjectExists_1 = require("../../projects/ensureProjectExists");
+const polling_1 = require("../../polling");
+const migrate_legacy_1 = require("../migrate_legacy");
 // Mock all external dependencies
 vi.mock('@hubspot/local-dev-lib/api/appsDev');
 vi.mock('@hubspot/local-dev-lib/logger');
@@ -26,16 +28,16 @@ vi.mock('../../usageTracking');
 vi.mock('../../ui/SpinniesManager');
 vi.mock('../../process');
 vi.mock('../../polling');
-const isAppDeveloperAccount = _isAppDeveloperAccount;
-const isUnifiedAccount = _isUnifiedAccount;
-const selectPublicAppForMigrationPrompt = _selectPublicAppForMigrationPrompt;
-const projectNameAndDestPrompt = _projectNameAndDestPrompt;
-const ensureProjectExists = _ensureProjectExists;
-const poll = _poll;
-const fetchPublicAppMetadata = _fetchPublicAppMetadata;
-const migrateNonProjectApp_v2023_2 = _migrateNonProjectApp_v2023_2;
-const downloadProject = _downloadProject;
-const promptUser = _promptUser;
+const isAppDeveloperAccount = accountTypes_1.isAppDeveloperAccount;
+const isUnifiedAccount = accountTypes_1.isUnifiedAccount;
+const selectPublicAppForMigrationPrompt = selectPublicAppForMigrationPrompt_1.selectPublicAppForMigrationPrompt;
+const projectNameAndDestPrompt = projectNameAndDestPrompt_1.projectNameAndDestPrompt;
+const ensureProjectExists = ensureProjectExists_1.ensureProjectExists;
+const poll = polling_1.poll;
+const fetchPublicAppMetadata = appsDev_1.fetchPublicAppMetadata;
+const migrateNonProjectApp_v2023_2 = projects_1.migrateApp;
+const downloadProject = projects_1.downloadProject;
+const promptUser = promptUtils_1.promptUser;
 describe('migrateApp2023_2', () => {
     const mockDerivedAccountId = 123;
     const mockOptions = {
@@ -94,12 +96,12 @@ describe('migrateApp2023_2', () => {
     });
     it('should exit if account is not an app developer account and not unified', async () => {
         isAppDeveloperAccount.mockReturnValue(false);
-        await migrateApp2023_2(mockDerivedAccountId, mockOptions, mockAccountConfig);
+        await (0, migrate_legacy_1.migrateApp2023_2)(mockDerivedAccountId, mockOptions, mockAccountConfig);
         expect(migrateNonProjectApp_v2023_2).not.toHaveBeenCalled();
-        expect(process.exit).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        expect(process.exit).toHaveBeenCalledWith(exitCodes_1.EXIT_CODES.SUCCESS);
     });
     it('should proceed with migration for valid app developer account', async () => {
-        await migrateApp2023_2(mockDerivedAccountId, mockOptions, mockAccountConfig);
+        await (0, migrate_legacy_1.migrateApp2023_2)(mockDerivedAccountId, mockOptions, mockAccountConfig);
         expect(selectPublicAppForMigrationPrompt).toHaveBeenCalled();
         expect(fetchPublicAppMetadata).toHaveBeenCalledWith(appId, mockDerivedAccountId);
         expect(projectNameAndDestPrompt).toHaveBeenCalled();
@@ -107,12 +109,12 @@ describe('migrateApp2023_2', () => {
         expect(migrateNonProjectApp_v2023_2).toHaveBeenCalled();
         expect(poll).toHaveBeenCalled();
         expect(downloadProject).toHaveBeenCalled();
-        expect(extractZipArchive).toHaveBeenCalled();
+        expect(archive_1.extractZipArchive).toHaveBeenCalled();
     });
     it('should handle migration failure gracefully', async () => {
         const errorMessage = 'Migration failed';
         migrateNonProjectApp_v2023_2.mockRejectedValue(new Error(errorMessage));
-        await expect(migrateApp2023_2(mockDerivedAccountId, mockOptions, mockAccountConfig)).rejects.toThrow(errorMessage);
+        await expect((0, migrate_legacy_1.migrateApp2023_2)(mockDerivedAccountId, mockOptions, mockAccountConfig)).rejects.toThrow(errorMessage);
     });
     it('should handle non-migratable apps', async () => {
         fetchPublicAppMetadata.mockResolvedValue({
@@ -122,13 +124,13 @@ describe('migrateApp2023_2', () => {
                 listingInfo: { someInfo: 'test' },
             },
         });
-        await migrateApp2023_2(mockDerivedAccountId, mockOptions, mockAccountConfig);
-        expect(process.exit).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        await (0, migrate_legacy_1.migrateApp2023_2)(mockDerivedAccountId, mockOptions, mockAccountConfig);
+        expect(process.exit).toHaveBeenCalledWith(exitCodes_1.EXIT_CODES.ERROR);
     });
     it('should handle existing project error', async () => {
         ensureProjectExists.mockResolvedValue({
             projectExists: true,
         });
-        await expect(migrateApp2023_2(mockDerivedAccountId, mockOptions, mockAccountConfig)).rejects.toThrow('A project with name test-project already exists');
+        await expect((0, migrate_legacy_1.migrateApp2023_2)(mockDerivedAccountId, mockOptions, mockAccountConfig)).rejects.toThrow('A project with name test-project already exists');
     });
 });

package/lib/app/migrate.d.ts

@@ -1,7 +1,7 @@
 import { ArgumentsCamelCase } from 'yargs';
-import { LoadedProjectConfig } from '../projects/config.js';
-import { MigrationApp, MigrationFailed, MigrationStatus } from '../../api/migrate.js';
-import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs } from '../../types/Yargs.js';
+import { LoadedProjectConfig } from '../projects/config';
+import { MigrationApp, MigrationFailed, MigrationStatus } from '../../api/migrate';
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs } from '../../types/Yargs';
 export type MigrateAppArgs = CommonArgs & AccountArgs & EnvironmentArgs & ConfigArgs & {
     name?: string;
     dest?: string;