@contentstack/cli-cm-import 2.0.0-beta.1 → 2.0.0-beta.11

package/lib/import/modules/base-class.js

@@ -54,6 +54,34 @@ class BaseClass {
         (_a = this.progressManager) === null || _a === void 0 ? void 0 : _a.complete(success, error);
         this.progressManager = null;
     }
+    /**
+     * Complete progress and log success/warning message based on errors
+     * Checks the progress manager's failure count to determine if errors occurred
+     * @param options - Options object containing:
+     *   - moduleName: The module name to generate the message (e.g., 'Content types', 'Entries')
+     *                 If not provided, uses this.currentModuleName
+     *   - customSuccessMessage: Optional custom success message. If not provided, generates: "{moduleName} have been imported successfully!"
+     *   - customWarningMessage: Optional custom warning message. If not provided, generates: "{moduleName} have been imported with some errors. Please check the logs at: {sessionLogPath}"
+     *   - context: Optional context for logging
+     */
+    completeProgressWithMessage(options) {
+        var _a, _b;
+        const logContext = (options === null || options === void 0 ? void 0 : options.context) || ((_a = this.importConfig) === null || _a === void 0 ? void 0 : _a.context) || {};
+        const failureCount = ((_b = this.progressManager) === null || _b === void 0 ? void 0 : _b.getFailureCount()) || 0;
+        const hasErrors = failureCount > 0;
+        const name = (options === null || options === void 0 ? void 0 : options.moduleName) || this.currentModuleName || 'Module';
+        // Generate default messages if not provided
+        const successMessage = (options === null || options === void 0 ? void 0 : options.customSuccessMessage) || `${name} have been imported successfully!`;
+        const sessionLogPath = (0, cli_utilities_1.getSessionLogPath)();
+        const warningMessage = (options === null || options === void 0 ? void 0 : options.customWarningMessage) || `${name} have been imported with some errors. Please check the logs at: ${sessionLogPath}`;
+        this.completeProgress(true);
+        if (hasErrors) {
+            cli_utilities_1.log.warn(warningMessage, logContext);
+        }
+        else {
+            cli_utilities_1.log.success(successMessage, logContext);
+        }
+    }
     async withLoadingSpinner(message, action) {
         var _a;
         const logConfig = cli_utilities_1.configHandler.get('log') || {};
@@ -337,7 +365,9 @@ class BaseClass {
                 if (!apiData || !apiData.filePath) {
                     return Promise.resolve();
                 }
-                return this.stack.taxonomy(uid).import({ taxonomy: apiData.filePath }).then(onSuccess).catch(onReject);
+                const importParams = { taxonomy: apiData.filePath };
+                const importQueryParam = apiOptions.queryParam || {};
+                return this.stack.taxonomy(uid).import(importParams, importQueryParam).then(onSuccess).catch(onReject);
             default:
                 return Promise.resolve();
         }

package/lib/import/modules/composable-studio.d.ts

@@ -0,0 +1,44 @@
+import { ModuleClassParams, ComposableStudioProject } from '../../types';
+export default class ImportComposableStudio {
+    private importConfig;
+    private composableStudioConfig;
+    private composableStudioPath;
+    private composableStudioFilePath;
+    private apiClient;
+    private envUidMapperPath;
+    private envUidMapper;
+    private projectMapperPath;
+    constructor({ importConfig }: ModuleClassParams);
+    /**
+     * Entry point for Studio import
+     */
+    start(): Promise<void>;
+    /**
+     * Initialize authentication headers for API calls
+     */
+    addAuthHeaders(): Promise<boolean>;
+    /**
+     * Load environment UID mapper from backup directory
+     */
+    loadEnvironmentMapper(): Promise<void>;
+    /**
+     * Read exported project from file system
+     */
+    readExportedProject(): Promise<ComposableStudioProject | null>;
+    /**
+     * Check if target stack already has a connected project
+     */
+    getExistingProject(): Promise<ComposableStudioProject | null>;
+    /**
+     * Import project with name conflict handling
+     */
+    importProject(exportedProject: ComposableStudioProject): Promise<void>;
+    /**
+     * Map environment UID from source to target
+     */
+    mapEnvironmentUid(sourceEnvUid: string): string;
+    /**
+     * Prompt user for a new project name when conflict occurs
+     */
+    promptForNewProjectName(currentName: string): Promise<string>;
+}

package/lib/import/modules/composable-studio.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const node_path_1 = require("node:path");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const constants_1 = require("../../constants");
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const utils_1 = require("../../utils");
+class ImportComposableStudio {
+    constructor({ importConfig }) {
+        this.importConfig = importConfig;
+        this.importConfig.context.module = 'composable-studio';
+        this.composableStudioConfig = importConfig.modules['composable-studio'];
+        // Setup paths
+        this.composableStudioPath = (0, node_path_1.join)(this.importConfig.backupDir, this.composableStudioConfig.dirName);
+        this.projectMapperPath = (0, node_path_1.join)(this.importConfig.backupDir, constants_1.PATH_CONSTANTS.MAPPER, this.composableStudioConfig.dirName);
+        this.composableStudioFilePath = (0, node_path_1.join)(this.composableStudioPath, this.composableStudioConfig.fileName);
+        this.envUidMapperPath = (0, node_path_1.join)(this.importConfig.backupDir, constants_1.PATH_CONSTANTS.MAPPER, constants_1.PATH_CONSTANTS.MAPPER_MODULES.ENVIRONMENTS, constants_1.PATH_CONSTANTS.FILES.UID_MAPPING);
+        this.envUidMapper = {};
+        // Initialize HttpClient with Studio API base URL
+        this.apiClient = new cli_utilities_1.HttpClient();
+        this.apiClient.baseUrl(`${this.composableStudioConfig.apiBaseUrl}/${this.composableStudioConfig.apiVersion}`);
+    }
+    /**
+     * Entry point for Studio import
+     */
+    async start() {
+        if (this.importConfig.management_token) {
+            cli_utilities_1.log.warn('Skipping Studio project import when using management token', this.importConfig.context);
+            return;
+        }
+        cli_utilities_1.log.debug('Starting Studio project import process...', this.importConfig.context);
+        try {
+            // Initialize authentication
+            const authInitialized = await this.addAuthHeaders();
+            if (!authInitialized) {
+                cli_utilities_1.log.warn('Skipping Studio project import when using OAuth authentication', this.importConfig.context);
+                return;
+            }
+            // Load environment UID mapper
+            await this.loadEnvironmentMapper();
+            // Read exported project data
+            const exportedProject = await this.readExportedProject();
+            if (!exportedProject) {
+                cli_utilities_1.log.warn(cli_utilities_1.messageHandler.parse('COMPOSABLE_STUDIO_NOT_FOUND'), this.importConfig.context);
+                return;
+            }
+            cli_utilities_1.log.debug(`Exported project found: ${exportedProject.name}`, this.importConfig.context);
+            // Check if target stack already has a connected project
+            const existingProject = await this.getExistingProject();
+            if (existingProject) {
+                cli_utilities_1.log.warn(cli_utilities_1.messageHandler.parse('COMPOSABLE_STUDIO_SKIP_EXISTING'), this.importConfig.context);
+                return;
+            }
+            // Import the project with name conflict handling
+            await this.importProject(exportedProject);
+            cli_utilities_1.log.success(cli_utilities_1.messageHandler.parse('COMPOSABLE_STUDIO_IMPORT_COMPLETE', exportedProject.name), this.importConfig.context);
+        }
+        catch (error) {
+            (0, cli_utilities_1.handleAndLogError)(error, Object.assign({}, this.importConfig.context));
+        }
+    }
+    /**
+     * Initialize authentication headers for API calls
+     */
+    async addAuthHeaders() {
+        cli_utilities_1.log.debug('Initializing Studio API authentication...', this.importConfig.context);
+        // Get authentication details - following personalization-api-adapter pattern
+        await cli_utilities_1.authenticationHandler.getAuthDetails();
+        const token = cli_utilities_1.authenticationHandler.accessToken;
+        cli_utilities_1.log.debug(`Authentication type: ${cli_utilities_1.authenticationHandler.isOauthEnabled ? 'OAuth' : 'Token'}`, this.importConfig.context);
+        // Set authentication headers based on auth type
+        if (cli_utilities_1.authenticationHandler.isOauthEnabled) {
+            cli_utilities_1.log.debug('Skipping setting OAuth authorization header when using OAuth authentication', this.importConfig.context);
+            return false;
+        }
+        else {
+            // TODO: Currenlty assuming if auth type is not OAuth, it is Basic Auth and we are setting authtoken header
+            cli_utilities_1.log.debug('Setting authtoken header', this.importConfig.context);
+            this.apiClient.headers({ authtoken: token });
+        }
+        // Set organization_uid header
+        this.apiClient.headers({
+            organization_uid: this.importConfig.org_uid,
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+        });
+        cli_utilities_1.log.debug('Studio API authentication initialized', this.importConfig.context);
+        return true;
+    }
+    /**
+     * Load environment UID mapper from backup directory
+     */
+    async loadEnvironmentMapper() {
+        cli_utilities_1.log.debug('Loading environment UID mapper...', this.importConfig.context);
+        if (utils_1.fileHelper.fileExistsSync(this.envUidMapperPath)) {
+            this.envUidMapper = utils_1.fileHelper.readFileSync(this.envUidMapperPath);
+            cli_utilities_1.log.debug(`Environment mapper loaded with ${Object.keys(this.envUidMapper).length} mappings`, this.importConfig.context);
+        }
+        else {
+            cli_utilities_1.log.debug('No environment UID mapper found', this.importConfig.context);
+        }
+    }
+    /**
+     * Read exported project from file system
+     */
+    async readExportedProject() {
+        cli_utilities_1.log.debug(`Reading exported project from: ${this.composableStudioFilePath}`, this.importConfig.context);
+        if (!utils_1.fileHelper.fileExistsSync(this.composableStudioFilePath)) {
+            cli_utilities_1.log.debug('Studio project file does not exist', this.importConfig.context);
+            return null;
+        }
+        const projectData = utils_1.fileHelper.readFileSync(this.composableStudioFilePath);
+        if (!projectData || (0, isEmpty_1.default)(projectData)) {
+            cli_utilities_1.log.debug('Studio project file is empty', this.importConfig.context);
+            return null;
+        }
+        return projectData;
+    }
+    /**
+     * Check if target stack already has a connected project
+     */
+    async getExistingProject() {
+        var _a;
+        cli_utilities_1.log.debug('Checking if target stack already has a connected project...', this.importConfig.context);
+        try {
+            const apiUrl = '/projects';
+            cli_utilities_1.log.debug(`Fetching projects from: ${this.composableStudioConfig.apiBaseUrl}${apiUrl}`, this.importConfig.context);
+            const response = await this.apiClient.get(apiUrl);
+            if (response.status < 200 || response.status >= 300) {
+                throw new Error(`API call failed with status ${response.status}: ${JSON.stringify(response.data)}`);
+            }
+            const projects = ((_a = response.data) === null || _a === void 0 ? void 0 : _a.projects) || [];
+            cli_utilities_1.log.debug(`Found ${projects.length} projects in organization`, this.importConfig.context);
+            // Filter projects by connected stack API key
+            const connectedProject = projects.find((project) => project.connectedStackApiKey === this.importConfig.apiKey);
+            if (connectedProject) {
+                cli_utilities_1.log.debug(`Target stack already has connected project: ${connectedProject.name}`, this.importConfig.context);
+                return connectedProject;
+            }
+            cli_utilities_1.log.debug('Target stack does not have a connected project', this.importConfig.context);
+            return null;
+        }
+        catch (error) {
+            cli_utilities_1.log.debug(`Error checking for existing project: ${error.message}`, this.importConfig.context);
+            throw error;
+        }
+    }
+    /**
+     * Import project with name conflict handling
+     */
+    async importProject(exportedProject) {
+        var _a, _b, _c;
+        cli_utilities_1.log.debug('Starting project import...', this.importConfig.context);
+        // Map environment UID
+        const mappedEnvironmentUid = this.mapEnvironmentUid(exportedProject.settings.configuration.environment);
+        // Prepare project data for import
+        const projectData = {
+            name: exportedProject.name,
+            connectedStackApiKey: this.importConfig.apiKey,
+            contentTypeUid: exportedProject.contentTypeUid,
+            description: exportedProject.description || '',
+            canvasUrl: exportedProject.canvasUrl || '/',
+            settings: {
+                configuration: {
+                    environment: mappedEnvironmentUid,
+                    locale: ((_b = (_a = exportedProject === null || exportedProject === void 0 ? void 0 : exportedProject.settings) === null || _a === void 0 ? void 0 : _a.configuration) === null || _b === void 0 ? void 0 : _b.locale) || '',
+                },
+            },
+        };
+        cli_utilities_1.log.debug(`Project data prepared: ${JSON.stringify(projectData, null, 2)}`, this.importConfig.context);
+        // Try to create project with name conflict retry loop
+        let projectCreated = false;
+        let currentName = projectData.name;
+        let attemptCount = 0;
+        while (!projectCreated) {
+            attemptCount++;
+            cli_utilities_1.log.debug(`Attempt ${attemptCount} to create project with name: ${currentName}`, this.importConfig.context);
+            projectData.name = currentName;
+            const response = await this.apiClient.post('/projects', projectData);
+            if (response.status >= 200 && response.status < 300) {
+                projectCreated = true;
+                cli_utilities_1.log.debug(`Project created successfully with UID: ${(_c = response.data) === null || _c === void 0 ? void 0 : _c.uid}`, this.importConfig.context);
+                // Create mapper directory if it doesn't exist
+                await utils_1.fsUtil.makeDirectory(this.projectMapperPath);
+                // write the project to file
+                const projectFileSuccessPath = (0, node_path_1.join)(this.projectMapperPath, this.composableStudioConfig.fileName);
+                utils_1.fsUtil.writeFile(projectFileSuccessPath, response.data);
+                cli_utilities_1.log.debug(`Project written to: ${projectFileSuccessPath}`, this.importConfig.context);
+            }
+            else {
+                throw new Error(`API call failed with status ${response.status}: ${JSON.stringify(response.data)}`);
+            }
+        }
+    }
+    /**
+     * Map environment UID from source to target
+     */
+    mapEnvironmentUid(sourceEnvUid) {
+        if (!sourceEnvUid) {
+            cli_utilities_1.log.debug('Source environment UID is empty', this.importConfig.context);
+            return '';
+        }
+        cli_utilities_1.log.debug(`Mapping source environment UID: ${sourceEnvUid}`, this.importConfig.context);
+        if ((0, isEmpty_1.default)(this.envUidMapper)) {
+            cli_utilities_1.log.warn(cli_utilities_1.messageHandler.parse('COMPOSABLE_STUDIO_ENV_MAPPING_FAILED', sourceEnvUid), this.importConfig.context);
+            return '';
+        }
+        const mappedUid = this.envUidMapper[sourceEnvUid];
+        if (!mappedUid) {
+            cli_utilities_1.log.warn(cli_utilities_1.messageHandler.parse('COMPOSABLE_STUDIO_ENV_MAPPING_FAILED', sourceEnvUid), this.importConfig.context);
+            return '';
+        }
+        cli_utilities_1.log.debug(`Mapped environment UID: ${sourceEnvUid} → ${mappedUid}`, this.importConfig.context);
+        return mappedUid;
+    }
+    /**
+     * Prompt user for a new project name when conflict occurs
+     */
+    async promptForNewProjectName(currentName) {
+        const suggestedName = `Copy of ${currentName}`;
+        cli_utilities_1.log.warn(cli_utilities_1.messageHandler.parse('COMPOSABLE_STUDIO_NAME_CONFLICT', currentName), this.importConfig.context);
+        cli_utilities_1.log.info(cli_utilities_1.messageHandler.parse('COMPOSABLE_STUDIO_SUGGEST_NAME', suggestedName), this.importConfig.context);
+        const response = await cli_utilities_1.cliux.inquire({
+            type: 'input',
+            name: 'projectName',
+            message: 'Enter new project name:',
+            default: suggestedName,
+        });
+        const newName = response.projectName || suggestedName;
+        cli_utilities_1.log.debug(`User provided new project name: ${newName}`, this.importConfig.context);
+        return newName;
+    }
+}
+exports.default = ImportComposableStudio;

package/lib/import/modules/content-types.d.ts

@@ -25,6 +25,8 @@ export default class ContentTypesImport extends BaseClass {
     private extPendingPath;
     private isExtensionsUpdate;
     private pendingExts;
+    private composableStudioSuccessPath;
+    private composableStudioExportPath;
     constructor({ importConfig, stackAPIClient }: ModuleClassParams);
     start(): Promise<any>;
     seedCTs(): Promise<any>;

package/lib/import/modules/content-types.js

@@ -1,9 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+/* eslint-disable no-prototype-builtins */
+/*!
+ * Contentstack Import
+ * Copyright (c) 2026 Contentstack LLC
+ * MIT Licensed
+ */
 const path = tslib_1.__importStar(require("path"));
 const lodash_1 = require("lodash");
 const cli_utilities_1 = require("@contentstack/cli-utilities");
+const constants_1 = require("../../constants");
 const base_class_1 = tslib_1.__importDefault(require("./base-class"));
 const content_type_helper_1 = require("../../utils/content-type-helper");
 const utils_1 = require("../../utils");
@@ -16,19 +23,28 @@ class ContentTypesImport extends base_class_1.default {
         this.cTsConfig = importConfig.modules['content-types'];
         this.gFsConfig = importConfig.modules['global-fields'];
         this.reqConcurrency = this.cTsConfig.writeConcurrency || this.importConfig.writeConcurrency;
-        this.cTsFolderPath = path.join((0, cli_utilities_1.sanitizePath)(this.importConfig.data), (0, cli_utilities_1.sanitizePath)(this.cTsConfig.dirName));
-        this.cTsMapperPath = path.join((0, cli_utilities_1.sanitizePath)(this.importConfig.data), 'mapper', 'content_types');
-        this.cTsSuccessPath = path.join((0, cli_utilities_1.sanitizePath)(this.importConfig.data), 'mapper', 'content_types', 'success.json');
-        this.gFsFolderPath = path.resolve((0, cli_utilities_1.sanitizePath)(this.importConfig.data), (0, cli_utilities_1.sanitizePath)(this.gFsConfig.dirName));
-        this.gFsMapperFolderPath = path.join((0, cli_utilities_1.sanitizePath)(importConfig.data), 'mapper', 'global_fields', 'success.json');
-        this.gFsPendingPath = path.join((0, cli_utilities_1.sanitizePath)(importConfig.data), 'mapper', 'global_fields', 'pending_global_fields.js');
-        this.marketplaceAppMapperPath = path.join((0, cli_utilities_1.sanitizePath)(this.importConfig.data), 'mapper', 'marketplace_apps', 'uid-mapping.json');
+        this.cTsFolderPath = path.join((0, cli_utilities_1.sanitizePath)(this.importConfig.contentDir), (0, cli_utilities_1.sanitizePath)(this.cTsConfig.dirName));
+        this.cTsMapperPath = path.join((0, cli_utilities_1.sanitizePath)(this.importConfig.backupDir), constants_1.PATH_CONSTANTS.MAPPER, constants_1.PATH_CONSTANTS.MAPPER_MODULES.CONTENT_TYPES);
+        this.cTsSuccessPath = path.join((0, cli_utilities_1.sanitizePath)(this.importConfig.backupDir), constants_1.PATH_CONSTANTS.MAPPER, constants_1.PATH_CONSTANTS.MAPPER_MODULES.CONTENT_TYPES, constants_1.PATH_CONSTANTS.FILES.SUCCESS);
+        this.gFsFolderPath = path.resolve((0, cli_utilities_1.sanitizePath)(this.importConfig.backupDir), (0, cli_utilities_1.sanitizePath)(this.gFsConfig.dirName));
+        this.gFsMapperFolderPath = path.join((0, cli_utilities_1.sanitizePath)(importConfig.backupDir), constants_1.PATH_CONSTANTS.MAPPER, constants_1.PATH_CONSTANTS.MAPPER_MODULES.GLOBAL_FIELDS, constants_1.PATH_CONSTANTS.FILES.SUCCESS);
+        this.gFsPendingPath = path.join((0, cli_utilities_1.sanitizePath)(importConfig.backupDir), constants_1.PATH_CONSTANTS.MAPPER, constants_1.PATH_CONSTANTS.MAPPER_MODULES.GLOBAL_FIELDS, constants_1.PATH_CONSTANTS.FILES.PENDING_GLOBAL_FIELDS);
+        this.marketplaceAppMapperPath = path.join((0, cli_utilities_1.sanitizePath)(this.importConfig.backupDir), constants_1.PATH_CONSTANTS.MAPPER, constants_1.PATH_CONSTANTS.MAPPER_MODULES.MARKETPLACE_APPS, constants_1.PATH_CONSTANTS.FILES.UID_MAPPING);
         this.ignoredFilesInContentTypesFolder = new Map([
             ['__master.json', 'true'],
             ['__priority.json', 'true'],
-            ['schema.json', 'true'],
+            [constants_1.PATH_CONSTANTS.FILES.SCHEMA, 'true'],
             ['.DS_Store', 'true'],
         ]);
+        // Initialize composable studio paths if config exists
+        if (this.importConfig.modules['composable-studio']) {
+            this.composableStudioSuccessPath = path.join((0, cli_utilities_1.sanitizePath)(importConfig.backupDir), constants_1.PATH_CONSTANTS.MAPPER, this.importConfig.modules['composable-studio'].dirName, this.importConfig.modules['composable-studio'].fileName);
+            this.composableStudioExportPath = path.join((0, cli_utilities_1.sanitizePath)(importConfig.backupDir), this.importConfig.modules['composable-studio'].dirName, this.importConfig.modules['composable-studio'].fileName);
+        }
+        else {
+            this.composableStudioSuccessPath = '';
+            this.composableStudioExportPath = '';
+        }
         this.cTs = [];
         this.createdCTs = [];
         this.titleToUIdMap = new Map();
@@ -37,8 +53,8 @@ class ContentTypesImport extends base_class_1.default {
         this.createdGFs = [];
         this.pendingGFs = [];
         this.pendingExts = [];
-        this.taxonomiesPath = path.join((0, cli_utilities_1.sanitizePath)(importConfig.data), 'mapper', 'taxonomies', 'success.json');
-        this.extPendingPath = path.join((0, cli_utilities_1.sanitizePath)(importConfig.data), 'mapper', 'extensions', 'pending_extensions.js');
+        this.taxonomiesPath = path.join((0, cli_utilities_1.sanitizePath)(importConfig.contentDir), constants_1.PATH_CONSTANTS.MAPPER, constants_1.PATH_CONSTANTS.MAPPER_MODULES.TAXONOMIES, constants_1.PATH_CONSTANTS.FILES.SUCCESS);
+        this.extPendingPath = path.join((0, cli_utilities_1.sanitizePath)(importConfig.contentDir), constants_1.PATH_CONSTANTS.MAPPER, constants_1.PATH_CONSTANTS.MAPPER_MODULES.EXTENSIONS, constants_1.PATH_CONSTANTS.FILES.PENDING_EXTENSIONS);
     }
     async start() {
         var _a;
@@ -49,6 +65,30 @@ class ContentTypesImport extends base_class_1.default {
                 cli_utilities_1.log.info('No content type found to import', this.importConfig.context);
                 return;
             }
+            // If success file doesn't exist but export file does, skip the composition content type
+            // Only check if composable studio paths are configured
+            if (this.composableStudioSuccessPath &&
+                this.composableStudioExportPath &&
+                !utils_1.fileHelper.fileExistsSync(this.composableStudioSuccessPath) &&
+                utils_1.fileHelper.fileExistsSync(this.composableStudioExportPath)) {
+                const exportedProject = utils_1.fileHelper.readFileSync(this.composableStudioExportPath);
+                if (exportedProject === null || exportedProject === void 0 ? void 0 : exportedProject.contentTypeUid) {
+                    const originalCount = this.cTs.length;
+                    this.cTs = this.cTs.filter((ct) => {
+                        const shouldSkip = ct.uid === exportedProject.contentTypeUid;
+                        if (shouldSkip) {
+                            cli_utilities_1.log.info(`Skipping content type '${ct.uid}' as Composable Studio project was not created successfully`, this.importConfig.context);
+                        }
+                        return !shouldSkip;
+                    });
+                    const skippedCount = originalCount - this.cTs.length;
+                    if (skippedCount > 0) {
+                        cli_utilities_1.log.debug(`Filtered out ${skippedCount} composition content type(s) from import`, this.importConfig.context);
+                    }
+                }
+            }
+            await utils_1.fsUtil.makeDirectory(this.cTsMapperPath);
+            cli_utilities_1.log.debug('Created content types mapper directory.', this.importConfig.context);
             await utils_1.fsUtil.makeDirectory(this.cTsMapperPath);
             cli_utilities_1.log.debug('Created content types mapper directory', this.importConfig.context);
             const progress = this.initializeProgress();
@@ -66,8 +106,7 @@ class ContentTypesImport extends base_class_1.default {
             if (this.pendingGFs.length > 0) {
                 await this.handlePendingGlobalFields(progress);
             }
-            this.completeProgress(true);
-            cli_utilities_1.log.success('Content types have been imported successfully!', this.importConfig.context);
+            this.completeProgressWithMessage();
         }
         catch (error) {
             this.completeProgress(false, (error === null || error === void 0 ? void 0 : error.message) || 'Content types import failed');
@@ -282,7 +321,7 @@ class ContentTypesImport extends base_class_1.default {
     async analyzeImportData() {
         var _a, _b, _c, _d, _e;
         const [cts, gfs, pendingGfs, pendingExt] = await this.withLoadingSpinner('CONTENT TYPES: Analyzing import data...', async () => {
-            const cts = utils_1.fsUtil.readFile(path.join(this.cTsFolderPath, 'schema.json'));
+            const cts = (0, cli_utilities_1.readContentTypeSchemas)(this.cTsFolderPath);
             const gfs = utils_1.fsUtil.readFile(path.resolve(this.gFsFolderPath, this.gFsConfig.fileName));
             const pendingGfs = utils_1.fsUtil.readFile(this.gFsPendingPath);
             const pendingExt = utils_1.fsUtil.readFile(this.extPendingPath);

package/lib/import/modules/custom-roles.js

@@ -6,6 +6,7 @@ const values_1 = tslib_1.__importDefault(require("lodash/values"));
 const node_path_1 = require("node:path");
 const lodash_1 = require("lodash");
 const cli_utilities_1 = require("@contentstack/cli-utilities");
+const constants_1 = require("../../constants");
 const utils_1 = require("../../utils");
 const base_class_1 = tslib_1.__importDefault(require("./base-class"));
 class ImportCustomRoles extends base_class_1.default {
@@ -49,13 +50,13 @@ class ImportCustomRoles extends base_class_1.default {
         this.importConfig.context.module = utils_1.MODULE_CONTEXTS.CUSTOM_ROLES;
         this.currentModuleName = utils_1.MODULE_NAMES[utils_1.MODULE_CONTEXTS.CUSTOM_ROLES];
         this.customRolesConfig = importConfig.modules.customRoles;
-        this.customRolesMapperPath = (0, node_path_1.join)(this.importConfig.backupDir, 'mapper', 'custom-roles');
+        this.customRolesMapperPath = (0, node_path_1.join)(this.importConfig.backupDir, constants_1.PATH_CONSTANTS.MAPPER, constants_1.PATH_CONSTANTS.MAPPER_MODULES.CUSTOM_ROLES);
         this.customRolesFolderPath = (0, node_path_1.join)(this.importConfig.backupDir, this.customRolesConfig.dirName);
-        this.customRolesUidMapperPath = (0, node_path_1.join)(this.customRolesMapperPath, 'uid-mapping.json');
-        this.envUidMapperFolderPath = (0, node_path_1.join)(this.importConfig.backupDir, 'mapper', 'environments');
-        this.entriesUidMapperFolderPath = (0, node_path_1.join)(this.importConfig.backupDir, 'mapper', 'entries');
-        this.createdCustomRolesPath = (0, node_path_1.join)(this.customRolesMapperPath, 'success.json');
-        this.customRolesFailsPath = (0, node_path_1.join)(this.customRolesMapperPath, 'fails.json');
+        this.customRolesUidMapperPath = (0, node_path_1.join)(this.customRolesMapperPath, constants_1.PATH_CONSTANTS.FILES.UID_MAPPING);
+        this.envUidMapperFolderPath = (0, node_path_1.join)(this.importConfig.backupDir, constants_1.PATH_CONSTANTS.MAPPER, constants_1.PATH_CONSTANTS.MAPPER_MODULES.ENVIRONMENTS);
+        this.entriesUidMapperFolderPath = (0, node_path_1.join)(this.importConfig.backupDir, constants_1.PATH_CONSTANTS.MAPPER, constants_1.PATH_CONSTANTS.MAPPER_MODULES.ENTRIES);
+        this.createdCustomRolesPath = (0, node_path_1.join)(this.customRolesMapperPath, constants_1.PATH_CONSTANTS.FILES.SUCCESS);
+        this.customRolesFailsPath = (0, node_path_1.join)(this.customRolesMapperPath, constants_1.PATH_CONSTANTS.FILES.FAILS);
         this.customRoles = {};
         this.failedCustomRoles = [];
         this.createdCustomRoles = [];
@@ -84,8 +85,7 @@ class ImportCustomRoles extends base_class_1.default {
             progress.updateStatus(utils_1.PROCESS_STATUS[utils_1.PROCESS_NAMES.CUSTOM_ROLES_IMPORT].IMPORTING);
             await this.importCustomRoles();
             this.handleImportResults();
-            this.completeProgress(true);
-            cli_utilities_1.log.success('Custom roles have been imported successfully!', this.importConfig.context);
+            this.completeProgressWithMessage();
         }
         catch (error) {
             this.completeProgress(false, (error === null || error === void 0 ? void 0 : error.message) || 'Custom roles import failed');
@@ -233,8 +233,8 @@ class ImportCustomRoles extends base_class_1.default {
         cli_utilities_1.log.debug('Creating custom roles mapper directory', this.importConfig.context);
         await utils_1.fsUtil.makeDirectory(this.customRolesMapperPath);
         this.customRolesUidMapper = this.loadJsonFileIfExists(this.customRolesUidMapperPath, 'custom roles');
-        this.environmentsUidMap = this.loadJsonFileIfExists((0, node_path_1.join)(this.envUidMapperFolderPath, 'uid-mapping.json'), 'environments');
-        this.entriesUidMap = this.loadJsonFileIfExists((0, node_path_1.join)(this.entriesUidMapperFolderPath, 'uid-mapping.json'), 'entries');
+        this.environmentsUidMap = this.loadJsonFileIfExists((0, node_path_1.join)(this.envUidMapperFolderPath, constants_1.PATH_CONSTANTS.FILES.UID_MAPPING), 'environments');
+        this.entriesUidMap = this.loadJsonFileIfExists((0, node_path_1.join)(this.entriesUidMapperFolderPath, constants_1.PATH_CONSTANTS.FILES.UID_MAPPING), 'entries');
     }
     loadJsonFileIfExists(path, label) {
         if (utils_1.fileHelper.fileExistsSync(path)) {

package/lib/import/modules/entries.d.ts

@@ -38,6 +38,8 @@ export default class EntriesImport extends BaseClass {
         locale: string;
         entry_uid: string;
     }>;
+    private composableStudioSuccessPath;
+    private composableStudioExportPath;
     constructor({ importConfig, stackAPIClient }: ModuleClassParams);
     start(): Promise<any>;
     private analyzeEntryData;