@squiz/dxp-cli-next 5.26.0-develop.4 → 5.26.0

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

@@ -0,0 +1,276 @@
+"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 ApplicationConfig_1 = require("../../ApplicationConfig");
+const ApiService_1 = require("../../ApiService");
+const _1 = require(".");
+// 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 mockFetchApplicationConfig = ApplicationConfig_1.fetchApplicationConfig;
+const mockApiService = ApiService_1.ApiService;
+describe('createMigration', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.resetAllMocks();
+    });
+    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, _1.validateExportFolder)('/export/path')).not.toThrow();
+        });
+        it('throws error when export folder does not exist', () => {
+            mockFs.existsSync.mockReturnValue(false);
+            expect(() => (0, _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, _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, _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, _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, _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, _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();
+        });
+        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, _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, _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, _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, _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, _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, _1.createMigration)(mockOptions)).rejects.toThrow('Failed to create migration: Unknown error');
+            }));
+        });
+        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, _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, _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, _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');
+            }));
+        });
+    });
+});

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

@@ -0,0 +1,2 @@
+import { GetMigrationOptions, GetMigrationApiResponse } from '../types';
+export declare function getMigration(options: GetMigrationOptions): Promise<GetMigrationApiResponse>;

package/lib/migration/utils/getMigration.js

@@ -0,0 +1,41 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMigration = void 0;
+const ApiService_1 = require("../../ApiService");
+const _1 = require(".");
+function getMigration(options) {
+    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);
+        try {
+            const response = yield apiService.client.get(`${migrationUrl}/${options.migrationId}/assets/${options.assetId}`, {
+                headers: yield (0, _1.getMigrationHeaders)(options.tenant),
+            });
+            if (response.status !== 200) {
+                throw new Error(`Failed to get migration: ${response.status}`);
+            }
+            if (!(response === null || response === void 0 ? void 0 : response.data)) {
+                throw new Error('No data returned from migration service');
+            }
+            return response.data;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw error;
+            }
+            throw new Error(`Failed to get migration: ${error}`);
+        }
+    });
+}
+exports.getMigration = getMigration;

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

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

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

