@hubspot/cli 7.7.0-experimental.3 → 7.7.0

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

@@ -0,0 +1,134 @@
+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';
+// Mock all external dependencies
+vi.mock('@hubspot/local-dev-lib/api/appsDev');
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('@hubspot/local-dev-lib/api/projects');
+vi.mock('@hubspot/local-dev-lib/path');
+vi.mock('@hubspot/local-dev-lib/urls');
+vi.mock('@hubspot/local-dev-lib/archive');
+vi.mock('../../prompts/promptUtils');
+vi.mock('../../errorHandlers');
+vi.mock('../../accountTypes');
+vi.mock('../../prompts/selectPublicAppForMigrationPrompt');
+vi.mock('../../prompts/projectNameAndDestPrompt');
+vi.mock('../../projects/ensureProjectExists');
+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;
+describe('migrateApp2023_2', () => {
+    const mockDerivedAccountId = 123;
+    const mockOptions = {
+        _: [],
+        $0: 'test',
+        derivedAccountId: 123,
+        d: false,
+        debug: false,
+        platformVersion: '2023.2',
+        unstable: false,
+    };
+    const mockAccountConfig = {
+        accountId: 123,
+        name: 'Test Account',
+        env: 'prod',
+    };
+    const appId = 12345;
+    const projectName = 'test-project';
+    beforeEach(() => {
+        // @ts-expect-error function mismatch
+        vi.spyOn(process, 'exit').mockImplementation(() => { });
+        selectPublicAppForMigrationPrompt.mockResolvedValue({
+            appId,
+        });
+        isAppDeveloperAccount.mockReturnValue(true);
+        isUnifiedAccount.mockResolvedValue(false);
+        fetchPublicAppMetadata.mockResolvedValue({
+            // @ts-expect-error Mocking the return type
+            data: { preventProjectMigrations: false },
+        });
+        projectNameAndDestPrompt.mockResolvedValue({
+            name: projectName,
+            dest: '/test/dest',
+        });
+        promptUser.mockResolvedValue({
+            shouldCreateApp: true,
+        });
+        ensureProjectExists.mockResolvedValue({
+            projectExists: false,
+        });
+        migrateNonProjectApp_v2023_2.mockResolvedValue({
+            // @ts-expect-error Mocking the return type
+            data: { id: 'migration-id' },
+        });
+        poll.mockResolvedValue({
+            status: 'SUCCESS',
+            // @ts-expect-error
+            project: {
+                name: projectName,
+            },
+        });
+        downloadProject.mockResolvedValue({
+            // @ts-expect-error Mocking the return type
+            data: 'zipped-project-data',
+        });
+    });
+    it('should exit if account is not an app developer account and not unified', async () => {
+        isAppDeveloperAccount.mockReturnValue(false);
+        await migrateApp2023_2(mockDerivedAccountId, mockOptions, mockAccountConfig);
+        expect(migrateNonProjectApp_v2023_2).not.toHaveBeenCalled();
+        expect(process.exit).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+    });
+    it('should proceed with migration for valid app developer account', async () => {
+        await migrateApp2023_2(mockDerivedAccountId, mockOptions, mockAccountConfig);
+        expect(selectPublicAppForMigrationPrompt).toHaveBeenCalled();
+        expect(fetchPublicAppMetadata).toHaveBeenCalledWith(appId, mockDerivedAccountId);
+        expect(projectNameAndDestPrompt).toHaveBeenCalled();
+        expect(ensureProjectExists).toHaveBeenCalled();
+        expect(migrateNonProjectApp_v2023_2).toHaveBeenCalled();
+        expect(poll).toHaveBeenCalled();
+        expect(downloadProject).toHaveBeenCalled();
+        expect(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);
+    });
+    it('should handle non-migratable apps', async () => {
+        fetchPublicAppMetadata.mockResolvedValue({
+            data: {
+                preventProjectMigrations: true,
+                // @ts-expect-error
+                listingInfo: { someInfo: 'test' },
+            },
+        });
+        await migrateApp2023_2(mockDerivedAccountId, mockOptions, mockAccountConfig);
+        expect(process.exit).toHaveBeenCalledWith(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');
+    });
+});

package/lib/app/migrate.d.ts

@@ -1,7 +1,7 @@
 import { ArgumentsCamelCase } from 'yargs';
-import { LoadedProjectConfig } from '../projects/config';
-import { MigrationApp, MigrationFailed, MigrationStatus } from '../../api/migrate';
-import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs } from '../../types/Yargs';
+import { LoadedProjectConfig } from '../projects/config.js';
+import { MigrationApp, MigratableApp, UnmigratableApp, MigrationFailed, MigrationStatus } from '../../api/migrate.js';
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs } from '../../types/Yargs.js';
 export type MigrateAppArgs = CommonArgs & AccountArgs & EnvironmentArgs & ConfigArgs & {
     name?: string;
     dest?: string;
@@ -12,7 +12,14 @@ export type MigrateAppArgs = CommonArgs & AccountArgs & EnvironmentArgs & Config
 export declare function getUnmigratableReason(reasonCode: string, projectName: string | undefined, accountId: number): string;
 export declare function generateFilterAppsByProjectNameFunction(projectConfig?: LoadedProjectConfig): (app: MigrationApp) => boolean;
 export declare function buildErrorMessageFromMigrationStatus(error: MigrationFailed): string;
-export declare function fetchMigrationApps(appId: MigrateAppArgs['appId'], derivedAccountId: number, platformVersion: string, projectConfig?: LoadedProjectConfig): Promise<MigrationApp[]>;
+export declare function fetchMigrationApps(derivedAccountId: number, platformVersion: string, projectConfig?: LoadedProjectConfig): Promise<{
+    migratableApps: MigratableApp[];
+    unmigratableApps: UnmigratableApp[];
+}>;
+export declare function validateMigrationApps(appId: MigrateAppArgs['appId'], derivedAccountId: number, { migratableApps, unmigratableApps, }: {
+    migratableApps: MigratableApp[];
+    unmigratableApps: UnmigratableApp[];
+}, projectConfig?: LoadedProjectConfig): Promise<void>;
 export declare function promptForAppToMigrate(allApps: MigrationApp[], derivedAccountId: number): Promise<number>;
 export declare function selectAppToMigrate(allApps: MigrationApp[], derivedAccountId: number, appId?: number): Promise<{
     proceed: boolean;
@@ -23,12 +30,12 @@ export declare function handleMigrationSetup(derivedAccountId: number, options:
     projectName?: string;
     projectDest?: string;
 }>;
-export declare function beginMigration(derivedAccountId: number, appId: number, platformVersion: string): Promise<{
+export declare function beginAppMigration(derivedAccountId: number, appId: number, platformVersion: string): Promise<{
     migrationId: number;
     uidMap: Record<string, string>;
 } | undefined>;
 export declare function pollMigrationStatus(derivedAccountId: number, migrationId: number, successStates?: string[]): Promise<MigrationStatus>;
-export declare function finalizeMigration(derivedAccountId: number, migrationId: number, uidMap: Record<string, string>, projectName: string): Promise<number>;
+export declare function finalizeAppMigration(derivedAccountId: number, migrationId: number, uidMap: Record<string, string>, projectName: string): Promise<number>;
 export declare function downloadProjectFiles(derivedAccountId: number, projectName: string, buildId: number, projectDest: string, projectConfig?: LoadedProjectConfig): Promise<void>;
 export declare function migrateApp2025_2(derivedAccountId: number, options: ArgumentsCamelCase<MigrateAppArgs>, projectConfig?: LoadedProjectConfig): Promise<void>;
 export declare function logInvalidAccountError(): void;