@squiz/dxp-cli-next 5.32.0-develop.1 → 5.32.0-develop.2

package/lib/migration/create/create.js

@@ -16,6 +16,7 @@ const commander_1 = require("commander");
 const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
 const utils_1 = require("../utils");
+const loadCctIdsFromFile_1 = require("../utils/loadCctIdsFromFile");
 const createMigrationCommand = () => {
     const createCommand = new commander_1.Command('create')
         .name('create')
@@ -23,6 +24,7 @@ const createMigrationCommand = () => {
         .addOption((0, utils_1.getParamOption)(utils_1.OptionName.ASSET_ID))
         .addOption((0, utils_1.getParamOption)(utils_1.OptionName.PREVIEW_ASSET_ID))
         .addOption((0, utils_1.getParamOption)(utils_1.OptionName.MATRIX_URL))
+        .addOption((0, utils_1.getParamOption)(utils_1.OptionName.CCT_IDS, false))
         .addOption((0, utils_1.getParamOption)(utils_1.OptionName.TENANT, false))
         .configureOutput({
         outputError(str, write) {
@@ -33,18 +35,13 @@ const createMigrationCommand = () => {
         yield (0, utils_1.throwErrorIfNotLoggedIn)(createCommand);
         const spinner = (0, ora_1.default)('Creating migration').start();
         try {
+            const cctIds = (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(options.cctIds);
             // Create migration
-            const response = yield (0, utils_1.createMigration)(options);
+            const response = yield (0, utils_1.createMigration)(Object.assign(Object.assign({}, options), { cctIds }));
             if (!response) {
                 throw new Error('Migration creation failed');
             }
-            spinner.succeed('Migration created successfully');
-            spinner.succeed(`Successfully created migration: ${JSON.stringify({
-                migrationId: response.assetMigration.migrationId,
-                assetId: response.assetMigration.assetId,
-                stage: response.assetMigration.stage,
-                status: response.assetMigration.status,
-            })}`);
+            spinner.succeed((0, utils_1.buildMigrationSuccessMessage)('migration', response.assetMigration));
         }
         catch (error) {
             spinner.fail();

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

@@ -52,6 +52,7 @@ describe('createMigrationCommand', () => {
         jest.resetAllMocks();
         logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
         mockUtils.throwErrorIfNotLoggedIn.mockResolvedValue(undefined);
+        mockUtils.buildMigrationSuccessMessage.mockReturnValue('Migration created successfully');
         mockCreateMigrationResponse = {
             assetMigration: {
                 migrationId: 'migration-123',

package/lib/migration/index.js

@@ -7,6 +7,7 @@ const commander_1 = require("commander");
 const create_1 = __importDefault(require("./create/create"));
 const get_1 = __importDefault(require("./get/get"));
 const next_1 = __importDefault(require("./next/next"));
+const pre_1 = __importDefault(require("./pre/pre"));
 const settings_1 = __importDefault(require("./settings/settings"));
 const revert_1 = __importDefault(require("./revert/revert"));
 const list_1 = __importDefault(require("./list/list"));
@@ -17,6 +18,7 @@ migrationCommand
     .addCommand((0, get_1.default)())
     .addCommand((0, list_1.default)())
     .addCommand((0, next_1.default)())
+    .addCommand((0, pre_1.default)())
     .addCommand((0, settings_1.default)())
     .addCommand((0, revert_1.default)());
 exports.default = migrationCommand;

package/lib/migration/pre/pre.d.ts

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

package/lib/migration/pre/pre.js

@@ -0,0 +1,54 @@
+"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 utils_1 = require("../utils");
+const loadCctIdsFromFile_1 = require("../utils/loadCctIdsFromFile");
+const preMigrationCommand = () => {
+    const preCommand = new commander_1.Command('pre')
+        .name('pre')
+        .description('Create a new pre-migration using the AI Page Migration service')
+        .addOption((0, utils_1.getParamOption)(utils_1.OptionName.MATRIX_URL))
+        .addOption((0, utils_1.getParamOption)(utils_1.OptionName.CCT_IDS))
+        .addOption((0, utils_1.getParamOption)(utils_1.OptionName.TENANT, false))
+        .configureOutput({
+        outputError(str, write) {
+            write(chalk_1.default.red(str));
+        },
+    })
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, utils_1.throwErrorIfNotLoggedIn)(preCommand);
+        const spinner = (0, ora_1.default)('Creating pre-migration').start();
+        try {
+            const cctIds = (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(options.cctIds);
+            // Create pre-migration
+            const response = yield (0, utils_1.createMigration)(Object.assign(Object.assign({}, options), { cctIds }));
+            if (!response) {
+                throw new Error('Pre-migration creation failed');
+            }
+            spinner.succeed((0, utils_1.buildMigrationSuccessMessage)('pre-migration', response.assetMigration));
+        }
+        catch (error) {
+            spinner.fail();
+            (0, utils_1.handleCommandError)(preCommand, error);
+        }
+    }));
+    if (process.env.ENABLE_OVERRIDE_MIGRATION_URL === 'true') {
+        preCommand.addOption(new commander_1.Option('-ou, --overrideUrl <string>', 'Developer option to override the entire migration url with a custom value'));
+    }
+    return preCommand;
+};
+exports.default = preMigrationCommand;

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

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

package/lib/migration/pre/pre.spec.js

@@ -0,0 +1,269 @@
+"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 pre_1 = __importDefault(require("./pre"));
+const utils = __importStar(require("../utils/common"));
+const createMigration = __importStar(require("../utils/createMigration"));
+const loadCctIdsFromFile = __importStar(require("../utils/loadCctIdsFromFile"));
+jest.mock('../utils/common');
+jest.mock('../utils/createMigration');
+jest.mock('../utils/loadCctIdsFromFile');
+const mockUtils = utils;
+const mockCreateMigration = createMigration;
+const mockLoadCctIdsFromFile = loadCctIdsFromFile;
+describe('preMigrationCommand', () => {
+    let logSpy;
+    let mockCreateMigrationResponse;
+    beforeEach(() => {
+        nock_1.default.cleanAll();
+        jest.clearAllMocks();
+        jest.resetAllMocks();
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        mockUtils.throwErrorIfNotLoggedIn.mockResolvedValue(undefined);
+        mockUtils.buildMigrationSuccessMessage.mockReturnValue('Pre-migration created successfully');
+        mockLoadCctIdsFromFile.loadCctIdsFromFile.mockReturnValue([
+            'cct-id-1',
+            'cct-id-2',
+        ]);
+        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',
+            },
+        };
+        mockCreateMigration.createMigration.mockResolvedValue(mockCreateMigrationResponse);
+    });
+    afterEach(() => {
+        logSpy.mockRestore();
+    });
+    describe('successful pre-migration creation', () => {
+        it('should create pre-migration successfully with all required options', () => __awaiter(void 0, void 0, void 0, function* () {
+            const program = (0, pre_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '--cct-ids',
+                '/path/to/cct-ids.json',
+            ]);
+            expect(mockUtils.throwErrorIfNotLoggedIn).toHaveBeenCalledWith(program);
+            expect(mockLoadCctIdsFromFile.loadCctIdsFromFile).toHaveBeenCalledWith('/path/to/cct-ids.json');
+            expect(mockCreateMigration.createMigration).toHaveBeenCalledWith({
+                matrixUrl: 'https://matrix.example.com',
+                cctIds: ['cct-id-1', 'cct-id-2'],
+            });
+            expect(mockCreateMigration.createMigration).toHaveBeenCalledTimes(1);
+            expect(mockUtils.handleCommandError).not.toHaveBeenCalled();
+        }));
+        it('should create pre-migration with tenant option', () => __awaiter(void 0, void 0, void 0, function* () {
+            const program = (0, pre_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '--cct-ids',
+                '/path/to/cct-ids.json',
+                '--tenant',
+                'test-tenant',
+            ]);
+            expect(mockCreateMigration.createMigration).toHaveBeenCalledWith({
+                matrixUrl: 'https://matrix.example.com',
+                cctIds: ['cct-id-1', 'cct-id-2'],
+                tenant: 'test-tenant',
+            });
+        }));
+        it('should create pre-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, pre_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '--cct-ids',
+                '/path/to/cct-ids.json',
+                '--overrideUrl',
+                'https://custom.migration.url',
+            ]);
+            expect(mockCreateMigration.createMigration).toHaveBeenCalledWith({
+                matrixUrl: 'https://matrix.example.com',
+                cctIds: ['cct-id-1', 'cct-id-2'],
+                overrideUrl: 'https://custom.migration.url',
+            });
+            process.env.ENABLE_OVERRIDE_MIGRATION_URL = originalEnv;
+        }));
+    });
+    describe('error scenarios', () => {
+        it('should handle pre-migration creation failure', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockCreateMigration.createMigration.mockResolvedValue(null);
+            mockUtils.handleCommandError.mockImplementation(() => { });
+            const program = (0, pre_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '--cct-ids',
+                '/path/to/cct-ids.json',
+            ]);
+            expect(mockUtils.handleCommandError).toHaveBeenCalledWith(program, new Error('Pre-migration creation failed'));
+        }));
+        it('should handle migration API error', () => __awaiter(void 0, void 0, void 0, function* () {
+            const apiError = new Error('Migration API failed');
+            mockCreateMigration.createMigration.mockRejectedValue(apiError);
+            mockUtils.handleCommandError.mockImplementation(() => { });
+            const program = (0, pre_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '--cct-ids',
+                '/path/to/cct-ids.json',
+            ]);
+            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, pre_1.default)();
+            yield expect(program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '--cct-ids',
+                '/path/to/cct-ids.json',
+            ])).rejects.toThrow('Not logged in');
+            expect(mockCreateMigration.createMigration).not.toHaveBeenCalled();
+        }));
+        it('should handle loadCctIdsFromFile error', () => __awaiter(void 0, void 0, void 0, function* () {
+            const loadError = new Error('Failed to load CCT IDs from file');
+            mockLoadCctIdsFromFile.loadCctIdsFromFile.mockImplementation(() => {
+                throw loadError;
+            });
+            mockUtils.handleCommandError.mockImplementation(() => { });
+            const program = (0, pre_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '--cct-ids',
+                '/path/to/invalid.json',
+            ]);
+            expect(mockUtils.handleCommandError).toHaveBeenCalledWith(program, loadError);
+            expect(mockCreateMigration.createMigration).not.toHaveBeenCalled();
+        }));
+    });
+    describe('required options validation', () => {
+        it('should require matrixUrl option', () => {
+            const program = (0, pre_1.default)().exitOverride();
+            expect(() => {
+                program.parse([
+                    'node',
+                    'dxp-cli',
+                    '--cct-ids',
+                    '/path/to/cct-ids.json',
+                ]);
+            }).toThrow();
+        });
+        it('should require cctIds option', () => {
+            const program = (0, pre_1.default)().exitOverride();
+            expect(() => {
+                program.parse([
+                    'node',
+                    'dxp-cli',
+                    '--matrix-url',
+                    'https://matrix.example.com',
+                ]);
+            }).toThrow();
+        });
+    });
+    describe('command configuration', () => {
+        it('should have correct command name and description', () => {
+            const program = (0, pre_1.default)();
+            expect(program.name()).toBe('pre');
+            expect(program.description()).toBe('Create a new pre-migration using the AI Page Migration service');
+        });
+        it('should parse options correctly', () => {
+            const program = (0, pre_1.default)();
+            program.parse([
+                'node',
+                'dxp-cli',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '--cct-ids',
+                '/path/to/cct-ids.json',
+                '--tenant',
+                'test-tenant',
+            ]);
+            const opts = program.opts();
+            expect(opts.matrixUrl).toBe('https://matrix.example.com');
+            expect(opts.cctIds).toBe('/path/to/cct-ids.json');
+            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, pre_1.default)();
+            yield program.parseAsync([
+                'node',
+                'dxp-cli',
+                '--matrix-url',
+                'https://matrix.example.com',
+                '--cct-ids',
+                '/path/to/cct-ids.json',
+            ]);
+            expect(mockCreateMigration.createMigration).toHaveBeenCalled();
+        }));
+    });
+});