@@ -0,0 +1,156 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ApiService_1 = require("../../ApiService");
+const ApplicationConfig_1 = require("../../ApplicationConfig");
+const getMigration_1 = require("./getMigration");
+jest.mock('path');
+jest.mock('child_process');
+jest.mock('axios');
+jest.mock('../../ApplicationConfig');
+jest.mock('../../ApiService');
+// Mock global fetch
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+describe('getMigration', () => {
+    let mockApiServiceInstance;
+    let mockOptions;
+    const mockApiService = ApiService_1.ApiService;
+    const mockFetchApplicationConfig = ApplicationConfig_1.fetchApplicationConfig;
+    beforeEach(() => {
+        mockApiServiceInstance = {
+            client: {
+                get: jest.fn(),
+            },
+        };
+        mockApiService.mockImplementation(() => mockApiServiceInstance);
+        mockOptions = {
+            migrationId: 'migration-123',
+            assetId: 'asset-456',
+            tenant: 'test-tenant',
+        };
+        mockFetchApplicationConfig.mockResolvedValue({
+            tenant: 'test-tenant',
+            baseUrl: 'https://example.com',
+            region: 'au',
+        });
+    });
+    it('gets migration successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockResponse = {
+            status: 200,
+            data: {
+                migrationId: 'migration-123',
+                assetId: 'asset-456',
+                stage: 'completed',
+                status: 'success',
+                stageDetails: 'Migration completed successfully',
+                previewPageAssetId: 'preview-789',
+                componentsTarDownloadUrl: 'https://download.example.com/components.zip',
+            },
+        };
+        mockApiServiceInstance.client.get.mockResolvedValue(mockResponse);
+        const result = yield (0, getMigration_1.getMigration)(mockOptions);
+        expect(result).toEqual({
+            migrationId: 'migration-123',
+            assetId: 'asset-456',
+            stage: 'completed',
+            status: 'success',
+            stageDetails: 'Migration completed successfully',
+            previewPageAssetId: 'preview-789',
+            componentsTarDownloadUrl: 'https://download.example.com/components.zip',
+        });
+        expect(mockApiServiceInstance.client.get).toHaveBeenCalledWith('https://example.com/__dxp/service/aiapps/migration/migrations/migration-123/assets/asset-456', {
+            headers: {
+                'Content-Type': 'application/json',
+                'x-dxp-tenant': 'test-tenant',
+            },
+        });
+    }));
+    it('gets migration with override URL', () => __awaiter(void 0, void 0, void 0, function* () {
+        const optionsWithOverride = Object.assign(Object.assign({}, mockOptions), { overrideUrl: 'https://custom.migration.url' });
+        const mockResponse = {
+            status: 200,
+            data: {
+                migrationId: 'migration-123',
+                assetId: 'asset-456',
+                stage: 'pending',
+                status: 'processing',
+            },
+        };
+        mockApiServiceInstance.client.get.mockResolvedValue(mockResponse);
+        const result = yield (0, getMigration_1.getMigration)(optionsWithOverride);
+        expect(result.migrationId).toBe('migration-123');
+        expect(result.assetId).toBe('asset-456');
+        expect(mockApiServiceInstance.client.get).toHaveBeenCalledWith('https://custom.migration.url/migrations/migration-123/assets/asset-456', expect.any(Object));
+    }));
+    it('handles non-success status codes', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockResponse = {
+            status: 404,
+            data: {},
+        };
+        mockApiServiceInstance.client.get.mockResolvedValue(mockResponse);
+        yield expect((0, getMigration_1.getMigration)(mockOptions)).rejects.toThrow('Failed to get migration: 404');
+    }));
+    it('handles missing response data', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockResponse = {
+            status: 200,
+            data: null,
+        };
+        mockApiServiceInstance.client.get.mockResolvedValue(mockResponse);
+        yield expect((0, getMigration_1.getMigration)(mockOptions)).rejects.toThrow('No data returned from migration service');
+    }));
+    it('handles API service errors', () => __awaiter(void 0, void 0, void 0, function* () {
+        const error = new Error('Network error');
+        mockApiServiceInstance.client.get.mockRejectedValue(error);
+        yield expect((0, getMigration_1.getMigration)(mockOptions)).rejects.toThrow('Network error');
+    }));
+    it('handles unknown errors', () => __awaiter(void 0, void 0, void 0, function* () {
+        mockApiServiceInstance.client.get.mockRejectedValue('Unknown error');
+        yield expect((0, getMigration_1.getMigration)(mockOptions)).rejects.toThrow('Failed to get migration: Unknown error');
+    }));
+    it('works without optional fields in response', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockResponse = {
+            status: 200,
+            data: {
+                migrationId: 'migration-123',
+                assetId: 'asset-456',
+                stage: 'pending',
+                status: 'processing',
+                // No optional fields: stageDetails, previewPageAssetId, componentsTarDownloadUrl
+            },
+        };
+        mockApiServiceInstance.client.get.mockResolvedValue(mockResponse);
+        const result = yield (0, getMigration_1.getMigration)(mockOptions);
+        expect(result).toEqual({
+            migrationId: 'migration-123',
+            assetId: 'asset-456',
+            stage: 'pending',
+            status: 'processing',
+            stageDetails: undefined,
+            previewPageAssetId: undefined,
+            componentsTarDownloadUrl: undefined,
+        });
+    }));
+    it('constructs correct URL path', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockResponse = {
+            status: 200,
+            data: {
+                migrationId: 'migration-123',
+                assetId: 'asset-456',
+                stage: 'completed',
+                status: 'success',
+            },
+        };
+        mockApiServiceInstance.client.get.mockResolvedValue(mockResponse);
+        yield (0, getMigration_1.getMigration)(mockOptions);
+        expect(mockApiServiceInstance.client.get).toHaveBeenCalledWith('https://example.com/__dxp/service/aiapps/migration/migrations/migration-123/assets/asset-456', expect.any(Object));
+    }));
+});

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

@@ -0,0 +1,7 @@
+export * from './common';
+export * from './options';
+export * from './createMigration';
+export * from './getMigration';
+export * from './nextStage';
+export * from './setMigrationSettings';
+export * from './revertMigration';

package/lib/migration/utils/index.js

@@ -0,0 +1,23 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./common"), exports);
+__exportStar(require("./options"), exports);
+__exportStar(require("./createMigration"), exports);
+__exportStar(require("./getMigration"), exports);
+__exportStar(require("./nextStage"), exports);
+__exportStar(require("./setMigrationSettings"), exports);
+__exportStar(require("./revertMigration"), exports);

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

@@ -0,0 +1,2 @@
+import { NextStageApiResponse, NextStageOptions } from '../types';
+export declare function nextStage(options: NextStageOptions): Promise<NextStageApiResponse>;

package/lib/migration/utils/nextStage.js

@@ -0,0 +1,44 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextStage = void 0;
+const ApiService_1 = require("../../ApiService");
+const _1 = require(".");
+function nextStage(options) {
+    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);
+        try {
+            const response = yield apiService.client.post(`${migrationUrl}/${options.migrationId}/assets/${options.assetId}/next`, {}, {
+                headers: yield (0, _1.getMigrationHeaders)(options.tenant),
+            });
+            if (response.status !== 202) {
+                throw new Error(`Next stage failed with status: ${response.status}`);
+            }
+            const { message } = response.data || {};
+            if (!message) {
+                throw new Error('Invalid response format from next stage');
+            }
+            return {
+                message,
+            };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw error;
+            }
+            throw new Error(`Failed to start next stage: ${error}`);
+        }
+    });
+}
+exports.nextStage = nextStage;

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

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