@squiz/dxp-cli-next 5.25.3 → 5.26.0-develop.1

package/lib/__tests__/integration/main.spec.js

@@ -17,6 +17,8 @@ describe('dxp', () => {
             'job-runner     Job Runner Service Commands',
             'datastore      Datastore Service Commands',
             'cdp            Customer Data Platform Service Commands',
+            // TODO: Migration is hidden behind feature flag.
+            // 'migration      AI Page Migration Service Commands',
             // TODO: Porter is hidden behind feature flag.
             // 'porter         Porter Service Commands',
         ]);
@@ -33,6 +35,8 @@ describe('dxp', () => {
             'job-runner     Job Runner Service Commands',
             'datastore      Datastore Service Commands',
             'cdp            Customer Data Platform Service Commands',
+            // TODO: Migration is hidden behind feature flag.
+            // 'migration      AI Page Migration Service Commands',
             'porter         Porter Service Commands',
         ]);
     });

package/lib/dxp.js

@@ -18,6 +18,7 @@ const datastore_1 = __importDefault(require("./datastore"));
 const cdp_1 = __importDefault(require("./cdp"));
 const porter_1 = __importDefault(require("./porter"));
 const page_1 = __importDefault(require("./page"));
+const migration_1 = __importDefault(require("./migration"));
 const program = new commander_1.default.Command();
 const packageJson = require('../package.json');
 const version = packageJson.version;
@@ -36,6 +37,9 @@ if (process.env.ENABLE_PORTER === 'true') {
 if (process.env.ENABLE_PAGE_LAYOUTS === 'true') {
     program.addCommand(page_1.default);
 }
+if (process.env.ENABLE_MIGRATION === 'true') {
+    program.addCommand(migration_1.default);
+}
 program
     .action(() => {
     program.help();

package/lib/migration/create/createMigration.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+declare const createMigrationCommand: () => Command;
+export default createMigrationCommand;

package/lib/migration/create/createMigration.js

@@ -0,0 +1,82 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs_1 = __importDefault(require("fs"));
+const utils_1 = require("../utils");
+const createMigrationCommand = () => {
+    const createCommand = new commander_1.Command('create')
+        .name('create')
+        .description('Create a new migration using the AI Page migration service')
+        .addOption(new commander_1.Option('--asset-id <string>', 'The ID of the asset to be migrated').makeOptionMandatory())
+        .addOption(new commander_1.Option('--preview-asset-id <string>', 'The ID of the folder that will be used as the parent of the migrated asset generated during the Preview stage').makeOptionMandatory())
+        .addOption(new commander_1.Option('--matrix-url <string>', 'Matrix URL for the migration').makeOptionMandatory())
+        .addOption(new commander_1.Option('-t, --tenant <string>', 'Tenant ID to run against. If not provided will use configured tenant from login'))
+        .argument('<exportPath>', 'Path to the export folder (e.g., ./export)')
+        .configureOutput({
+        outputError(str, write) {
+            write(chalk_1.default.red(str));
+        },
+    })
+        .action((exportPath, options) => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, utils_1.throwErrorIfNotLoggedIn)(createCommand);
+        let spinner = (0, ora_1.default)('Validating export folder structure').start();
+        try {
+            // Validate export folder structure
+            (0, utils_1.validateExportFolder)(exportPath);
+            spinner.succeed('Export folder structure validated');
+            // Create tar file
+            spinner = (0, ora_1.default)('Creating tar file from export folder').start();
+            const tarFilePath = yield (0, utils_1.createTarFile)(exportPath);
+            if (!tarFilePath) {
+                throw new Error('Tar file creation failed');
+            }
+            spinner.succeed(`Tar file created: ${tarFilePath}`);
+            // Create migration
+            spinner = (0, ora_1.default)('Creating migration').start();
+            const response = yield (0, utils_1.createMigration)(options);
+            if (!response) {
+                throw new Error('Migration creation failed');
+            }
+            spinner.succeed('Migration created successfully');
+            // Upload file to S3
+            spinner = (0, ora_1.default)('Uploading file to S3').start();
+            const uploadUrl = response.uploadUrl;
+            const s3Url = yield (0, utils_1.uploadFileToS3)(uploadUrl, tarFilePath, options.tenant);
+            if (!s3Url) {
+                throw new Error('File upload failed');
+            }
+            spinner.succeed('File uploaded to S3');
+            // Clean up tar file
+            fs_1.default.unlinkSync(tarFilePath);
+            spinner.succeed(`Successfully created migration: ${JSON.stringify({
+                migrationId: response.assetMigration.migrationId,
+                assetId: response.assetMigration.assetId,
+                stage: response.assetMigration.stage,
+                status: response.assetMigration.status,
+            })}`);
+        }
+        catch (error) {
+            spinner.fail();
+            (0, utils_1.handleCommandError)(createCommand, error);
+        }
+    }));
+    if (process.env.ENABLE_OVERRIDE_MIGRATION_URL === 'true') {
+        createCommand.addOption(new commander_1.Option('-ou, --overrideUrl <string>', 'Developer option to override the entire migration url with a custom value'));
+    }
+    return createCommand;
+};
+exports.default = createMigrationCommand;

package/lib/migration/create/createMigration.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/migration/create/createMigration.spec.js