package/lib/migration/types/common.types.d.ts

@@ -3,6 +3,16 @@ export interface CommonCommandOptions {
     overrideUrl?: string;
 }
 export interface AssetMigration {
+    /**
+     * Will be programmatically set while creating a migration or pre-migration,
+     * depending on whether assetId and cctIds are provided.
+     */
+    isPreMigration?: boolean;
+    /**
+     * In pre-migrations, this will be the CCT IDs to generate specs for.
+     * In migrations, this will be the CCT IDs to be skipped (because they were already converted and deployed).
+     */
+    cctIds?: string[];
     migrationId: string;
     assetId: string;
     xmlFilePath: string;

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

@@ -1,5 +1,9 @@
 import { AssetMigration, CommonCommandOptions } from '.';
 export interface CreateMigrationOptions extends CommonCommandOptions, Pick<AssetMigration, 'assetId' | 'previewAssetId' | 'matrixUrl'> {
+    /**
+     * The path to a JSON file containing the CCT IDs to be skipped in a migration (because they were already converted and deployed)
+     */
+    cctIds?: string;
 }
 export interface CreateMigrationApiResponse {
     assetMigration: AssetMigration;

package/lib/migration/types/index.d.ts

@@ -2,5 +2,6 @@ export * from './common.types';
 export * from './createMigration.types';
 export * from './getMigration.types';
 export * from './nextStage.types';
+export * from './preMigration.types';
 export * from './settings.types';
 export * from './revert.types';

package/lib/migration/types/index.js

@@ -18,5 +18,6 @@ __exportStar(require("./common.types"), exports);
 __exportStar(require("./createMigration.types"), exports);
 __exportStar(require("./getMigration.types"), exports);
 __exportStar(require("./nextStage.types"), exports);
+__exportStar(require("./preMigration.types"), exports);
 __exportStar(require("./settings.types"), exports);
 __exportStar(require("./revert.types"), exports);

package/lib/migration/types/preMigration.types.d.ts

@@ -0,0 +1,10 @@
+import { AssetMigration, CommonCommandOptions } from '.';
+export interface PreMigrationOptions extends CommonCommandOptions, Pick<AssetMigration, 'matrixUrl'> {
+    /**
+     * The path to a JSON file containing the CCT IDs to generate specs
+     */
+    cctIds: string;
+}
+export interface PreMigrationApiResponse {
+    assetMigration: AssetMigration;
+}

package/lib/migration/types/preMigration.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,4 +1,5 @@
 import { Command } from 'commander';
+import { AssetMigration } from '../types';
 /**
  * The purpose of this file is to provide utilities in common
  * such as functions that can be reused across the migration service.
@@ -29,3 +30,10 @@ export declare function buildMigrationUrl(tenantID?: string, overrideUrl?: strin
 export declare function validateAxiosStatus(status: number): boolean;
 export declare function getMigrationHeaders(tenantID?: string, isJson?: boolean): Promise<Record<string, string>>;
 export declare function redactKey(key: string, visibleChars?: number): string;
+/**
+ * Builds a success message for migration creation.
+ * @param label - The label for the migration type (e.g., "migration" or "pre-migration").
+ * @param assetMigration - The asset migration response.
+ * @returns The formatted success message.
+ */
+export declare function buildMigrationSuccessMessage(label: string, assetMigration: AssetMigration): string;

package/lib/migration/utils/common.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.redactKey = exports.getMigrationHeaders = exports.validateAxiosStatus = exports.buildMigrationUrl = exports.throwErrorIfNotLoggedIn = exports.handleCommandError = void 0;
+exports.buildMigrationSuccessMessage = exports.redactKey = exports.getMigrationHeaders = exports.validateAxiosStatus = exports.buildMigrationUrl = exports.throwErrorIfNotLoggedIn = exports.handleCommandError = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const ApplicationConfig_1 = require("../../ApplicationConfig");
 const axios_1 = __importDefault(require("axios"));
@@ -114,3 +114,21 @@ function redactKey(key, visibleChars = 3) {
     return masked + key.slice(-visibleChars);
 }
 exports.redactKey = redactKey;
+/**
+ * Builds a success message for migration creation.
+ * @param label - The label for the migration type (e.g., "migration" or "pre-migration").
+ * @param assetMigration - The asset migration response.
+ * @returns The formatted success message.
+ */
+function buildMigrationSuccessMessage(label, assetMigration) {
+    const { isPreMigration, cctIds, migrationId, assetId, stage, status } = assetMigration;
+    return `Successfully created ${label}: ${JSON.stringify({
+        isPreMigration,
+        migrationId,
+        assetId,
+        stage,
+        status,
+        cctIds: (cctIds === null || cctIds === void 0 ? void 0 : cctIds.length) ? JSON.stringify(cctIds).substring(0, 100) : '[]',
+    })}`;
+}
+exports.buildMigrationSuccessMessage = buildMigrationSuccessMessage;

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

@@ -1,5 +1,29 @@
-import { CreateMigrationOptions, CreateMigrationApiResponse } from '../types';
-export declare function createMigration(options: CreateMigrationOptions): Promise<CreateMigrationApiResponse>;
+import { CommonCommandOptions, CreateMigrationApiResponse } from '../types';
+export interface CreateMigrationInput extends CommonCommandOptions {
+    /**
+     * Optional for pre-migrations, required for migrations.
+     */
+    assetId?: string;
+    /**
+     * Optional for pre-migrations, required for migrations.
+     */
+    previewAssetId?: string;
+    /**
+     * Required for both migrations and pre-migrations.
+     */
+    matrixUrl: string;
+    /**
+     * Optional for migrations, required for pre-migrations.
+     */
+    cctIds?: string[];
+}
+/**
+ * Creates a new migration or pre-migration using the AI Page Migration service.
+ * Pre-migrations are used to generate specs for CCTs so they can be converted and deployed in advance.
+ * @param {CreateMigrationInput} input - The input parameters for the migration/pre-migration creation.
+ * @returns {Promise<CreateMigrationApiResponse>}
+ */
+export declare function createMigration({ tenant, overrideUrl, assetId, previewAssetId, matrixUrl, cctIds, }: CreateMigrationInput): Promise<CreateMigrationApiResponse>;
 export declare function validateExportFolder(exportPath: string): void;
 /**
  * Creates a tar file from the export path.

package/lib/migration/utils/createMigration.js

@@ -18,20 +18,27 @@ const path_1 = __importDefault(require("path"));
 const ApiService_1 = require("../../ApiService");
 const _1 = require(".");
 const child_process_1 = require("child_process");
-function createMigration(options) {
+/**
+ * Creates a new migration or pre-migration using the AI Page Migration service.
+ * Pre-migrations are used to generate specs for CCTs so they can be converted and deployed in advance.
+ * @param {CreateMigrationInput} input - The input parameters for the migration/pre-migration creation.
+ * @returns {Promise<CreateMigrationApiResponse>}
+ */
+function createMigration({ tenant, overrideUrl, assetId, previewAssetId, matrixUrl, cctIds, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const apiService = new ApiService_1.ApiService({
             validateStatus: _1.validateAxiosStatus,
         });
-        const migrationUrl = yield (0, _1.buildMigrationUrl)(options.tenant, options.overrideUrl);
+        const migrationUrl = yield (0, _1.buildMigrationUrl)(tenant, overrideUrl);
         try {
             const payload = {
-                assetId: options.assetId,
-                previewAssetId: options.previewAssetId,
-                matrixUrl: options.matrixUrl,
+                assetId,
+                previewAssetId,
+                matrixUrl,
+                cctIds,
             };
             const response = yield apiService.client.post(`${migrationUrl}`, payload, {
-                headers: yield (0, _1.getMigrationHeaders)(options.tenant),
+                headers: yield (0, _1.getMigrationHeaders)(tenant),
             });
             if (response.status !== 200 && response.status !== 201) {
                 throw new Error(`Migration creation failed with status: ${response.status}`);

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

@@ -0,0 +1 @@
+export declare const loadCctIdsFromFile: (filePath?: string) => string[] | undefined;

package/lib/migration/utils/loadCctIdsFromFile.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCctIdsFromFile = void 0;
+const fs_1 = __importDefault(require("fs"));
+const loadCctIdsFromFile = (filePath) => {
+    if (!filePath) {
+        return undefined;
+    }
+    try {
+        if (!fs_1.default.existsSync(filePath)) {
+            throw new Error(`CCT IDs file not found: ${filePath}`);
+        }
+        const fileContent = fs_1.default.readFileSync(filePath, 'utf8');
+        const cctIds = JSON.parse(fileContent);
+        if (!Array.isArray(cctIds) ||
+            cctIds.some(id => typeof id !== 'string' || !id.trim()) ||
+            cctIds.length === 0) {
+            throw new Error('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+        }
+        return cctIds;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to load CCT IDs from file: ${error.message}`);
+        }
+        throw new Error(`Failed to load CCT IDs from file: ${error}`);
+    }
+};
+exports.loadCctIdsFromFile = loadCctIdsFromFile;

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

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

package/lib/migration/utils/loadCctIdsFromFile.spec.js

@@ -0,0 +1,91 @@
+"use strict";
+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 loadCctIdsFromFile_1 = require("./loadCctIdsFromFile");
+jest.mock('fs');
+const mockFs = fs_1.default;
+describe('loadCctIdsFromFile', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return undefined when no file path is provided', () => {
+        const result = (0, loadCctIdsFromFile_1.loadCctIdsFromFile)();
+        expect(result).toBeUndefined();
+    });
+    it('should load and parse valid JSON file with CCT IDs', () => {
+        const mockFilePath = '/test/path/cct-ids.json';
+        const mockJsonContent = '["cct-id-1", "cct-id-2", "cct-id-3"]';
+        const expectedResult = ['cct-id-1', 'cct-id-2', 'cct-id-3'];
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(mockJsonContent);
+        const result = (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath);
+        expect(mockFs.existsSync).toHaveBeenCalledWith(mockFilePath);
+        expect(mockFs.readFileSync).toHaveBeenCalledWith(mockFilePath, 'utf8');
+        expect(result).toEqual(expectedResult);
+    });
+    it('should throw error when file does not exist', () => {
+        const mockFilePath = '/test/path/nonexistent.json';
+        mockFs.existsSync.mockReturnValue(false);
+        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow(`Failed to load CCT IDs from file: CCT IDs file not found: ${mockFilePath}`);
+    });
+    it('should throw error when JSON is invalid', () => {
+        const mockFilePath = '/test/path/invalid.json';
+        const invalidJson = '["invalid": json}';
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(invalidJson);
+        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('Failed to load CCT IDs from file:');
+    });
+    it('should throw error when JSON is not an array', () => {
+        const mockFilePath = '/test/path/object.json';
+        const objectJson = '{"id": "cct-id-1"}';
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(objectJson);
+        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+    });
+    it('should throw error when array is empty', () => {
+        const mockFilePath = '/test/path/empty.json';
+        const emptyArrayJson = '[]';
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(emptyArrayJson);
+        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+    });
+    it('should throw error when array contains non-string values', () => {
+        const mockFilePath = '/test/path/mixed.json';
+        const mixedArrayJson = '["cct-id-1", 123, "cct-id-3"]';
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(mixedArrayJson);
+        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+    });
+    it('should throw error when array contains empty strings', () => {
+        const mockFilePath = '/test/path/empty-strings.json';
+        const emptyStringsJson = '["cct-id-1", "", "cct-id-3"]';
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(emptyStringsJson);
+        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+    });
+    it('should throw error when array contains whitespace-only strings', () => {
+        const mockFilePath = '/test/path/whitespace.json';
+        const whitespaceJson = '["cct-id-1", "   ", "cct-id-3"]';
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(whitespaceJson);
+        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+    });
+    it('should throw error when JSON is null', () => {
+        const mockFilePath = '/test/path/null.json';
+        const nullJson = 'null';
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(nullJson);
+        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+    });
+    it('should handle single CCT ID in array', () => {
+        const mockFilePath = '/test/path/single.json';
+        const singleIdJson = '["cct-id-only"]';
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(singleIdJson);
+        const result = (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath);
+        expect(result).toEqual(['cct-id-only']);
+    });
+});

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

@@ -8,7 +8,8 @@ export declare enum OptionName {
     MATRIX_IDENTIFIER = "matrix-identifier",
     MATRIX_KEY = "matrix-key",
     CONTENT_API_KEY = "content-api-key",
-    STAGE_OPTIONS = "stage-options"
+    STAGE_OPTIONS = "stage-options",
+    CCT_IDS = "cct-ids"
 }
 export declare const getParamOption: (param: OptionName, makeOptionMandatory?: boolean) => Option;
 export declare const addOverrideUrlOption: (command: Command) => void;

package/lib/migration/utils/options.js

@@ -13,6 +13,7 @@ var OptionName;
     OptionName["MATRIX_KEY"] = "matrix-key";
     OptionName["CONTENT_API_KEY"] = "content-api-key";
     OptionName["STAGE_OPTIONS"] = "stage-options";
+    OptionName["CCT_IDS"] = "cct-ids";
 })(OptionName = exports.OptionName || (exports.OptionName = {}));
 const params = new Map([
     [
@@ -78,6 +79,13 @@ const params = new Map([
             description: 'Path to a JSON file containing stage options',
         },
     ],
+    [
+        OptionName.CCT_IDS,
+        {
+            flags: '--cct-ids <string>',
+            description: 'The IDs of the CCTs to be converted in a pre-migration, or to be skipped in a migration (already converted)',
+        },
+    ],
 ]);
 const getParamOption = (param, makeOptionMandatory = true) => {
     const paramInfo = params.get(param);

package/package.json

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