@contentstack/cli-cm-export 2.0.0-beta.1 → 2.0.0-beta.10

package/lib/export/modules/taxonomies.js

@@ -11,63 +11,45 @@ const utils_1 = require("../../utils");
 class ExportTaxonomies extends base_class_1.default {
     constructor({ exportConfig, stackAPIClient }) {
         super({ exportConfig, stackAPIClient });
+        this.isLocaleBasedExportSupported = true; // Flag to track if locale-based export is supported
         this.taxonomies = {};
+        this.taxonomiesByLocale = {};
         this.taxonomiesConfig = exportConfig.modules.taxonomies;
         this.qs = { include_count: true, limit: this.taxonomiesConfig.limit || 100, skip: 0 };
         this.applyQueryFilters(this.qs, 'taxonomies');
         this.exportConfig.context.module = utils_1.MODULE_CONTEXTS.TAXONOMIES;
         this.currentModuleName = utils_1.MODULE_NAMES[utils_1.MODULE_CONTEXTS.TAXONOMIES];
+        this.localesFilePath = (0, node_path_1.resolve)((0, cli_utilities_1.sanitizePath)(exportConfig.exportDir), (0, cli_utilities_1.sanitizePath)(exportConfig.branchName || ''), (0, cli_utilities_1.sanitizePath)(exportConfig.modules.locales.dirName), (0, cli_utilities_1.sanitizePath)(exportConfig.modules.locales.fileName));
     }
     async start() {
         var _a;
         try {
-            cli_utilities_1.log.debug('Starting taxonomies export process...', this.exportConfig.context);
-            // Setup with loading spinner
-            const [totalCount] = await this.withLoadingSpinner('TAXONOMIES: Analyzing taxonomy structure...', async () => {
-                this.taxonomiesFolderPath = (0, node_path_1.resolve)(this.exportConfig.data, this.exportConfig.branchName || '', this.taxonomiesConfig.dirName);
-                await utils_1.fsUtil.makeDirectory(this.taxonomiesFolderPath);
-                // Get count first for progress tracking
-                const countResponse = await this.stack
-                    .taxonomy()
-                    .query(Object.assign(Object.assign({}, this.qs), { include_count: true, limit: 1 }))
-                    .find();
-                return [countResponse.count || 0];
-            });
+            cli_utilities_1.log.debug('Starting export process for taxonomies...', this.exportConfig.context);
+            const totalCount = await this.initializeExport();
             if (totalCount === 0) {
                 cli_utilities_1.log.info(cli_utilities_1.messageHandler.parse('TAXONOMY_NOT_FOUND'), this.exportConfig.context);
                 return;
             }
-            // Create nested progress manager
-            const progress = this.createNestedProgress(this.currentModuleName);
-            // Add sub-processes
-            progress.addProcess(utils_1.PROCESS_NAMES.FETCH_TAXONOMIES, totalCount);
-            progress.addProcess(utils_1.PROCESS_NAMES.EXPORT_TAXONOMIES_TERMS, totalCount);
-            // Fetch taxonomies
+            const progress = this.setupProgress(totalCount);
+            const localesToExport = this.getLocalesToExport();
+            if (localesToExport.length === 0) {
+                cli_utilities_1.log.warn('No locales found to export', this.exportConfig.context);
+                this.completeProgress(true);
+                return;
+            }
+            // Start fetch process
             progress
                 .startProcess(utils_1.PROCESS_NAMES.FETCH_TAXONOMIES)
                 .updateStatus(utils_1.PROCESS_STATUS[utils_1.PROCESS_NAMES.FETCH_TAXONOMIES].FETCHING, utils_1.PROCESS_NAMES.FETCH_TAXONOMIES);
-            await this.getAllTaxonomies();
+            // Determine export strategy and fetch taxonomies
+            await this.determineExportStrategy((_a = this.exportConfig.master_locale) === null || _a === void 0 ? void 0 : _a.code);
+            await this.fetchAllTaxonomies(localesToExport);
             progress.completeProcess(utils_1.PROCESS_NAMES.FETCH_TAXONOMIES, true);
-            const actualTaxonomyCount = (_a = Object.keys(this.taxonomies || {})) === null || _a === void 0 ? void 0 : _a.length;
-            cli_utilities_1.log.debug(`Found ${actualTaxonomyCount} taxonomies to export (API reported ${totalCount})`, this.exportConfig.context);
-            // Update progress for export step if counts differ
-            if (actualTaxonomyCount !== totalCount && actualTaxonomyCount > 0) {
-                // Remove the old process and add with correct count
-                progress.addProcess(utils_1.PROCESS_NAMES.EXPORT_TAXONOMIES_TERMS, actualTaxonomyCount);
-            }
-            // Export detailed taxonomies
-            if (actualTaxonomyCount > 0) {
-                progress
-                    .startProcess(utils_1.PROCESS_NAMES.EXPORT_TAXONOMIES_TERMS)
-                    .updateStatus(utils_1.PROCESS_STATUS[utils_1.PROCESS_NAMES.EXPORT_TAXONOMIES_TERMS].EXPORTING, utils_1.PROCESS_NAMES.EXPORT_TAXONOMIES_TERMS);
-                await this.exportTaxonomies();
-                progress.completeProcess(utils_1.PROCESS_NAMES.EXPORT_TAXONOMIES_TERMS, true);
-            }
-            else {
-                cli_utilities_1.log.info('No taxonomies found to export detailed information', this.exportConfig.context);
-            }
-            const taxonomyCount = Object.keys(this.taxonomies || {}).length;
-            cli_utilities_1.log.success(cli_utilities_1.messageHandler.parse('TAXONOMY_EXPORT_COMPLETE', taxonomyCount), this.exportConfig.context);
+            // Export taxonomies with detailed information
+            const actualCount = await this.exportAllTaxonomies(progress, localesToExport, totalCount);
+            // Write metadata and complete
+            await this.writeTaxonomiesMetadata();
+            cli_utilities_1.log.success(cli_utilities_1.messageHandler.parse('TAXONOMY_EXPORT_COMPLETE', actualCount), this.exportConfig.context);
             this.completeProgress(true);
         }
         catch (error) {
@@ -76,72 +58,226 @@ class ExportTaxonomies extends base_class_1.default {
         }
     }
     /**
-     * Fetch in the provided stack
-     * @param {number} skip
-     * @returns {Promise<any>}
+     * Initialize export setup (create directories, get initial count)
      */
-    async getAllTaxonomies(skip = 0) {
-        var _a, _b;
-        if (skip) {
-            this.qs.skip = skip;
-            cli_utilities_1.log.debug(`Fetching taxonomies with skip: ${skip}`, this.exportConfig.context);
+    async initializeExport() {
+        return this.withLoadingSpinner('TAXONOMIES: Analyzing taxonomy structure...', async () => {
+            this.taxonomiesFolderPath = (0, node_path_1.resolve)(this.exportConfig.exportDir, this.exportConfig.branchName || '', this.taxonomiesConfig.dirName);
+            cli_utilities_1.log.debug(`Taxonomies folder path: '${this.taxonomiesFolderPath}'`, this.exportConfig.context);
+            await utils_1.fsUtil.makeDirectory(this.taxonomiesFolderPath);
+            cli_utilities_1.log.debug('Created taxonomies directory.', this.exportConfig.context);
+            // Get count first for progress tracking
+            const countResponse = await this.stack
+                .taxonomy()
+                .query(Object.assign(Object.assign({}, this.qs), { include_count: true, limit: 1 }))
+                .find();
+            return countResponse.count || 0;
+        });
+    }
+    /**
+     * Setup progress manager with processes
+     */
+    setupProgress(totalCount) {
+        const progress = this.createNestedProgress(this.currentModuleName);
+        // For fetch: count API calls, not individual taxonomies
+        const fetchApiCallsCount = Math.ceil(totalCount / (this.qs.limit || 100));
+        progress.addProcess(utils_1.PROCESS_NAMES.FETCH_TAXONOMIES, fetchApiCallsCount);
+        progress.addProcess(utils_1.PROCESS_NAMES.EXPORT_TAXONOMIES_TERMS, totalCount);
+        return progress;
+    }
+    /**
+     * Determine if locale-based export is supported
+     */
+    async determineExportStrategy(masterLocale) {
+        await this.fetchTaxonomies(masterLocale, true);
+        if (!this.isLocaleBasedExportSupported) {
+            cli_utilities_1.log.debug('Falling back to legacy export (non-localized)', this.exportConfig.context);
+            this.taxonomies = {};
+            this.taxonomiesByLocale = {};
         }
         else {
-            cli_utilities_1.log.debug('Fetching taxonomies with initial query', this.exportConfig.context);
-        }
-        cli_utilities_1.log.debug(`Query parameters: ${JSON.stringify(this.qs)}`, this.exportConfig.context);
-        let taxonomyResult = await this.stack.taxonomy().query(this.qs).find();
-        cli_utilities_1.log.debug(`Fetched ${((_a = taxonomyResult.items) === null || _a === void 0 ? void 0 : _a.length) || 0} taxonomies out of total ${taxonomyResult.count}`, this.exportConfig.context);
-        if ((taxonomyResult === null || taxonomyResult === void 0 ? void 0 : taxonomyResult.items) && ((_b = taxonomyResult === null || taxonomyResult === void 0 ? void 0 : taxonomyResult.items) === null || _b === void 0 ? void 0 : _b.length) > 0) {
-            cli_utilities_1.log.debug(`Processing ${taxonomyResult.items.length} taxonomies`, this.exportConfig.context);
-            this.sanitizeTaxonomiesAttribs(taxonomyResult.items);
-            skip += this.taxonomiesConfig.limit;
-            if (skip >= taxonomyResult.count) {
-                cli_utilities_1.log.debug('Completed fetching all taxonomies', this.exportConfig.context);
-                return;
+            cli_utilities_1.log.debug('Localization enabled, proceeding with locale-based export', this.exportConfig.context);
+        }
+    }
+    /**
+     * Fetch all taxonomies based on export strategy
+     */
+    async fetchAllTaxonomies(localesToExport) {
+        if (!this.isLocaleBasedExportSupported) {
+            await this.fetchTaxonomies();
+        }
+        else {
+            for (const localeCode of localesToExport) {
+                await this.fetchTaxonomies(localeCode);
             }
-            cli_utilities_1.log.debug(`Continuing to fetch taxonomies with skip: ${skip}`, this.exportConfig.context);
-            return await this.getAllTaxonomies(skip);
+        }
+    }
+    /**
+     * Export all taxonomies with detailed information
+     */
+    async exportAllTaxonomies(progress, localesToExport, totalCount) {
+        var _a;
+        const actualCount = (_a = Object.keys(this.taxonomies || {})) === null || _a === void 0 ? void 0 : _a.length;
+        cli_utilities_1.log.debug(`Found ${actualCount} taxonomies to export (API reported ${totalCount})`, this.exportConfig.context);
+        if (actualCount === 0) {
+            cli_utilities_1.log.info('No taxonomies found to export detailed information', this.exportConfig.context);
+            return 0;
+        }
+        // Update progress total if needed
+        if (actualCount !== totalCount) {
+            progress.updateProcessTotal(utils_1.PROCESS_NAMES.EXPORT_TAXONOMIES_TERMS, actualCount);
+        }
+        // Start export process
+        progress
+            .startProcess(utils_1.PROCESS_NAMES.EXPORT_TAXONOMIES_TERMS)
+            .updateStatus(utils_1.PROCESS_STATUS[utils_1.PROCESS_NAMES.EXPORT_TAXONOMIES_TERMS].EXPORTING, utils_1.PROCESS_NAMES.EXPORT_TAXONOMIES_TERMS);
+        // Export based on strategy
+        if (!this.isLocaleBasedExportSupported) {
+            await this.exportTaxonomies();
         }
         else {
+            for (const localeCode of localesToExport) {
+                await this.processLocaleExport(localeCode);
+            }
+        }
+        progress.completeProcess(utils_1.PROCESS_NAMES.EXPORT_TAXONOMIES_TERMS, true);
+        return actualCount;
+    }
+    /**
+     * Process and export taxonomies for a specific locale
+     */
+    async processLocaleExport(localeCode) {
+        const localeTaxonomies = this.taxonomiesByLocale[localeCode];
+        if ((localeTaxonomies === null || localeTaxonomies === void 0 ? void 0 : localeTaxonomies.size) > 0) {
+            cli_utilities_1.log.info(`Found ${localeTaxonomies.size} taxonomies for locale: ${localeCode}`, this.exportConfig.context);
+            await this.exportTaxonomies(localeCode);
+        }
+        else {
+            cli_utilities_1.log.debug(`No taxonomies found for locale: ${localeCode}`, this.exportConfig.context);
+        }
+    }
+    /**
+     * Write taxonomies metadata file
+     */
+    async writeTaxonomiesMetadata() {
+        if (!this.taxonomies || (0, isEmpty_1.default)(this.taxonomies)) {
             cli_utilities_1.log.info(cli_utilities_1.messageHandler.parse('TAXONOMY_NOT_FOUND'), this.exportConfig.context);
+            return;
         }
+        const taxonomiesFilePath = (0, node_path_1.resolve)(this.taxonomiesFolderPath, this.taxonomiesConfig.fileName);
+        cli_utilities_1.log.debug(`Writing taxonomies metadata to: ${taxonomiesFilePath}`, this.exportConfig.context);
+        utils_1.fsUtil.writeFile(taxonomiesFilePath, this.taxonomies);
     }
-    sanitizeTaxonomiesAttribs(taxonomies) {
-        var _a;
-        cli_utilities_1.log.debug(`Sanitizing ${taxonomies.length} taxonomies`, this.exportConfig.context);
-        for (let index = 0; index < (taxonomies === null || taxonomies === void 0 ? void 0 : taxonomies.length); index++) {
-            const taxonomy = taxonomies[index];
-            const taxonomyUid = taxonomy.uid;
-            const taxonomyName = taxonomy === null || taxonomy === void 0 ? void 0 : taxonomy.name;
-            cli_utilities_1.log.debug(`Processing taxonomy: ${taxonomyName} (${taxonomyUid})`, this.exportConfig.context);
-            if (this.taxonomiesConfig.invalidKeys && this.taxonomiesConfig.invalidKeys.length > 0) {
-                this.taxonomies[taxonomyUid] = (0, omit_1.default)(taxonomy, this.taxonomiesConfig.invalidKeys);
+    /**
+     * Fetch taxonomies
+     *
+     * @async
+     * @param {?string} [localeCode]
+     * @param {boolean} [checkLocaleSupport=false]
+     * @returns {Promise<void>}
+     */
+    async fetchTaxonomies(localeCode, checkLocaleSupport = false) {
+        var _a, _b;
+        let skip = 0;
+        const localeInfo = localeCode ? `for locale: ${localeCode}` : '';
+        if (localeCode && !this.taxonomiesByLocale[localeCode]) {
+            this.taxonomiesByLocale[localeCode] = new Set();
+        }
+        do {
+            const queryParams = Object.assign(Object.assign({}, this.qs), { skip });
+            if (localeCode) {
+                queryParams.locale = localeCode;
             }
-            else {
-                this.taxonomies[taxonomyUid] = taxonomy;
+            cli_utilities_1.log.debug(`Fetching taxonomies ${localeInfo} with skip: ${skip}`, this.exportConfig.context);
+            try {
+                const data = await this.stack.taxonomy().query(queryParams).find();
+                const { items, count } = data;
+                const taxonomiesCount = (_a = count !== null && count !== void 0 ? count : items === null || items === void 0 ? void 0 : items.length) !== null && _a !== void 0 ? _a : 0;
+                cli_utilities_1.log.debug(`Fetched ${(items === null || items === void 0 ? void 0 : items.length) || 0} taxonomies out of total ${taxonomiesCount} ${localeInfo}`, this.exportConfig.context);
+                if (!(items === null || items === void 0 ? void 0 : items.length)) {
+                    cli_utilities_1.log.debug(`No taxonomies found ${localeInfo}`, this.exportConfig.context);
+                    break;
+                }
+                // Check localization support
+                if (checkLocaleSupport && localeCode && skip === 0 && !items[0].locale) {
+                    cli_utilities_1.log.debug('API does not support locale-based taxonomy export', this.exportConfig.context);
+                    this.isLocaleBasedExportSupported = false;
+                }
+                this.sanitizeTaxonomiesAttribs(items, localeCode);
+                // Track progress per API call (only for actual fetch, not locale support check)
+                if (!checkLocaleSupport) {
+                    (_b = this.progressManager) === null || _b === void 0 ? void 0 : _b.tick(true, `fetched ${items.length} taxonomies${localeInfo}`, null, utils_1.PROCESS_NAMES.FETCH_TAXONOMIES);
+                }
+                skip += this.qs.limit || 100;
+                if (skip >= taxonomiesCount) {
+                    cli_utilities_1.log.debug(`Completed fetching all taxonomies ${localeInfo}`, this.exportConfig.context);
+                    break;
+                }
+            }
+            catch (error) {
+                cli_utilities_1.log.debug(`Error fetching taxonomies ${localeInfo}`, this.exportConfig.context);
+                if (checkLocaleSupport && this.isLocalePlanLimitationError(error)) {
+                    cli_utilities_1.log.debug('Taxonomy localization is not included in your plan. Falling back to non-localized export.', this.exportConfig.context);
+                    this.isLocaleBasedExportSupported = false;
+                }
+                else if (checkLocaleSupport) {
+                    cli_utilities_1.log.debug('Locale-based taxonomy export not supported, will use legacy method', this.exportConfig.context);
+                    this.isLocaleBasedExportSupported = false;
+                }
+                else {
+                    // Log actual errors during normal fetch (not locale check)
+                    (0, cli_utilities_1.handleAndLogError)(error, Object.assign(Object.assign({}, this.exportConfig.context), (localeCode && { locale: localeCode })));
+                }
+                // Break to avoid infinite retry loop on errors
+                break;
+            }
+        } while (true);
+    }
+    /**
+     * remove invalid keys and write data into taxonomies
+     * @function sanitizeTaxonomiesAttribs
+     * @param {Record<string, string>[]} taxonomies
+     * @param {?string} [localeCode]
+     */
+    sanitizeTaxonomiesAttribs(taxonomies, localeCode) {
+        const localeInfo = localeCode ? ` for locale: ${localeCode}` : '';
+        cli_utilities_1.log.debug(`Processing ${taxonomies.length} taxonomies${localeInfo}`, this.exportConfig.context);
+        for (const taxonomy of taxonomies) {
+            const taxonomyUID = taxonomy.uid;
+            const taxonomyName = taxonomy.name;
+            cli_utilities_1.log.debug(`Processing taxonomy: ${taxonomyName} (${taxonomyUID})${localeInfo}`, this.exportConfig.context);
+            // Store taxonomy metadata (only once per taxonomy)
+            if (!this.taxonomies[taxonomyUID]) {
+                this.taxonomies[taxonomyUID] = (0, omit_1.default)(taxonomy, this.taxonomiesConfig.invalidKeys);
+            }
+            // Track taxonomy for this locale
+            if (localeCode) {
+                this.taxonomiesByLocale[localeCode].add(taxonomyUID);
             }
-            // Track progress for each taxonomy
-            (_a = this.progressManager) === null || _a === void 0 ? void 0 : _a.tick(true, `taxonomy: ${taxonomyName || taxonomyUid}`, null, utils_1.PROCESS_NAMES.FETCH_TAXONOMIES);
         }
-        cli_utilities_1.log.debug(`Sanitization complete. Total taxonomies processed: ${Object.keys(this.taxonomies || {}).length}`, this.exportConfig.context);
+        cli_utilities_1.log.debug(`Processing complete${localeInfo}. Total taxonomies processed: ${(0, keys_1.default)(this.taxonomies).length}`, this.exportConfig.context);
     }
     /**
-     * Export all taxonomies details using metadata(this.taxonomies) and write it into respective <taxonomy-uid>.json file
-     * @returns {Promise<any>}
+     * Export taxonomies - supports both locale-based and legacy export
      */
-    async exportTaxonomies() {
-        var _a;
-        cli_utilities_1.log.debug(`Exporting ${(_a = Object.keys(this.taxonomies || {})) === null || _a === void 0 ? void 0 : _a.length} taxonomies with detailed information`, this.exportConfig.context);
-        if ((0, isEmpty_1.default)(this.taxonomies)) {
-            cli_utilities_1.log.info(cli_utilities_1.messageHandler.parse('TAXONOMY_NOT_FOUND'), this.exportConfig.context);
+    async exportTaxonomies(localeCode) {
+        const taxonomiesUID = localeCode ? Array.from(this.taxonomiesByLocale[localeCode] || []) : (0, keys_1.default)(this.taxonomies);
+        const localeInfo = localeCode ? ` for locale: ${localeCode}` : '';
+        if (taxonomiesUID.length === 0) {
+            cli_utilities_1.log.debug(`No taxonomies to export${localeInfo}`, this.exportConfig.context);
             return;
         }
+        cli_utilities_1.log.debug(`Exporting detailed data for ${taxonomiesUID.length} taxonomies${localeInfo}`, this.exportConfig.context);
+        const exportFolderPath = localeCode ? (0, node_path_1.resolve)(this.taxonomiesFolderPath, localeCode) : this.taxonomiesFolderPath;
+        if (localeCode) {
+            await utils_1.fsUtil.makeDirectory(exportFolderPath);
+            cli_utilities_1.log.debug(`Created locale folder: ${exportFolderPath}`, this.exportConfig.context);
+        }
         const onSuccess = ({ response, uid }) => {
             var _a, _b;
             const taxonomyName = (_a = this.taxonomies[uid]) === null || _a === void 0 ? void 0 : _a.name;
-            const filePath = (0, node_path_1.resolve)(this.taxonomiesFolderPath, `${uid}.json`);
-            cli_utilities_1.log.debug(`Writing detailed taxonomy to: ${filePath}`, this.exportConfig.context);
+            const filePath = (0, node_path_1.resolve)(exportFolderPath, `${uid}.json`);
+            cli_utilities_1.log.debug(`Writing detailed taxonomy data to: ${filePath}`, this.exportConfig.context);
             utils_1.fsUtil.writeFile(filePath, response);
             // Track progress for each exported taxonomy
             (_b = this.progressManager) === null || _b === void 0 ? void 0 : _b.tick(true, `taxonomy: ${taxonomyName || uid}`, null, utils_1.PROCESS_NAMES.EXPORT_TAXONOMIES_TERMS);
@@ -150,31 +286,69 @@ class ExportTaxonomies extends base_class_1.default {
         const onReject = ({ error, uid }) => {
             var _a, _b;
             const taxonomyName = (_a = this.taxonomies[uid]) === null || _a === void 0 ? void 0 : _a.name;
+            cli_utilities_1.log.debug(`Failed to export detailed data for taxonomy: ${uid}${localeInfo}`, this.exportConfig.context);
             // Track failure
             (_b = this.progressManager) === null || _b === void 0 ? void 0 : _b.tick(false, `taxonomy: ${taxonomyName || uid}`, (error === null || error === void 0 ? void 0 : error.message) || utils_1.PROCESS_STATUS[utils_1.PROCESS_NAMES.EXPORT_TAXONOMIES_TERMS].FAILED, utils_1.PROCESS_NAMES.EXPORT_TAXONOMIES_TERMS);
-            (0, cli_utilities_1.handleAndLogError)(error, Object.assign(Object.assign({}, this.exportConfig.context), { uid }), cli_utilities_1.messageHandler.parse('TAXONOMY_EXPORT_FAILED', taxonomyName || uid));
+            (0, cli_utilities_1.handleAndLogError)(error, Object.assign(Object.assign(Object.assign({}, this.exportConfig.context), { uid }), (localeCode && { locale: localeCode })));
         };
-        const taxonomyUids = (0, keys_1.default)(this.taxonomies);
-        cli_utilities_1.log.debug(`Starting detailed export for ${taxonomyUids.length} taxonomies`, this.exportConfig.context);
-        // Export each taxonomy individually
-        for (const uid of taxonomyUids) {
-            try {
-                cli_utilities_1.log.debug(`Exporting detailed taxonomy: ${uid}`, this.exportConfig.context);
-                await this.makeAPICall({
-                    module: 'export-taxonomy',
-                    uid,
-                    resolve: onSuccess,
-                    reject: onReject,
-                });
+        for (const taxonomyUID of taxonomiesUID) {
+            cli_utilities_1.log.debug(`Processing detailed export for taxonomy: ${taxonomyUID}${localeInfo}`, this.exportConfig.context);
+            const exportParams = { format: 'json' };
+            if (localeCode) {
+                exportParams.locale = localeCode;
+                if (this.qs.include_fallback !== undefined)
+                    exportParams.include_fallback = this.qs.include_fallback;
+                if (this.qs.fallback_locale)
+                    exportParams.fallback_locale = this.qs.fallback_locale;
             }
-            catch (error) {
-                onReject({ error, uid });
+            if (this.qs.branch)
+                exportParams.branch = this.qs.branch;
+            await this.makeAPICall({
+                reject: onReject,
+                resolve: onSuccess,
+                uid: taxonomyUID,
+                module: 'export-taxonomy',
+                queryParam: exportParams,
+            });
+        }
+        cli_utilities_1.log.debug(`Completed detailed taxonomy export process${localeInfo}`, this.exportConfig.context);
+    }
+    /**
+     * Get all locales to export
+     */
+    getLocalesToExport() {
+        var _a;
+        cli_utilities_1.log.debug('Determining locales to export...', this.exportConfig.context);
+        const masterLocaleCode = ((_a = this.exportConfig.master_locale) === null || _a === void 0 ? void 0 : _a.code) || 'en-us';
+        const localeSet = new Set([masterLocaleCode]);
+        try {
+            const locales = utils_1.fsUtil.readFile(this.localesFilePath);
+            if (locales && (0, keys_1.default)(locales || {}).length > 0) {
+                cli_utilities_1.log.debug(`Loaded ${(0, keys_1.default)(locales || {}).length} locales from ${this.localesFilePath}`, this.exportConfig.context);
+                for (const localeUid of (0, keys_1.default)(locales)) {
+                    const localeCode = locales[localeUid].code;
+                    if (localeCode && !localeSet.has(localeCode)) {
+                        localeSet.add(localeCode);
+                        cli_utilities_1.log.debug(`Added locale: ${localeCode} (uid: ${localeUid})`, this.exportConfig.context);
+                    }
+                }
+            }
+            else {
+                cli_utilities_1.log.debug(`No locales found in ${this.localesFilePath}`, this.exportConfig.context);
             }
         }
-        // Write the taxonomies index file
-        const taxonomiesFilePath = (0, node_path_1.resolve)(this.taxonomiesFolderPath, this.taxonomiesConfig.fileName);
-        cli_utilities_1.log.debug(`Writing taxonomies index to: ${taxonomiesFilePath}`, this.exportConfig.context);
-        utils_1.fsUtil.writeFile(taxonomiesFilePath, this.taxonomies);
+        catch (error) {
+            cli_utilities_1.log.warn(`Failed to read locales file: ${this.localesFilePath}`, this.exportConfig.context);
+        }
+        const localesToExport = Array.from(localeSet);
+        cli_utilities_1.log.debug(`Total unique locales to export: ${localesToExport.length}`, this.exportConfig.context);
+        return localesToExport;
+    }
+    isLocalePlanLimitationError(error) {
+        var _a, _b;
+        return ((error === null || error === void 0 ? void 0 : error.status) === 403 &&
+            ((_b = (_a = error === null || error === void 0 ? void 0 : error.errors) === null || _a === void 0 ? void 0 : _a.taxonomies) === null || _b === void 0 ? void 0 : _b.some((msg) => msg.toLowerCase().includes('taxonomy localization') &&
+                msg.toLowerCase().includes('not included in your plan'))));
     }
 }
 exports.default = ExportTaxonomies;

package/lib/export/modules/webhooks.js

@@ -21,7 +21,7 @@ class ExportWebhooks extends base_class_1.default {
             cli_utilities_1.log.debug('Starting webhooks export process...', this.exportConfig.context);
             // Setup with loading spinner
             const [totalCount] = await this.withLoadingSpinner('WEBHOOKS: Analyzing webhooks...', async () => {
-                this.webhooksFolderPath = (0, node_path_1.resolve)(this.exportConfig.data, this.exportConfig.branchName || '', this.webhookConfig.dirName);
+                this.webhooksFolderPath = (0, node_path_1.resolve)(this.exportConfig.exportDir, this.exportConfig.branchName || '', this.webhookConfig.dirName);
                 await utils_1.fsUtil.makeDirectory(this.webhooksFolderPath);
                 // Get count for progress tracking
                 const countResponse = await this.stack.webhook().fetchAll(Object.assign(Object.assign({}, this.qs), { limit: 1 }));
@@ -43,9 +43,8 @@ class ExportWebhooks extends base_class_1.default {
                 const webhooksFilePath = (0, node_path_1.resolve)(this.webhooksFolderPath, this.webhookConfig.fileName);
                 cli_utilities_1.log.debug(`Writing webhooks to: ${webhooksFilePath}`, this.exportConfig.context);
                 utils_1.fsUtil.writeFile(webhooksFilePath, this.webhooks);
-                cli_utilities_1.log.success(cli_utilities_1.messageHandler.parse('WEBHOOK_EXPORT_COMPLETE', Object.keys(this.webhooks || {}).length), this.exportConfig.context);
             }
-            this.completeProgress(true);
+            this.completeProgressWithMessage();
         }
         catch (error) {
             (0, cli_utilities_1.handleAndLogError)(error, Object.assign({}, this.exportConfig.context));

package/lib/export/modules/workflows.js

@@ -22,7 +22,7 @@ class ExportWorkFlows extends base_class_1.default {
             // Setup with loading spinner
             const [totalCount] = await this.withLoadingSpinner('WORKFLOWS: Analyzing workflows...', async () => {
                 var _a;
-                this.webhooksFolderPath = (0, node_path_1.resolve)(this.exportConfig.data, this.exportConfig.branchName || '', this.workflowConfig.dirName);
+                this.webhooksFolderPath = (0, node_path_1.resolve)(this.exportConfig.exportDir, this.exportConfig.branchName || '', this.workflowConfig.dirName);
                 await utils_1.fsUtil.makeDirectory(this.webhooksFolderPath);
                 // Get count for progress tracking
                 const countResponse = await this.stack.workflow().fetchAll(Object.assign(Object.assign({}, this.qs), { limit: 1 }));
@@ -46,9 +46,8 @@ class ExportWorkFlows extends base_class_1.default {
                 const workflowsFilePath = (0, node_path_1.resolve)(this.webhooksFolderPath, this.workflowConfig.fileName);
                 cli_utilities_1.log.debug(`Writing workflows to: ${workflowsFilePath}`, this.exportConfig.context);
                 utils_1.fsUtil.writeFile(workflowsFilePath, this.workflows);
-                cli_utilities_1.log.success(cli_utilities_1.messageHandler.parse('WORKFLOW_EXPORT_COMPLETE', Object.keys(this.workflows || {}).length), this.exportConfig.context);
             }
-            this.completeProgress(true);
+            this.completeProgressWithMessage();
         }
         catch (error) {
             (0, cli_utilities_1.handleAndLogError)(error, Object.assign({}, this.exportConfig.context));
@@ -140,7 +139,7 @@ class ExportWorkFlows extends base_class_1.default {
             .catch((err) => {
             cli_utilities_1.log.debug(`Failed to fetch role data for UID: ${roleUid}`, this.exportConfig.context);
             (0, cli_utilities_1.handleAndLogError)(err, Object.assign({}, this.exportConfig.context));
-            throw err;
+            return undefined; // Return undefined instead of throwing to handle gracefully
         });
     }
 }

package/lib/types/default-config.d.ts

@@ -147,6 +147,12 @@ export default interface DefaultConfig {
             fileName: string;
             dependencies?: Modules[];
         };
+        'composable-studio': {
+            dirName: string;
+            fileName: string;
+            apiBaseUrl: string;
+            apiVersion: string;
+        };
         masterLocale: {
             dirName: string;
             fileName: string;

package/lib/types/index.d.ts

@@ -26,7 +26,7 @@ export interface Region {
     cda: string;
     uiHost: string;
 }
-export type Modules = 'stack' | 'assets' | 'locales' | 'environments' | 'extensions' | 'webhooks' | 'global-fields' | 'entries' | 'content-types' | 'custom-roles' | 'workflows' | 'labels' | 'marketplace-apps' | 'taxonomies' | 'personalize';
+export type Modules = 'stack' | 'assets' | 'locales' | 'environments' | 'extensions' | 'webhooks' | 'global-fields' | 'entries' | 'content-types' | 'custom-roles' | 'workflows' | 'labels' | 'marketplace-apps' | 'taxonomies' | 'personalize' | 'composable-studio';
 export type ModuleClassParams = {
     stackAPIClient: ReturnType<ContentstackClient['stack']>;
     exportConfig: ExportConfig;
@@ -96,11 +96,36 @@ export interface StackConfig {
     dependencies?: Modules[];
     limit?: number;
 }
+export interface ComposableStudioConfig {
+    dirName: string;
+    fileName: string;
+    apiBaseUrl: string;
+    apiVersion: string;
+}
+export interface ComposableStudioProject {
+    name: string;
+    description: string;
+    canvasUrl: string;
+    connectedStackApiKey: string;
+    contentTypeUid: string;
+    organizationUid: string;
+    settings: {
+        configuration: {
+            environment: string;
+            locale: string;
+        };
+    };
+    createdBy: string;
+    updatedBy: string;
+    deletedAt: boolean;
+    createdAt: string;
+    updatedAt: string;
+    uid: string;
+}
 export interface Context {
     command: string;
     module: string;
     userId: string | undefined;
-    email?: string | undefined;
     sessionId: string | undefined;
     clientId?: string | undefined;
     apiKey: string;

package/lib/utils/basic-login.d.ts

@@ -1,6 +1,6 @@
 /*!
  * Contentstack Import
- * Copyright (c) 2024 Contentstack LLC
+ * Copyright (c) 2026 Contentstack LLC
  * MIT Licensed
  */
 import { ExternalConfig } from '../types';

package/lib/utils/basic-login.js

@@ -4,7 +4,7 @@
 /* eslint-disable no-empty */
 /*!
  * Contentstack Import
- * Copyright (c) 2024 Contentstack LLC
+ * Copyright (c) 2026 Contentstack LLC
  * MIT Licensed
  */
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -16,7 +16,7 @@ const login = async (config) => {
         const response = await client.login({ email: config.email, password: config.password }).catch(Promise.reject);
         if ((_a = response === null || response === void 0 ? void 0 : response.user) === null || _a === void 0 ? void 0 : _a.authtoken) {
             config.headers = {
-                api_key: config.source_stack,
+                api_key: config.apiKey,
                 access_token: config.access_token,
                 authtoken: response.user.authtoken,
                 'X-User-Agent': 'contentstack-export/v',
@@ -26,15 +26,15 @@ const login = async (config) => {
             return config;
         }
         else {
-            cli_utilities_1.log.error(`Failed to login, Invalid credentials`, config.context);
+            cli_utilities_1.log.error(`Failed to log in!`, config.context);
             process.exit(1);
         }
     }
-    else if (!config.email && !config.password && config.source_stack && config.access_token) {
+    else if (!config.email && !config.password && config.apiKey && config.access_token) {
         cli_utilities_1.log.info(`Content types, entries, assets, labels, global fields, extensions modules will be exported`, config.context);
         cli_utilities_1.log.info(`Email, password, or management token is not set in the config, cannot export Webhook and label modules`, config.context);
         config.headers = {
-            api_key: config.source_stack,
+            api_key: config.apiKey,
             access_token: config.access_token,
             'X-User-Agent': 'contentstack-export/v',
         };

package/lib/utils/common-helper.d.ts

@@ -1,6 +1,6 @@
 /*!
  * Contentstack Export
- * Copyright (c) 2024 Contentstack LLC
+ * Copyright (c) 2026 Contentstack LLC
  * MIT Licensed
  */
 import { ExternalConfig } from '../types';