@@ -0,0 +1,381 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nock_1 = __importDefault(require("nock"));
+const createMigration_1 = __importDefault(require("./createMigration"));
+const utils = __importStar(require("../utils"));
+const ApplicationStore = __importStar(require("../../ApplicationStore"));
+const fs_1 = __importDefault(require("fs"));
+jest.mock('../utils');
+jest.mock('../../ApplicationStore');
+jest.mock('fs');
+const mockUtils = utils;
+const mockApplicationStore = ApplicationStore;
+const mockFs = fs_1.default;
+describe('createMigrationCommand', () => {
+    let logSpy;
+    let mockCreateMigrationResponse;
+    beforeEach(() => {
+        nock_1.default.cleanAll();
+        jest.clearAllMocks();
+        jest.resetAllMocks();
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        mockApplicationStore.getApplicationFile.mockResolvedValue('session-cookie');
+        mockUtils.throwErrorIfNotLoggedIn.mockResolvedValue(undefined);
+        mockUtils.validateExportFolder.mockImplementation(() => { });
+        mockUtils.createTarFile.mockResolvedValue('/path/to/export_123.tar.gz');
+        mockUtils.uploadFileToS3.mockResolvedValue('https://s3.amazonaws.com/uploaded-file');
+        mockFs.unlinkSync.mockImplementation(() => { });
+        mockCreateMigrationResponse = {
+            assetMigration: {
+                migrationId: 'migration-123',
+                assetId: 'asset-456',
+                stage: 'pending',
+                status: 'created',
+                xmlFilePath: '/path/to/xml',
+                matrixUrl: 'https://matrix.example.com',
+                previewAssetId: 'preview-789',
+                created: 1234567890,
+                updated: 1234567890,
+                migrationIdAssetId: 'migration-123-asset-456',
+            },
+            uploadUrl: 'https://upload.s3.amazonaws.com',
+        };
+        mockUtils.createMigration.mockResolvedValue(mockCreateMigrationResponse);
+    });
+    afterEach(() => {
+        logSpy.mockRestore();
+    });
+    describe('successful migration creation', () => {
+        it('should create migration successfully with all required options', () => __awaiter(void 0, void 0, void 0, function* () {
+            const program = (0, createMigration_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--asset-id',
+                'asset-123',
+                '--preview-asset-id',
+                'preview-456',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '/path/to/export',
+            ]);
+            expect(mockUtils.throwErrorIfNotLoggedIn).toHaveBeenCalledWith(program);
+            expect(mockUtils.validateExportFolder).toHaveBeenCalledWith('/path/to/export');
+            expect(mockUtils.createTarFile).toHaveBeenCalledWith('/path/to/export');
+            expect(mockUtils.createMigration).toHaveBeenCalledWith({
+                assetId: 'asset-123',
+                previewAssetId: 'preview-456',
+                matrixUrl: 'https://matrix.example.com',
+            });
+            expect(mockUtils.uploadFileToS3).toHaveBeenCalledWith('https://upload.s3.amazonaws.com', '/path/to/export_123.tar.gz', undefined);
+            expect(mockFs.unlinkSync).toHaveBeenCalledWith('/path/to/export_123.tar.gz');
+            expect(mockUtils.validateExportFolder).toHaveBeenCalledTimes(1);
+            expect(mockUtils.createTarFile).toHaveBeenCalledTimes(1);
+            expect(mockUtils.createMigration).toHaveBeenCalledTimes(1);
+            expect(mockUtils.uploadFileToS3).toHaveBeenCalledTimes(1);
+            expect(mockFs.unlinkSync).toHaveBeenCalledTimes(1);
+            expect(mockUtils.handleCommandError).not.toHaveBeenCalled();
+        }));
+        it('should create migration with tenant option', () => __awaiter(void 0, void 0, void 0, function* () {
+            const program = (0, createMigration_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--asset-id',
+                'asset-123',
+                '--preview-asset-id',
+                'preview-456',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '--tenant',
+                'test-tenant',
+                '/path/to/export',
+            ]);
+            expect(mockUtils.createMigration).toHaveBeenCalledWith({
+                assetId: 'asset-123',
+                previewAssetId: 'preview-456',
+                matrixUrl: 'https://matrix.example.com',
+                tenant: 'test-tenant',
+            });
+            expect(mockUtils.uploadFileToS3).toHaveBeenCalledWith('https://upload.s3.amazonaws.com', '/path/to/export_123.tar.gz', 'test-tenant');
+        }));
+        it('should create migration with override URL when environment variable is set', () => __awaiter(void 0, void 0, void 0, function* () {
+            const originalEnv = process.env.ENABLE_OVERRIDE_MIGRATION_URL;
+            process.env.ENABLE_OVERRIDE_MIGRATION_URL = 'true';
+            const program = (0, createMigration_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--asset-id',
+                'asset-123',
+                '--preview-asset-id',
+                'preview-456',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '--overrideUrl',
+                'https://custom.migration.url',
+                '/path/to/export',
+            ]);
+            expect(mockUtils.createMigration).toHaveBeenCalledWith({
+                assetId: 'asset-123',
+                previewAssetId: 'preview-456',
+                matrixUrl: 'https://matrix.example.com',
+                overrideUrl: 'https://custom.migration.url',
+            });
+            process.env.ENABLE_OVERRIDE_MIGRATION_URL = originalEnv;
+        }));
+    });
+    describe('error scenarios', () => {
+        it('should handle validation error for export folder', () => __awaiter(void 0, void 0, void 0, function* () {
+            const validationError = new Error('Export folder does not exist');
+            mockUtils.validateExportFolder.mockImplementation(() => {
+                throw validationError;
+            });
+            mockUtils.handleCommandError.mockImplementation(() => { });
+            const program = (0, createMigration_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--asset-id',
+                'asset-123',
+                '--preview-asset-id',
+                'preview-456',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '/invalid/path',
+            ]);
+            expect(mockUtils.handleCommandError).toHaveBeenCalledWith(program, validationError);
+            expect(mockUtils.createTarFile).not.toHaveBeenCalled();
+        }));
+        it('should handle tar file creation failure', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockUtils.createTarFile.mockResolvedValue(null);
+            const program = (0, createMigration_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--asset-id',
+                'asset-123',
+                '--preview-asset-id',
+                'preview-456',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '/path/to/export',
+            ]);
+            expect(mockUtils.createMigration).not.toHaveBeenCalled();
+            expect(mockUtils.uploadFileToS3).not.toHaveBeenCalled();
+        }));
+        it('should handle migration creation failure', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockUtils.createMigration.mockResolvedValue(null);
+            const program = (0, createMigration_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--asset-id',
+                'asset-123',
+                '--preview-asset-id',
+                'preview-456',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '/path/to/export',
+            ]);
+            expect(mockUtils.uploadFileToS3).not.toHaveBeenCalled();
+            expect(mockFs.unlinkSync).not.toHaveBeenCalled();
+        }));
+        it('should handle S3 upload failure', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockUtils.uploadFileToS3.mockResolvedValue(null);
+            const program = (0, createMigration_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--asset-id',
+                'asset-123',
+                '--preview-asset-id',
+                'preview-456',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '/path/to/export',
+            ]);
+            expect(mockFs.unlinkSync).not.toHaveBeenCalled();
+        }));
+        it('should handle migration API error', () => __awaiter(void 0, void 0, void 0, function* () {
+            const apiError = new Error('Migration API failed');
+            mockUtils.createMigration.mockRejectedValue(apiError);
+            mockUtils.handleCommandError.mockImplementation(() => { });
+            const program = (0, createMigration_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--asset-id',
+                'asset-123',
+                '--preview-asset-id',
+                'preview-456',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '/path/to/export',
+            ]);
+            expect(mockUtils.handleCommandError).toHaveBeenCalledWith(program, apiError);
+        }));
+        it('should handle not being logged in', () => __awaiter(void 0, void 0, void 0, function* () {
+            const loginError = new Error('Not logged in');
+            mockUtils.throwErrorIfNotLoggedIn.mockImplementation(() => {
+                throw loginError;
+            });
+            const program = (0, createMigration_1.default)();
+            yield expect(program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--asset-id',
+                'asset-123',
+                '--preview-asset-id',
+                'preview-456',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '/path/to/export',
+            ])).rejects.toThrow('Not logged in');
+            expect(mockUtils.validateExportFolder).not.toHaveBeenCalled();
+        }));
+    });
+    describe('required options validation', () => {
+        it('should require assetid option', () => {
+            const program = (0, createMigration_1.default)().exitOverride();
+            expect(() => {
+                program.parse([
+                    'node',
+                    'dxp-cli',
+                    '--preview-asset-id',
+                    'preview-456',
+                    '--matrix-url',
+                    'https://matrix.example.com',
+                    '/path/to/export',
+                ]);
+            }).toThrow();
+        });
+        it('should require previewAssetid option', () => {
+            const program = (0, createMigration_1.default)().exitOverride();
+            expect(() => {
+                program.parse([
+                    'node',
+                    'dxp-cli',
+                    '--asset-id',
+                    'asset-123',
+                    '--matrix-url',
+                    'https://matrix.example.com',
+                    '/path/to/export',
+                ]);
+            }).toThrow();
+        });
+        it('should require matrixUrl option', () => {
+            const program = (0, createMigration_1.default)().exitOverride();
+            expect(() => {
+                program.parse([
+                    'node',
+                    'dxp-cli',
+                    '--asset-id',
+                    'asset-123',
+                    '--preview-asset-id',
+                    'preview-456',
+                    '/path/to/export',
+                ]);
+            }).toThrow();
+        });
+        it('should require exportPath argument', () => {
+            const program = (0, createMigration_1.default)().exitOverride();
+            expect(() => {
+                program.parse([
+                    'node',
+                    'dxp-cli',
+                    '--asset-id',
+                    'asset-123',
+                    '--preview-asset-id',
+                    'preview-456',
+                    '--matrix-url',
+                    'https://matrix.example.com',
+                ]);
+            }).toThrow();
+        });
+    });
+    describe('command configuration', () => {
+        it('should have correct command name and description', () => {
+            const program = (0, createMigration_1.default)();
+            expect(program.name()).toBe('create');
+            expect(program.description()).toBe('Create a new migration using the AI Page migration service');
+        });
+        it('should parse options correctly', () => {
+            const program = (0, createMigration_1.default)();
+            program.parse([
+                'node',
+                'dxp-cli',
+                '--asset-id',
+                'asset-123',
+                '--preview-asset-id',
+                'preview-456',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '--tenant',
+                'test-tenant',
+                '/path/to/export',
+            ]);
+            const opts = program.opts();
+            expect(opts.assetId).toBe('asset-123');
+            expect(opts.previewAssetId).toBe('preview-456');
+            expect(opts.matrixUrl).toBe('https://matrix.example.com');
+            expect(opts.tenant).toBe('test-tenant');
+        });
+    });
+    describe('spinner and output behavior', () => {
+        it('should display appropriate spinner messages during execution', () => __awaiter(void 0, void 0, void 0, function* () {
+            const program = (0, createMigration_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--asset-id',
+                'asset-123',
+                '--preview-asset-id',
+                'preview-456',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '/path/to/export',
+            ]);
+            expect(mockUtils.validateExportFolder).toHaveBeenCalledWith('/path/to/export');
+            expect(mockUtils.createTarFile).toHaveBeenCalledWith('/path/to/export');
+            expect(mockUtils.createMigration).toHaveBeenCalled();
+            expect(mockUtils.uploadFileToS3).toHaveBeenCalled();
+            expect(mockFs.unlinkSync).toHaveBeenCalled();
+        }));
+    });
+});

