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

package/lib/migration/utils/common.js

@@ -0,0 +1,129 @@
+"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.redactKey = exports.uploadFileToS3 = exports.getMigrationHeaders = exports.validateAxiosStatus = exports.buildMigrationUrl = exports.throwErrorIfNotLoggedIn = exports.handleCommandError = void 0;
+const fs_1 = __importDefault(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
+const ApplicationConfig_1 = require("../../ApplicationConfig");
+const axios_1 = __importDefault(require("axios"));
+const ApplicationStore_1 = require("../../ApplicationStore");
+/**
+ * The purpose of this file is to provide utilities in common
+ * such as functions that can be reused across the migration service.
+ */
+/**
+ * Handles errors from the migration service.
+ * @param command - The command that is being executed.
+ * @param error - The error that occurred.
+ */
+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;
+/**
+ * Throws an error if the user is not logged in.
+ * @param command - The command that is being executed.
+ */
+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;
+/**
+ * Builds the migration URL.
+ * @param tenantID - The tenant ID.
+ * @param overrideUrl - The override URL.
+ * @returns The migration URL.
+ */
+function buildMigrationUrl(tenantID, overrideUrl, baseDomain = 'migrations') {
+    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/${baseDomain}`;
+        }
+        else {
+            return `${overrideUrl}/${baseDomain}`;
+        }
+    });
+}
+exports.buildMigrationUrl = buildMigrationUrl;
+/**
+ * Validates the status of the axios request.
+ * @param status - The status of the axios request.
+ * @returns True if the status is less than 400, false otherwise.
+ */
+function validateAxiosStatus(status) {
+    return status < 400;
+}
+exports.validateAxiosStatus = validateAxiosStatus;
+function getMigrationHeaders(tenantID, isJson = true) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const existingConfig = yield (0, ApplicationConfig_1.fetchApplicationConfig)(tenantID);
+        return isJson
+            ? {
+                'Content-Type': 'application/json',
+                'x-dxp-tenant': existingConfig.tenant,
+            }
+            : {
+                '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: yield getMigrationHeaders(tenantID, false),
+        });
+        return response.url;
+    });
+}
+exports.uploadFileToS3 = uploadFileToS3;
+function redactKey(key, visibleChars = 3) {
+    if (!key)
+        return '';
+    const len = key.length;
+    if (len <= visibleChars)
+        return '*'.repeat(len);
+    const masked = '*'.repeat(len - visibleChars);
+    return masked + key.slice(-visibleChars);
+}
+exports.redactKey = redactKey;

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

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

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

@@ -0,0 +1,196 @@
+"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 axios_1 = __importDefault(require("axios"));
+const ApplicationConfig_1 = require("../../ApplicationConfig");
+const ApplicationStore_1 = require("../../ApplicationStore");
+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 mockAxios = axios_1.default;
+const mockFetchApplicationConfig = ApplicationConfig_1.fetchApplicationConfig;
+const mockGetApplicationFile = ApplicationStore_1.getApplicationFile;
+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, _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, _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, _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, _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, _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, _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, _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, _1.buildMigrationUrl)('tenant-id');
+            expect(result).toBe('https://example.com/__dxp/service/aiapps/migration/migrations');
+            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, _1.buildMigrationUrl)('tenant-id', overrideUrl);
+            expect(result).toBe(overrideUrl + '/migrations');
+            expect(mockFetchApplicationConfig).not.toHaveBeenCalled();
+        }));
+    });
+    describe('validateAxiosStatus', () => {
+        it('returns true for successful status codes', () => {
+            expect((0, _1.validateAxiosStatus)(200)).toBe(true);
+            expect((0, _1.validateAxiosStatus)(201)).toBe(true);
+            expect((0, _1.validateAxiosStatus)(399)).toBe(true);
+        });
+        it('returns false for error status codes', () => {
+            expect((0, _1.validateAxiosStatus)(400)).toBe(false);
+            expect((0, _1.validateAxiosStatus)(404)).toBe(false);
+            expect((0, _1.validateAxiosStatus)(500)).toBe(false);
+        });
+    });
+    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, _1.getMigrationHeaders)('tenant-id');
+            expect(result).toEqual({
+                'Content-Type': 'application/json',
+                '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, _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, _1.uploadFileToS3)('https://upload.url', '/nonexistent/file.tar.gz')).rejects.toThrow('File not found');
+        }));
+    });
+    describe('redactKey', () => {
+        it('redacts key correctly', () => {
+            expect((0, _1.redactKey)('1234567890', 3)).toBe('*******890');
+            expect((0, _1.redactKey)('1234567890', 1)).toBe('*********0');
+            expect((0, _1.redactKey)('1234567890', 10)).toBe('**********');
+        });
+    });
+});

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

@@ -0,0 +1,9 @@
+import { CreateMigrationOptions, CreateMigrationApiResponse } from '../types';
+export declare function createMigration(options: CreateMigrationOptions): Promise<CreateMigrationApiResponse>;
+export declare function validateExportFolder(exportPath: string): void;
+/**
+ * Creates a tar file from the export path.
+ * @param exportPath - The path to the export folder.
+ * @returns The path to the tar file.
+ */
+export declare function createTarFile(exportPath: string): Promise<string>;

package/lib/migration/utils/createMigration.js

@@ -0,0 +1,122 @@
+"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.createTarFile = exports.validateExportFolder = exports.createMigration = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ApiService_1 = require("../../ApiService");
+const _1 = require(".");
+const child_process_1 = require("child_process");
+function createMigration(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 payload = {
+                assetId: options.assetId,
+                previewAssetId: options.previewAssetId,
+                matrixUrl: options.matrixUrl,
+            };
+            const response = yield apiService.client.post(`${migrationUrl}`, payload, {
+                headers: yield (0, _1.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;
+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;
+/**
+ * Creates a tar file from the export path.
+ * @param exportPath - The path to the export folder.
+ * @returns The path to the tar file.
+ */
+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;

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

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