feat: Add hs app migrate command

api/__tests__/migrate.test.ts

@@ -0,0 +1,190 @@
+import { http } from '@hubspot/local-dev-lib/http';
+import { MIGRATION_STATUS } from '@hubspot/local-dev-lib/types/Migration';
+import {
+  listAppsForMigration,
+  initializeMigration,
+  continueMigration,
+  checkMigrationStatusV2,
+  ListAppsResponse,
+  MigrationStatus,
+} from '../migrate';
+
+jest.mock('@hubspot/local-dev-lib/http');
+
+const httpMock = http as jest.Mocked<typeof http>;
+
+describe('api/migrate', () => {
+  const mockAccountId = 12345;
+  const mockPortalId = 12345;
+  const mockAppId = 67890;
+  const mockMigrationId = 54321;
+  const mockPlatformVersion = '2025.2';
+  const mockProjectName = 'Test Project';
+  const mockComponentUids = { 'component-1': 'uid-1', 'component-2': 'uid-2' };
+
+  describe('listAppsForMigration', () => {
+    it('should call http.get with correct parameters', async () => {
+      const mockResponse: ListAppsResponse = {
+        migratableApps: [
+          {
+            appId: 1,
+            appName: 'App 1',
+            isMigratable: true,
+            migrationComponents: [
+              { id: 'comp1', componentType: 'type1', isSupported: true },
+            ],
+          },
+        ],
+        unmigratableApps: [
+          {
+            appId: 2,
+            appName: 'App 2',
+            isMigratable: false,
+            unmigratableReason: 'UP_TO_DATE',
+            migrationComponents: [
+              { id: 'comp2', componentType: 'type2', isSupported: false },
+            ],
+          },
+        ],
+      };
+
+      // @ts-expect-error Mock
+      httpMock.get.mockResolvedValue(mockResponse);
+
+      const result = await listAppsForMigration(mockAccountId);
+
+      expect(http.get).toHaveBeenCalledWith(mockAccountId, {
+        url: 'dfs/migrations/v2/list-apps',
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('initializeMigration', () => {
+    it('should call http.post with correct parameters', async () => {
+      const mockResponse = { migrationId: mockMigrationId };
+      // @ts-expect-error Mock
+      httpMock.post.mockResolvedValue(mockResponse);
+
+      const result = await initializeMigration(
+        mockAccountId,
+        mockAppId,
+        mockPlatformVersion
+      );
+
+      expect(http.post).toHaveBeenCalledWith(mockAccountId, {
+        url: 'dfs/migrations/v2/migrations',
+        data: {
+          applicationId: mockAppId,
+          platformVersion: 'V2025_2',
+        },
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('continueMigration', () => {
+    it('should call http.post with correct parameters', async () => {
+      const mockResponse = { migrationId: mockMigrationId };
+      // @ts-expect-error Mock
+      httpMock.post.mockResolvedValue(mockResponse);
+
+      const result = await continueMigration(
+        mockPortalId,
+        mockMigrationId,
+        mockComponentUids,
+        mockProjectName
+      );
+
+      expect(http.post).toHaveBeenCalledWith(mockPortalId, {
+        url: 'dfs/migrations/v2/migrations/continue',
+        data: {
+          migrationId: mockMigrationId,
+          projectName: mockProjectName,
+          componentUids: mockComponentUids,
+        },
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('checkMigrationStatusV2', () => {
+    it('should call http.get with correct parameters for in-progress status', async () => {
+      const mockResponse: MigrationStatus = {
+        id: mockMigrationId,
+        status: MIGRATION_STATUS.IN_PROGRESS,
+      };
+      // @ts-expect-error Mock
+      httpMock.get.mockResolvedValue(mockResponse);
+
+      const result = await checkMigrationStatusV2(
+        mockAccountId,
+        mockMigrationId
+      );
+
+      expect(http.get).toHaveBeenCalledWith(mockAccountId, {
+        url: `dfs/migrations/v2/migrations/${mockMigrationId}/status`,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should handle input required status', async () => {
+      const mockResponse: MigrationStatus = {
+        id: mockMigrationId,
+        status: MIGRATION_STATUS.INPUT_REQUIRED,
+        componentsRequiringUids: {
+          'component-1': {
+            componentType: 'type1',
+            componentHint: 'hint1',
+          },
+        },
+      };
+      // @ts-expect-error Mock
+      httpMock.get.mockResolvedValue(mockResponse);
+
+      const result = await checkMigrationStatusV2(
+        mockAccountId,
+        mockMigrationId
+      );
+
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should handle success status', async () => {
+      const mockResponse: MigrationStatus = {
+        id: mockMigrationId,
+        status: MIGRATION_STATUS.SUCCESS,
+        buildId: 98765,
+      };
+      // @ts-expect-error Mock
+      httpMock.get.mockResolvedValue(mockResponse);
+
+      const result = await checkMigrationStatusV2(
+        mockAccountId,
+        mockMigrationId
+      );
+
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should handle failure status', async () => {
+      const mockResponse: MigrationStatus = {
+        id: mockMigrationId,
+        status: MIGRATION_STATUS.FAILURE,
+        projectErrorsDetail: 'Error details',
+        componentErrorDetails: {
+          'component-1': 'Component error',
+        },
+      };
+      // @ts-expect-error Mock
+      httpMock.get.mockResolvedValue(mockResponse);
+
+      const result = await checkMigrationStatusV2(
+        mockAccountId,
+        mockMigrationId
+      );
+
+      expect(result).toEqual(mockResponse);
+    });
+  });
+});

api/migrate.ts

@@ -0,0 +1,138 @@
+import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
+import {
+  PLATFORM_VERSIONS,
+  UNMIGRATABLE_REASONS,
+} from '@hubspot/local-dev-lib/constants/projects';
+import { http } from '@hubspot/local-dev-lib/http';
+import { MIGRATION_STATUS } from '@hubspot/local-dev-lib/types/Migration';
+
+const MIGRATIONS_API_PATH_V2 = 'dfs/migrations/v2';
+
+interface BaseMigrationApp {
+  appId: number;
+  appName: string;
+  isMigratable: boolean;
+  migrationComponents: ListAppsMigrationComponent[];
+  projectName?: string;
+}
+
+export interface MigratableApp extends BaseMigrationApp {
+  isMigratable: true;
+}
+
+export interface UnmigratableApp extends BaseMigrationApp {
+  isMigratable: false;
+  unmigratableReason: keyof typeof UNMIGRATABLE_REASONS;
+}
+
+export type MigrationApp = MigratableApp | UnmigratableApp;
+
+export interface ListAppsResponse {
+  migratableApps: MigratableApp[];
+  unmigratableApps: UnmigratableApp[];
+}
+
+export interface InitializeMigrationResponse {
+  migrationId: number;
+}
+
+export interface ListAppsMigrationComponent {
+  id: string;
+  componentType: string;
+  isSupported: boolean;
+}
+
+export type ContinueMigrationResponse = {
+  migrationId: number;
+};
+
+export interface MigrationBaseStatus {
+  id: number;
+}
+
+export interface MigrationInProgress extends MigrationBaseStatus {
+  status: typeof MIGRATION_STATUS.IN_PROGRESS;
+}
+
+export interface MigrationInputRequired extends MigrationBaseStatus {
+  status: typeof MIGRATION_STATUS.INPUT_REQUIRED;
+  componentsRequiringUids: Record<
+    string,
+    {
+      componentType: string;
+      componentHint: string;
+    }
+  >;
+}
+
+export interface MigrationSuccess extends MigrationBaseStatus {
+  status: typeof MIGRATION_STATUS.SUCCESS;
+  buildId: number;
+}
+
+export interface MigrationFailed extends MigrationBaseStatus {
+  status: typeof MIGRATION_STATUS.FAILURE;
+  projectErrorsDetail?: string;
+  componentErrorDetails: Record<string, string>;
+}
+
+export type MigrationStatus =
+  | MigrationInProgress
+  | MigrationInputRequired
+  | MigrationSuccess
+  | MigrationFailed;
+
+export async function listAppsForMigration(
+  accountId: number
+): HubSpotPromise<ListAppsResponse> {
+  return http.get<ListAppsResponse>(accountId, {
+    url: `${MIGRATIONS_API_PATH_V2}/list-apps`,
+  });
+}
+
+function mapPlatformVersionToEnum(platformVersion: string): string {
+  if (platformVersion === PLATFORM_VERSIONS.unstable) {
+    return PLATFORM_VERSIONS.unstable.toUpperCase();
+  }
+
+  return `V${platformVersion.replace('.', '_')}`;
+}
+
+export async function initializeMigration(
+  accountId: number,
+  applicationId: number,
+  platformVersion: string
+): HubSpotPromise<InitializeMigrationResponse> {
+  return http.post(accountId, {
+    url: `${MIGRATIONS_API_PATH_V2}/migrations`,
+    data: {
+      applicationId,
+      platformVersion: mapPlatformVersionToEnum(platformVersion),
+    },
+  });
+}
+
+export async function continueMigration(
+  portalId: number,
+  migrationId: number,
+  componentUids: Record<string, string>,
+  projectName: string
+): HubSpotPromise<ContinueMigrationResponse> {
+  return http.post(portalId, {
+    url: `${MIGRATIONS_API_PATH_V2}/migrations/continue`,
+    data: {
+      migrationId,
+      projectName,
+      componentUids,
+    },
+  });
+}
+
+export function checkMigrationStatusV2(
+  accountId: number,
+  id: number
+): HubSpotPromise<MigrationStatus> {
+  return http.get<MigrationStatus>(accountId, {
+    url: `${MIGRATIONS_API_PATH_V2}/migrations/${id}/status`,
+  });
+}

bin/cli.js

@@ -51,6 +51,7 @@ const cmsCommand = require('../commands/cms');
 const feedbackCommand = require('../commands/feedback');
 const doctorCommand = require('../commands/doctor');
 const completionCommand = require('../commands/completion');
+const appCommand = require('../commands/app');
 
 notifyAboutUpdates();
 
@@ -134,6 +135,7 @@ const argv = yargs
   .command(feedbackCommand)
   .command(doctorCommand)
   .command(completionCommand)
+  .command(appCommand)
   .help()
   .alias('h', 'help')
   .recommendCommands()

commands/__tests__/project.test.ts

@@ -25,10 +25,11 @@ jest.mock('../project/download');
 jest.mock('../project/open');
 jest.mock('../project/dev');
 jest.mock('../project/add');
-jest.mock('../project/migrateApp');
-jest.mock('../project/cloneApp');
+jest.mock('../project/migrateApp', () => ({}));
+jest.mock('../project/cloneApp', () => ({}));
 jest.mock('../project/installDeps');
 jest.mock('../../lib/commonOpts');
+
 yargs.command.mockReturnValue(yargs);
 yargs.demandCommand.mockReturnValue(yargs);
 

commands/app.ts

@@ -0,0 +1,22 @@
+import migrateCommand from './app/migrate';
+import { addGlobalOptions } from '../lib/commonOpts';
+import { Argv, CommandModule } from 'yargs';
+
+export const command = ['app', 'apps'];
+
+// Keep the command hidden for now
+export const describe = undefined;
+
+export function builder(yargs: Argv) {
+  addGlobalOptions(yargs);
+
+  return yargs.command(migrateCommand).demandCommand(1, '');
+}
+
+const appCommand: CommandModule = {
+  command,
+  describe,
+  builder,
+  handler: () => {},
+};
+export default appCommand;