package/lib/migration/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+declare const migrationCommand: Command;
+export default migrationCommand;

package/lib/migration/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const createMigration_1 = __importDefault(require("./create/createMigration"));
+const migrationCommand = new commander_1.Command('migration');
+migrationCommand
+    .description('AI Page Migration Service Commands')
+    .addCommand((0, createMigration_1.default)());
+exports.default = migrationCommand;

package/lib/migration/utils.d.ts

@@ -0,0 +1,32 @@
+import { Command } from 'commander';
+export interface CreateMigrationOptions {
+    assetId: string;
+    previewAssetId: string;
+    matrixUrl: string;
+    tenant?: string;
+    overrideUrl?: string;
+}
+export interface CreateMigrationAPIResponse {
+    assetMigration: {
+        migrationId: string;
+        assetId: string;
+        xmlFilePath: string;
+        matrixUrl: string;
+        previewAssetId: string;
+        stage: string;
+        status: string;
+        created: number;
+        updated: number;
+        migrationIdAssetId: string;
+    };
+    uploadUrl: string;
+}
+export declare function handleCommandError(command: Command, error: Error): void;
+export declare function throwErrorIfNotLoggedIn(command: Command): Promise<void>;
+export declare function buildMigrationUrl(tenantID?: string, overrideUrl?: string): Promise<string>;
+export declare function validateAxiosStatus(status: number): boolean;
+export declare function validateExportFolder(exportPath: string): void;
+export declare function createTarFile(exportPath: string): Promise<string>;
+export declare function getMigrationHeaders(tenantID?: string): Promise<Record<string, string>>;
+export declare function uploadFileToS3(uploadUrl: string, filePath: string, tenantID?: string): Promise<string>;
+export declare function createMigration(options: CreateMigrationOptions): Promise<CreateMigrationAPIResponse>;

package/lib/migration/utils.js

@@ -0,0 +1,190 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMigration = exports.uploadFileToS3 = exports.getMigrationHeaders = exports.createTarFile = exports.validateExportFolder = exports.validateAxiosStatus = exports.buildMigrationUrl = exports.throwErrorIfNotLoggedIn = exports.handleCommandError = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const ApplicationConfig_1 = require("../ApplicationConfig");
+const axios_1 = __importDefault(require("axios"));
+const ApplicationStore_1 = require("../ApplicationStore");
+const child_process_1 = require("child_process");
+const ApiService_1 = require("../ApiService");
+function handleCommandError(command, error) {
+    var _a, _b, _c, _d;
+    if (axios_1.default.isAxiosError(error)) {
+        let message = `${error.message}`;
+        if ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) {
+            message += `: ${error.response.data.message}`;
+        }
+        if ((_d = (_c = error.response) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.details) {
+            message += ` - ${error.response.data.details}`;
+        }
+        command.error(chalk_1.default.red(message));
+    }
+    else {
+        if (!!process.env.DEBUG && error.stack) {
+            command.error(error.stack);
+        }
+        if (error.message) {
+            command.error(chalk_1.default.red(error.message));
+        }
+        else {
+            command.error(chalk_1.default.red('An unknown error occurred'));
+        }
+    }
+}
+exports.handleCommandError = handleCommandError;
+function throwErrorIfNotLoggedIn(command) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield (0, ApplicationStore_1.getApplicationFile)(ApplicationStore_1.STORE_FILES.sessionCookie))) {
+            command.error(chalk_1.default.red('You must login to interact with the migration service. See `dxp-next auth login`'));
+        }
+    });
+}
+exports.throwErrorIfNotLoggedIn = throwErrorIfNotLoggedIn;
+function buildMigrationUrl(tenantID, overrideUrl) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!overrideUrl) {
+            const existingConfig = yield (0, ApplicationConfig_1.fetchApplicationConfig)(tenantID);
+            return `${existingConfig.baseUrl}/__dxp/service/aiapps/migration`;
+        }
+        else {
+            return overrideUrl;
+        }
+    });
+}
+exports.buildMigrationUrl = buildMigrationUrl;
+function validateAxiosStatus(status) {
+    return status < 400;
+}
+exports.validateAxiosStatus = validateAxiosStatus;
+function validateExportFolder(exportPath) {
+    // Check if the export folder exists
+    if (!fs_1.default.existsSync(exportPath)) {
+        throw new Error(`Export folder does not exist: ${exportPath}`);
+    }
+    // Check if it's a directory
+    if (!fs_1.default.statSync(exportPath).isDirectory()) {
+        throw new Error(`Export path is not a directory: ${exportPath}`);
+    }
+    // Check for nested export folder structure (e.g., ./export/export/...)
+    const nestedExportPath = path_1.default.join(exportPath, 'export');
+    if (!fs_1.default.existsSync(nestedExportPath)) {
+        throw new Error(`Nested export folder does not exist: ${nestedExportPath}`);
+    }
+    if (!fs_1.default.statSync(nestedExportPath).isDirectory()) {
+        throw new Error(`Nested export path is not a directory: ${nestedExportPath}`);
+    }
+    // Check for export.xml file in the nested export directory
+    const exportXmlPath = path_1.default.join(nestedExportPath, 'export.xml');
+    if (!fs_1.default.existsSync(exportXmlPath)) {
+        throw new Error(`export.xml file does not exist in: ${nestedExportPath}`);
+    }
+    if (!fs_1.default.statSync(exportXmlPath).isFile()) {
+        throw new Error(`export.xml is not a valid file: ${exportXmlPath}`);
+    }
+}
+exports.validateExportFolder = validateExportFolder;
+function createTarFile(exportPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tarFileName = `export_${Date.now()}.tar.gz`;
+        const tarFilePath = path_1.default.join(process.cwd(), tarFileName);
+        return new Promise((resolve, reject) => {
+            const tar = (0, child_process_1.spawn)('tar', [
+                '-czf',
+                tarFilePath,
+                '-C',
+                path_1.default.dirname(exportPath),
+                path_1.default.basename(exportPath),
+            ]);
+            tar.on('close', code => {
+                if (code === 0) {
+                    resolve(tarFilePath);
+                }
+                else {
+                    reject(new Error(`tar command failed with exit code ${code}`));
+                }
+            });
+            tar.on('error', error => {
+                reject(new Error(`Failed to create tar file: ${error.message}`));
+            });
+        });
+    });
+}
+exports.createTarFile = createTarFile;
+function getMigrationHeaders(tenantID) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const existingConfig = yield (0, ApplicationConfig_1.fetchApplicationConfig)(tenantID);
+        return {
+            'x-dxp-tenant': existingConfig.tenant,
+        };
+    });
+}
+exports.getMigrationHeaders = getMigrationHeaders;
+function uploadFileToS3(uploadUrl, filePath, tenantID) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fileBuffer = fs_1.default.readFileSync(filePath);
+        const response = yield fetch(uploadUrl, {
+            method: 'PUT',
+            body: fileBuffer,
+            headers: Object.assign({}, (yield getMigrationHeaders(tenantID))),
+        });
+        return response.url;
+    });
+}
+exports.uploadFileToS3 = uploadFileToS3;
+function createMigration(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const apiService = new ApiService_1.ApiService({
+            validateStatus: validateAxiosStatus,
+        });
+        const migrationUrl = yield buildMigrationUrl(options.tenant, options.overrideUrl);
+        try {
+            const payload = {
+                assetId: options.assetId,
+                previewAssetId: options.previewAssetId,
+                matrixUrl: options.matrixUrl,
+            };
+            const response = yield apiService.client.post(`${migrationUrl}/migrations`, payload, {
+                headers: Object.assign({ 'Content-Type': 'application/json' }, (yield getMigrationHeaders(options.tenant))),
+            });
+            if (response.status !== 200 && response.status !== 201) {
+                throw new Error(`Migration creation failed with status: ${response.status}`);
+            }
+            // Validate response structure
+            const { assetMigration, uploadUrl } = response.data || {};
+            if (!(assetMigration === null || assetMigration === void 0 ? void 0 : assetMigration.migrationId) ||
+                !(assetMigration === null || assetMigration === void 0 ? void 0 : assetMigration.assetId) ||
+                !(assetMigration === null || assetMigration === void 0 ? void 0 : assetMigration.stage) ||
+                !(assetMigration === null || assetMigration === void 0 ? void 0 : assetMigration.status)) {
+                throw new Error('Invalid response format from migration service');
+            }
+            if (!uploadUrl) {
+                throw new Error('Upload URL not found in response');
+            }
+            return {
+                assetMigration,
+                uploadUrl,
+            };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw error;
+            }
+            throw new Error(`Failed to create migration: ${error}`);
+        }
+    });
+}
+exports.createMigration = createMigration;

package/lib/migration/utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/migration/utils.spec.js

@@ -0,0 +1,411 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const axios_1 = __importDefault(require("axios"));
+const ApplicationConfig_1 = require("../ApplicationConfig");
+const ApplicationStore_1 = require("../ApplicationStore");
+const ApiService_1 = require("../ApiService");
+const utils_1 = require("./utils");
+// Mock all external dependencies
+jest.mock('fs');
+jest.mock('path');
+jest.mock('child_process');
+jest.mock('axios');
+jest.mock('../ApplicationConfig');
+jest.mock('../ApplicationStore');
+jest.mock('../ApiService');
+// Mock global fetch
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+const mockFs = fs_1.default;
+const mockPath = path_1.default;
+const mockSpawn = child_process_1.spawn;
+const mockAxios = axios_1.default;
+const mockFetchApplicationConfig = ApplicationConfig_1.fetchApplicationConfig;
+const mockGetApplicationFile = ApplicationStore_1.getApplicationFile;
+const mockApiService = ApiService_1.ApiService;
+describe('Migration Utils', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.resetAllMocks();
+    });
+    describe('handleCommandError', () => {
+        let mockCommand;
+        beforeEach(() => {
+            mockCommand = {
+                error: jest.fn(),
+            };
+        });
+        it('handles axios errors with response data message', () => {
+            const axiosError = {
+                message: 'Network Error',
+                response: {
+                    data: {
+                        message: 'Server Error',
+                        details: 'Additional details',
+                    },
+                },
+            };
+            mockAxios.isAxiosError.mockReturnValue(true);
+            (0, utils_1.handleCommandError)(mockCommand, axiosError);
+            expect(mockCommand.error).toHaveBeenCalledWith(expect.stringContaining('Network Error: Server Error - Additional details'));
+        });
+        it('handles axios errors without response data', () => {
+            const axiosError = {
+                message: 'Network Error',
+            };
+            mockAxios.isAxiosError.mockReturnValue(true);
+            (0, utils_1.handleCommandError)(mockCommand, axiosError);
+            expect(mockCommand.error).toHaveBeenCalledWith(expect.stringContaining('Network Error'));
+        });
+        it('handles regular errors with message', () => {
+            const error = new Error('Regular error');
+            mockAxios.isAxiosError.mockReturnValue(false);
+            (0, utils_1.handleCommandError)(mockCommand, error);
+            expect(mockCommand.error).toHaveBeenCalledWith(expect.stringContaining('Regular error'));
+        });
+        it('handles errors without message', () => {
+            const error = new Error();
+            error.message = '';
+            mockAxios.isAxiosError.mockReturnValue(false);
+            (0, utils_1.handleCommandError)(mockCommand, error);
+            expect(mockCommand.error).toHaveBeenCalledWith(expect.stringContaining('An unknown error occurred'));
+        });
+        it('shows stack trace in debug mode', () => {
+            const originalDebug = process.env.DEBUG;
+            process.env.DEBUG = 'true';
+            const error = new Error('Test error');
+            error.stack = 'Error stack trace';
+            mockAxios.isAxiosError.mockReturnValue(false);
+            (0, utils_1.handleCommandError)(mockCommand, error);
+            expect(mockCommand.error).toHaveBeenCalledWith('Error stack trace');
+            process.env.DEBUG = originalDebug;
+        });
+    });
+    describe('throwErrorIfNotLoggedIn', () => {
+        let mockCommand;
+        beforeEach(() => {
+            mockCommand = {
+                error: jest.fn(),
+            };
+        });
+        it('throws error when not logged in', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockGetApplicationFile.mockResolvedValue(undefined);
+            yield (0, utils_1.throwErrorIfNotLoggedIn)(mockCommand);
+            expect(mockCommand.error).toHaveBeenCalledWith(expect.stringContaining('You must login to interact with the migration service'));
+        }));
+        it('does not throw error when logged in', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockGetApplicationFile.mockResolvedValue('session-cookie');
+            yield (0, utils_1.throwErrorIfNotLoggedIn)(mockCommand);
+            expect(mockCommand.error).not.toHaveBeenCalled();
+        }));
+    });
+    describe('buildMigrationUrl', () => {
+        it('builds url without override', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockConfig = {
+                baseUrl: 'https://example.com',
+                tenant: 'test-tenant',
+                region: 'au',
+            };
+            mockFetchApplicationConfig.mockResolvedValue(mockConfig);
+            const result = yield (0, utils_1.buildMigrationUrl)('tenant-id');
+            expect(result).toBe('https://example.com/__dxp/service/aiapps/migration');
+            expect(mockFetchApplicationConfig).toHaveBeenCalledWith('tenant-id');
+        }));
+        it('returns override url when provided', () => __awaiter(void 0, void 0, void 0, function* () {
+            const overrideUrl = 'https://override.com';
+            const result = yield (0, utils_1.buildMigrationUrl)('tenant-id', overrideUrl);
+            expect(result).toBe(overrideUrl);
+            expect(mockFetchApplicationConfig).not.toHaveBeenCalled();
+        }));
+    });
+    describe('validateAxiosStatus', () => {
+        it('returns true for successful status codes', () => {
+            expect((0, utils_1.validateAxiosStatus)(200)).toBe(true);
+            expect((0, utils_1.validateAxiosStatus)(201)).toBe(true);
+            expect((0, utils_1.validateAxiosStatus)(399)).toBe(true);
+        });
+        it('returns false for error status codes', () => {
+            expect((0, utils_1.validateAxiosStatus)(400)).toBe(false);
+            expect((0, utils_1.validateAxiosStatus)(404)).toBe(false);
+            expect((0, utils_1.validateAxiosStatus)(500)).toBe(false);
+        });
+    });
+    describe('validateExportFolder', () => {
+        beforeEach(() => {
+            mockPath.join.mockImplementation((...paths) => paths.join('/'));
+        });
+        it('validates successful export folder structure', () => {
+            mockFs.existsSync.mockImplementation(filePath => {
+                return [
+                    '/export/path',
+                    '/export/path/export',
+                    '/export/path/export/export.xml',
+                ].includes(filePath);
+            });
+            mockFs.statSync.mockImplementation(filePath => ({
+                isDirectory: () => filePath !== '/export/path/export/export.xml',
+                isFile: () => filePath === '/export/path/export/export.xml',
+            }));
+            expect(() => (0, utils_1.validateExportFolder)('/export/path')).not.toThrow();
+        });
+        it('throws error when export folder does not exist', () => {
+            mockFs.existsSync.mockReturnValue(false);
+            expect(() => (0, utils_1.validateExportFolder)('/nonexistent')).toThrow('Export folder does not exist: /nonexistent');
+        });
+        it('throws error when export path is not a directory', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.statSync.mockReturnValue({
+                isDirectory: () => false,
+                isFile: () => true,
+            });
+            expect(() => (0, utils_1.validateExportFolder)('/export/file.txt')).toThrow('Export path is not a directory: /export/file.txt');
+        });
+        it('throws error when nested export folder does not exist', () => {
+            mockFs.existsSync.mockImplementation(filePath => filePath === '/export/path');
+            mockFs.statSync.mockReturnValue({
+                isDirectory: () => true,
+            });
+            expect(() => (0, utils_1.validateExportFolder)('/export/path')).toThrow('Nested export folder does not exist: /export/path/export');
+        });
+        it('throws error when export.xml does not exist', () => {
+            mockFs.existsSync.mockImplementation(filePath => {
+                return ['/export/path', '/export/path/export'].includes(filePath);
+            });
+            mockFs.statSync.mockReturnValue({
+                isDirectory: () => true,
+            });
+            expect(() => (0, utils_1.validateExportFolder)('/export/path')).toThrow('export.xml file does not exist in: /export/path/export');
+        });
+        it('throws error when export.xml is not a file', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.statSync.mockImplementation(filePath => ({
+                isDirectory: () => filePath !== '/export/path/export/export.xml',
+                isFile: () => false,
+            }));
+            expect(() => (0, utils_1.validateExportFolder)('/export/path')).toThrow('export.xml is not a valid file: /export/path/export/export.xml');
+        });
+        it('throws error when nested export path is not a directory', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.statSync.mockImplementation(filePath => {
+                if (filePath === '/export/path') {
+                    return { isDirectory: () => true };
+                }
+                else if (filePath === '/export/path/export') {
+                    return { isDirectory: () => false, isFile: () => true };
+                }
+                return { isDirectory: () => false, isFile: () => false };
+            });
+            expect(() => (0, utils_1.validateExportFolder)('/export/path')).toThrow('Nested export path is not a directory: /export/path/export');
+        });
+    });
+    describe('createTarFile', () => {
+        let mockChildProcess;
+        beforeEach(() => {
+            mockChildProcess = {
+                on: jest.fn(),
+            };
+            mockSpawn.mockReturnValue(mockChildProcess);
+            mockPath.join.mockImplementation((...paths) => paths.join('/'));
+            mockPath.dirname.mockReturnValue('/parent');
+            mockPath.basename.mockReturnValue('export');
+            // Mock Date.now() to return consistent timestamp
+            jest.spyOn(Date, 'now').mockReturnValue(1234567890);
+        });
+        afterEach(() => {
+            jest.restoreAllMocks();
+        });
+        it('creates tar file successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const promise = (0, utils_1.createTarFile)('/parent/export');
+            // Simulate successful tar creation
+            const closeCallback = mockChildProcess.on.mock.calls.find((call) => call[0] === 'close')[1];
+            closeCallback(0);
+            const result = yield promise;
+            expect(result).toBe(`${process.cwd()}/export_1234567890.tar.gz`);
+            expect(mockSpawn).toHaveBeenCalledWith('tar', [
+                '-czf',
+                `${process.cwd()}/export_1234567890.tar.gz`,
+                '-C',
+                '/parent',
+                'export',
+            ]);
+        }));
+        it('handles tar command failure', () => __awaiter(void 0, void 0, void 0, function* () {
+            const promise = (0, utils_1.createTarFile)('/parent/export');
+            // Simulate tar command failure
+            const closeCallback = mockChildProcess.on.mock.calls.find((call) => call[0] === 'close')[1];
+            closeCallback(1);
+            yield expect(promise).rejects.toThrow('tar command failed with exit code 1');
+        }));
+        it('handles spawn error', () => __awaiter(void 0, void 0, void 0, function* () {
+            const promise = (0, utils_1.createTarFile)('/parent/export');
+            // Simulate spawn error
+            const errorCallback = mockChildProcess.on.mock.calls.find((call) => call[0] === 'error')[1];
+            errorCallback(new Error('Spawn failed'));
+            yield expect(promise).rejects.toThrow('Failed to create tar file: Spawn failed');
+        }));
+    });
+    describe('getMigrationHeaders', () => {
+        it('returns headers with tenant from config', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockConfig = {
+                tenant: 'test-tenant',
+                baseUrl: 'https://example.com',
+                region: 'au',
+            };
+            mockFetchApplicationConfig.mockResolvedValue(mockConfig);
+            const result = yield (0, utils_1.getMigrationHeaders)('tenant-id');
+            expect(result).toEqual({
+                'x-dxp-tenant': 'test-tenant',
+            });
+            expect(mockFetchApplicationConfig).toHaveBeenCalledWith('tenant-id');
+        }));
+    });
+    describe('uploadFileToS3', () => {
+        beforeEach(() => {
+            mockFs.readFileSync.mockReturnValue(Buffer.from('file content'));
+            mockFetchApplicationConfig.mockResolvedValue({
+                tenant: 'test-tenant',
+                baseUrl: 'https://example.com',
+                region: 'au',
+            });
+        });
+        it('uploads file successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                url: 'https://s3.amazonaws.com/uploaded-file',
+            };
+            mockFetch.mockResolvedValue(mockResponse);
+            const result = yield (0, utils_1.uploadFileToS3)('https://upload.url', '/path/to/file.tar.gz', 'tenant-id');
+            expect(result).toBe('https://s3.amazonaws.com/uploaded-file');
+            expect(mockFetch).toHaveBeenCalledWith('https://upload.url', {
+                method: 'PUT',
+                body: Buffer.from('file content'),
+                headers: {
+                    'x-dxp-tenant': 'test-tenant',
+                },
+            });
+        }));
+        it('handles file read error', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockFs.readFileSync.mockImplementation(() => {
+                throw new Error('File not found');
+            });
+            yield expect((0, utils_1.uploadFileToS3)('https://upload.url', '/nonexistent/file.tar.gz')).rejects.toThrow('File not found');
+        }));
+    });
+    describe('createMigration', () => {
+        let mockApiServiceInstance;
+        let mockOptions;
+        beforeEach(() => {
+            mockApiServiceInstance = {
+                client: {
+                    post: jest.fn(),
+                },
+            };
+            mockApiService.mockImplementation(() => mockApiServiceInstance);
+            mockOptions = {
+                assetId: 'asset-123',
+                previewAssetId: 'preview-456',
+                matrixUrl: 'https://matrix.example.com',
+                tenant: 'test-tenant',
+            };
+            mockFetchApplicationConfig.mockResolvedValue({
+                tenant: 'test-tenant',
+                baseUrl: 'https://example.com',
+                region: 'au',
+            });
+        });
+        it('creates migration successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                status: 201,
+                data: {
+                    assetMigration: {
+                        migrationId: 'migration-123',
+                        assetId: 'asset-123',
+                        stage: 'pending',
+                        status: 'created',
+                        xmlFilePath: '/path/to/xml',
+                        matrixUrl: 'https://matrix.example.com',
+                        previewAssetId: 'preview-456',
+                        created: 1234567890,
+                        updated: 1234567890,
+                        migrationIdAssetId: 'migration-123-asset-123',
+                    },
+                    uploadUrl: 'https://upload.s3.amazonaws.com',
+                },
+            };
+            mockApiServiceInstance.client.post.mockResolvedValue(mockResponse);
+            const result = yield (0, utils_1.createMigration)(mockOptions);
+            expect(result).toEqual(mockResponse.data);
+            expect(mockApiServiceInstance.client.post).toHaveBeenCalledWith('https://example.com/__dxp/service/aiapps/migration/migrations', {
+                assetId: 'asset-123',
+                previewAssetId: 'preview-456',
+                matrixUrl: 'https://matrix.example.com',
+            }, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-dxp-tenant': 'test-tenant',
+                },
+            });
+        }));
+        it('handles non-success status codes', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                status: 400,
+                data: {},
+            };
+            mockApiServiceInstance.client.post.mockResolvedValue(mockResponse);
+            yield expect((0, utils_1.createMigration)(mockOptions)).rejects.toThrow('Migration creation failed with status: 400');
+        }));
+        it('handles invalid response format - missing migrationId', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                status: 200,
+                data: {
+                    assetMigration: {
+                        assetId: 'asset-123',
+                        stage: 'pending',
+                        status: 'created',
+                    },
+                    uploadUrl: 'https://upload.s3.amazonaws.com',
+                },
+            };
+            mockApiServiceInstance.client.post.mockResolvedValue(mockResponse);
+            yield expect((0, utils_1.createMigration)(mockOptions)).rejects.toThrow('Invalid response format from migration service');
+        }));
+        it('handles missing upload URL', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                status: 200,
+                data: {
+                    assetMigration: {
+                        migrationId: 'migration-123',
+                        assetId: 'asset-123',
+                        stage: 'pending',
+                        status: 'created',
+                    },
+                },
+            };
+            mockApiServiceInstance.client.post.mockResolvedValue(mockResponse);
+            yield expect((0, utils_1.createMigration)(mockOptions)).rejects.toThrow('Upload URL not found in response');
+        }));
+        it('handles API service errors', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Network error');
+            mockApiServiceInstance.client.post.mockRejectedValue(error);
+            yield expect((0, utils_1.createMigration)(mockOptions)).rejects.toThrow('Network error');
+        }));
+        it('handles unknown errors', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockApiServiceInstance.client.post.mockRejectedValue('Unknown error');
+            yield expect((0, utils_1.createMigration)(mockOptions)).rejects.toThrow('Failed to create migration: Unknown error');
+        }));
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squiz/dxp-cli-next",
-  "version": "5.25.3",
+  "version": "5.26.0-develop.1",
   "repository": {
     "url": "https://gitlab.squiz.net/dxp/dxp-cli-next"
   },