@contentstack/cli-cm-import-setup 1.6.0 → 1.7.0

package/README.md

@@ -47,7 +47,7 @@ $ npm install -g @contentstack/cli-cm-import-setup
 $ csdx COMMAND
 running command...
 $ csdx (--version)
-@contentstack/cli-cm-import-setup/1.6.0 linux-x64 node-v22.20.0
+@contentstack/cli-cm-import-setup/1.7.0 linux-x64 node-v22.21.1
 $ csdx --help [COMMAND]
 USAGE
   $ csdx COMMAND

package/lib/config/index.js

@@ -22,6 +22,11 @@ const config = {
             fileName: 'custom-roles.json',
             dependencies: ['environments', 'entries'],
         },
+        locales: {
+            dirName: 'locales',
+            fileName: 'locales.json',
+            dependencies: [],
+        },
         environments: {
             dirName: 'environments',
             fileName: 'environments.json',
@@ -43,7 +48,7 @@ const config = {
         entries: {
             dirName: 'entries',
             fileName: 'entries.json',
-            dependencies: ['assets', 'marketplace-apps', 'taxonomies'],
+            dependencies: ['assets', 'extensions', 'marketplace-apps', 'taxonomies'],
         },
         'global-fields': {
             dirName: 'global_fields',

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

@@ -3,6 +3,7 @@ import { ModuleClassParams } from '../../types';
 export default class TaxonomiesImportSetup {
     private config;
     private taxonomiesFilePath;
+    private taxonomiesFolderPath;
     private stackAPIClient;
     private dependencies;
     private taxonomiesConfig;
@@ -10,8 +11,11 @@ export default class TaxonomiesImportSetup {
     private taxSuccessPath;
     private taxonomiesMapperDirPath;
     private termsMapperDirPath;
+    private localesFilePath;
+    private isLocaleBasedStructure;
     taxonomiesMapper: Record<string, unknown>;
     termsMapper: Record<string, unknown>;
+    masterLocaleFilePath: string;
     constructor({ config, stackAPIClient }: ModuleClassParams);
     /**
      * Start the taxonomies import setup
@@ -19,13 +23,39 @@ export default class TaxonomiesImportSetup {
      * @returns {Promise<void>}
      */
     start(): Promise<void>;
+    /**
+     * Setup taxonomies using legacy format (root-level taxonomy files)
+     */
+    setupTaxonomiesLegacy(taxonomies: any): Promise<void>;
+    /**
+     * Setup taxonomies using locale-based format (taxonomies organized by locale)
+     * For locale-based structure, we query the target stack for each taxonomy+locale combination
+     */
+    setupTaxonomiesByLocale(taxonomies: any): Promise<void>;
+    /**
+     * Detect if locale-based folder structure exists
+     * @returns {boolean} true if locale-based structure detected, false otherwise
+     */
+    detectLocaleBasedStructure(): boolean;
+    /**
+     * Get the master locale code
+     * First tries to read from master-locale.json, then falls back to config, then 'en-us'
+     * @returns {string} The master locale code
+     */
+    getMasterLocaleCode(): string;
+    /**
+     * Load available locales from locales file
+     * @returns {Record<string, string>} Map of locale codes
+     */
+    loadAvailableLocales(): Record<string, string>;
     /**
      * Retrieves the taxonomies based on the provided taxonomy UID.
      *
      * @param taxonomy - The UID of the taxonomy to retrieve.
+     * @param locale - Optional locale code to query taxonomy in specific locale
      * @returns A promise that resolves to the retrieved taxonomies.
      */
-    getTaxonomies(taxonomy: any): Promise<any>;
+    getTaxonomies(taxonomy: any, locale?: string): Promise<any>;
     /**
      * Sanitizes the attributes of a taxonomy object.
      *
@@ -37,11 +67,12 @@ export default class TaxonomiesImportSetup {
      * Retrieves all terms of a taxonomy.
      *
      * @param taxonomy - The taxonomy object.
+     * @param locale - Optional locale code to query terms in specific locale
      * @param skip - The number of terms to skip (default: 0).
      * @param terms - An array to store the retrieved terms (default: []).
      * @returns A promise that resolves to an array of terms.
      */
-    getAllTermsOfTaxonomy(taxonomy: any, skip?: number, terms?: any[]): Promise<any>;
+    getAllTermsOfTaxonomy(taxonomy: any, locale?: string, skip?: number, terms?: any[]): Promise<any>;
     /**
      * Sanitizes the attributes of the given terms.
      *
@@ -49,5 +80,5 @@ export default class TaxonomiesImportSetup {
      * @returns The sanitized terms.
      */
     sanitizeTermsAttribs(terms: Record<string, unknown>[]): Record<string, unknown>[];
-    handleTaxonomyErrorMsg(err: any): void;
+    handleTaxonomyErrorMsg(err: any, taxonomyUid?: string, locale?: string): void;
 }

package/lib/import/modules/taxonomies.js

@@ -8,16 +8,21 @@ const utils_1 = require("../../utils");
 const cli_utilities_1 = require("@contentstack/cli-utilities");
 class TaxonomiesImportSetup {
     constructor({ config, stackAPIClient }) {
+        var _a, _b, _c;
+        this.isLocaleBasedStructure = false;
         this.taxonomiesMapper = {};
         this.termsMapper = {};
         this.config = config;
         this.stackAPIClient = stackAPIClient;
-        this.taxonomiesFilePath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.contentDir), 'taxonomies', 'taxonomies.json');
+        this.taxonomiesFolderPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.contentDir), 'taxonomies');
+        this.taxonomiesFilePath = (0, path_1.join)(this.taxonomiesFolderPath, 'taxonomies.json');
         this.taxonomiesConfig = config.modules.taxonomies;
         this.taxonomiesMapperDirPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'taxonomies');
         this.taxSuccessPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.taxonomiesMapperDirPath), 'success.json');
         this.termsMapperDirPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.taxonomiesMapperDirPath), 'terms');
         this.termsSuccessPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.termsMapperDirPath), 'success.json');
+        this.localesFilePath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.contentDir), ((_a = config.modules.locales) === null || _a === void 0 ? void 0 : _a.dirName) || 'locales', ((_b = config.modules.locales) === null || _b === void 0 ? void 0 : _b.fileName) || 'locales.json');
+        this.masterLocaleFilePath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.contentDir), ((_c = config.modules.locales) === null || _c === void 0 ? void 0 : _c.dirName) || 'locales', 'master-locale.json');
         this.taxonomiesMapper = {};
         this.termsMapper = {};
     }
@@ -30,20 +35,18 @@ class TaxonomiesImportSetup {
         try {
             const taxonomies = utils_1.fsUtil.readFile(this.taxonomiesFilePath);
             if (!(0, isEmpty_1.default)(taxonomies)) {
+                // 1. Detect locale-based structure
+                this.isLocaleBasedStructure = this.detectLocaleBasedStructure();
                 // 2. Create mapper directory
                 utils_1.fsUtil.makeDirectory(this.taxonomiesMapperDirPath);
                 utils_1.fsUtil.makeDirectory(this.termsMapperDirPath);
-                for (const taxonomy of Object.values(taxonomies)) {
-                    let targetTaxonomy = await this.getTaxonomies(taxonomy);
-                    if (!targetTaxonomy) {
-                        (0, utils_1.log)(this.config, `Taxonomies with uid '${taxonomy.uid}' not found in the stack!`, 'info');
-                        continue;
-                    }
-                    targetTaxonomy = this.sanitizeTaxonomyAttribs(targetTaxonomy);
-                    this.taxonomiesMapper[taxonomy.uid] = targetTaxonomy;
-                    const terms = await this.getAllTermsOfTaxonomy(targetTaxonomy);
-                    const sanitizedTerms = this.sanitizeTermsAttribs(terms);
-                    this.termsMapper[taxonomy.uid] = sanitizedTerms;
+                if (this.isLocaleBasedStructure) {
+                    (0, utils_1.log)(this.config, 'Detected locale-based folder structure for taxonomies', 'info');
+                    await this.setupTaxonomiesByLocale(taxonomies);
+                }
+                else {
+                    (0, utils_1.log)(this.config, 'Using legacy folder structure for taxonomies', 'info');
+                    await this.setupTaxonomiesLegacy(taxonomies);
                 }
                 if (this.taxonomiesMapper !== undefined && !(0, isEmpty_1.default)(this.taxonomiesMapper)) {
                     utils_1.fsUtil.writeFile(this.taxSuccessPath, this.taxonomiesMapper);
@@ -61,18 +64,148 @@ class TaxonomiesImportSetup {
             (0, utils_1.log)(this.config, `Error generating taxonomies mapper: ${error.message}`, 'error');
         }
     }
+    /**
+     * Setup taxonomies using legacy format (root-level taxonomy files)
+     */
+    async setupTaxonomiesLegacy(taxonomies) {
+        for (const taxonomy of Object.values(taxonomies)) {
+            let targetTaxonomy = await this.getTaxonomies(taxonomy);
+            if (!targetTaxonomy) {
+                (0, utils_1.log)(this.config, `Taxonomies with uid '${taxonomy.uid}' not found in the stack!`, 'info');
+                continue;
+            }
+            targetTaxonomy = this.sanitizeTaxonomyAttribs(targetTaxonomy);
+            this.taxonomiesMapper[taxonomy.uid] = targetTaxonomy;
+            const terms = await this.getAllTermsOfTaxonomy(targetTaxonomy);
+            if (Array.isArray(terms) && terms.length > 0) {
+                (0, utils_1.log)(this.config, `Terms found for taxonomy '${taxonomy.uid}', processing...`, 'info');
+                const sanitizedTerms = this.sanitizeTermsAttribs(terms);
+                this.termsMapper[taxonomy.uid] = sanitizedTerms;
+            }
+            else {
+                (0, utils_1.log)(this.config, `No terms found for taxonomy '${taxonomy.uid}', skipping...`, 'info');
+            }
+        }
+    }
+    /**
+     * Setup taxonomies using locale-based format (taxonomies organized by locale)
+     * For locale-based structure, we query the target stack for each taxonomy+locale combination
+     */
+    async setupTaxonomiesByLocale(taxonomies) {
+        const locales = this.loadAvailableLocales();
+        for (const localeCode of Object.keys(locales)) {
+            (0, utils_1.log)(this.config, `Processing taxonomies for locale: ${localeCode}`, 'info');
+            for (const taxonomy of Object.values(taxonomies)) {
+                // Query target stack for this taxonomy in this locale
+                let targetTaxonomy = await this.getTaxonomies(taxonomy, localeCode);
+                if (!targetTaxonomy) {
+                    (0, utils_1.log)(this.config, `Taxonomy '${taxonomy.uid}' not found in target stack for locale: ${localeCode}`, 'info');
+                    continue;
+                }
+                targetTaxonomy = this.sanitizeTaxonomyAttribs(targetTaxonomy);
+                // Store with composite key: taxonomyUID_locale
+                // const mapperKey = `${taxonomy.uid}_${localeCode}`; // TODO: Unsure about this required or not
+                this.taxonomiesMapper[taxonomy.uid] = targetTaxonomy;
+                const terms = await this.getAllTermsOfTaxonomy(targetTaxonomy, localeCode);
+                if (Array.isArray(terms) && terms.length > 0) {
+                    (0, utils_1.log)(this.config, `Terms found for taxonomy '${taxonomy.uid} for locale: ${localeCode}', processing...`, 'info');
+                    const sanitizedTerms = this.sanitizeTermsAttribs(terms);
+                    this.termsMapper[taxonomy.uid] = sanitizedTerms;
+                }
+                else {
+                    (0, utils_1.log)(this.config, `No terms found for taxonomy '${taxonomy.uid} for locale: ${localeCode}', skipping...`, 'info');
+                }
+            }
+        }
+    }
+    /**
+     * Detect if locale-based folder structure exists
+     * @returns {boolean} true if locale-based structure detected, false otherwise
+     */
+    detectLocaleBasedStructure() {
+        const masterLocaleCode = this.getMasterLocaleCode();
+        const masterLocaleFolder = (0, path_1.join)(this.taxonomiesFolderPath, masterLocaleCode);
+        // Check if master locale folder exists (indicates new locale-based structure)
+        if (!utils_1.fileHelper.fileExistsSync(masterLocaleFolder)) {
+            (0, utils_1.log)(this.config, 'No locale-based folder structure detected', 'info');
+            return false;
+        }
+        (0, utils_1.log)(this.config, 'Locale-based folder structure detected', 'info');
+        return true;
+    }
+    /**
+     * Get the master locale code
+     * First tries to read from master-locale.json, then falls back to config, then 'en-us'
+     * @returns {string} The master locale code
+     */
+    getMasterLocaleCode() {
+        var _a;
+        // Try to read from master-locale.json file
+        if (utils_1.fileHelper.fileExistsSync(this.masterLocaleFilePath)) {
+            try {
+                const masterLocaleData = utils_1.fsUtil.readFile(this.masterLocaleFilePath, true);
+                // The file contains an object with UID as key, extract the code
+                const firstLocale = Object.values(masterLocaleData)[0];
+                if (firstLocale === null || firstLocale === void 0 ? void 0 : firstLocale.code) {
+                    (0, utils_1.log)(this.config, `Master locale loaded from file: ${firstLocale.code}`, 'info');
+                    return firstLocale.code;
+                }
+            }
+            catch (error) {
+                (0, utils_1.log)(this.config, 'Error reading master-locale.json, using fallback', 'warn');
+            }
+        }
+        // Fallback to config or default
+        const fallbackCode = ((_a = this.config.master_locale) === null || _a === void 0 ? void 0 : _a.code) || 'en-us';
+        (0, utils_1.log)(this.config, `Using fallback master locale: ${fallbackCode}`, 'info');
+        return fallbackCode;
+    }
+    /**
+     * Load available locales from locales file
+     * @returns {Record<string, string>} Map of locale codes
+     */
+    loadAvailableLocales() {
+        const locales = {};
+        // First, get the master locale
+        const masterLocaleCode = this.getMasterLocaleCode();
+        locales[masterLocaleCode] = masterLocaleCode;
+        // Then load additional locales from locales.json if it exists
+        if (!utils_1.fileHelper.fileExistsSync(this.localesFilePath)) {
+            (0, utils_1.log)(this.config, 'No locales file found, using only master locale', 'info');
+            return locales;
+        }
+        try {
+            const localesData = utils_1.fsUtil.readFile(this.localesFilePath, true);
+            for (const [uid, locale] of Object.entries(localesData)) {
+                if (locale === null || locale === void 0 ? void 0 : locale.code) {
+                    locales[locale.code] = locale.code;
+                }
+            }
+            (0, utils_1.log)(this.config, `Loaded ${Object.keys(locales).length} locales (1 master + ${Object.keys(locales).length - 1} additional)`, 'info');
+            return locales;
+        }
+        catch (error) {
+            (0, utils_1.log)(this.config, 'Error loading locales file, using only master locale', 'error');
+            return locales;
+        }
+    }
     /**
      * Retrieves the taxonomies based on the provided taxonomy UID.
      *
      * @param taxonomy - The UID of the taxonomy to retrieve.
+     * @param locale - Optional locale code to query taxonomy in specific locale
      * @returns A promise that resolves to the retrieved taxonomies.
      */
-    async getTaxonomies(taxonomy) {
+    async getTaxonomies(taxonomy, locale) {
+        const query = {};
+        if (locale) {
+            query.locale = locale;
+        }
         return await this.stackAPIClient
             .taxonomy(taxonomy.uid)
-            .fetch()
+            .fetch(query)
             .then((data) => data)
-            .catch((err) => this.handleTaxonomyErrorMsg(err));
+            .catch((err) => this.handleTaxonomyErrorMsg(err, taxonomy.uid, locale));
     }
     /**
      * Sanitizes the attributes of a taxonomy object.
@@ -87,19 +220,21 @@ class TaxonomiesImportSetup {
      * Retrieves all terms of a taxonomy.
      *
      * @param taxonomy - The taxonomy object.
+     * @param locale - Optional locale code to query terms in specific locale
      * @param skip - The number of terms to skip (default: 0).
      * @param terms - An array to store the retrieved terms (default: []).
      * @returns A promise that resolves to an array of terms.
      */
-    async getAllTermsOfTaxonomy(taxonomy, skip = 0, terms = []) {
+    async getAllTermsOfTaxonomy(taxonomy, locale, skip = 0, terms = []) {
         const queryParams = {
             include_count: true,
             limit: 100,
             skip,
+            depth: 0,
         };
-        if (skip >= 0)
-            queryParams['skip'] = skip || 0;
-        queryParams['depth'] = 0;
+        if (locale) {
+            queryParams.locale = locale;
+        }
         await this.stackAPIClient
             .taxonomy(taxonomy.uid)
             .terms()
@@ -108,10 +243,10 @@ class TaxonomiesImportSetup {
             .then((data) => {
             terms = terms.concat(data.items);
             if (data.count >= skip + queryParams.limit) {
-                return this.getAllTermsOfTaxonomy(taxonomy, skip + 100, terms);
+                return this.getAllTermsOfTaxonomy(taxonomy, locale, skip + 100, terms);
             }
         })
-            .catch((err) => this.handleTaxonomyErrorMsg(err));
+            .catch((err) => this.handleTaxonomyErrorMsg(err, taxonomy.uid, locale));
         return terms;
     }
     /**
@@ -126,14 +261,16 @@ class TaxonomiesImportSetup {
         }
         return terms;
     }
-    handleTaxonomyErrorMsg(err) {
+    handleTaxonomyErrorMsg(err, taxonomyUid, locale) {
         var _a, _b;
+        const context = locale ? ` for locale: ${locale}` : '';
+        const taxInfo = taxonomyUid ? ` (${taxonomyUid}${context})` : '';
         if ((err === null || err === void 0 ? void 0 : err.errorMessage) || (err === null || err === void 0 ? void 0 : err.message)) {
             const errorMsg = (err === null || err === void 0 ? void 0 : err.errorMessage) || ((_a = err === null || err === void 0 ? void 0 : err.errors) === null || _a === void 0 ? void 0 : _a.taxonomy) || ((_b = err === null || err === void 0 ? void 0 : err.errors) === null || _b === void 0 ? void 0 : _b.term) || (err === null || err === void 0 ? void 0 : err.message);
-            (0, utils_1.log)(this.config, errorMsg, 'error');
+            (0, utils_1.log)(this.config, `${errorMsg}${taxInfo}`, 'error');
         }
         else {
-            (0, utils_1.log)(this.config, 'Error fetching taxonomy data!', 'error');
+            (0, utils_1.log)(this.config, `Error fetching taxonomy data${taxInfo}!`, 'error');
             (0, utils_1.log)(this.config, err, 'error');
         }
     }

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

@@ -13,6 +13,11 @@ export default interface DefaultConfig {
             fileName: string;
             dependencies?: Modules[];
         };
+        locales: {
+            dirName: string;
+            fileName: string;
+            dependencies?: Modules[];
+        };
         extensions: {
             dirName: string;
             fileName: string;

package/lib/types/index.d.ts

@@ -112,4 +112,5 @@ export type TaxonomyQueryParams = {
     limit: number;
     skip: number;
     depth?: number;
+    locale?: string;
 };

package/oclif.manifest.json

@@ -88,5 +88,5 @@
       ]
     }
   },
-  "version": "1.6.0"
+  "version": "1.7.0"
 }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@contentstack/cli-cm-import-setup",
   "description": "Contentstack CLI plugin to setup the mappers and configurations for the import command",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "author": "Contentstack",
   "bugs": "https://github.com/contentstack/cli/issues",
   "dependencies": {
     "@contentstack/cli-command": "~1.6.1",
-    "@contentstack/cli-utilities": "~1.14.1",
+    "@contentstack/cli-utilities": "~1.14.4",
     "@oclif/core": "^4.3.0",
     "big-json": "^3.2.0",
     "chalk": "^4.1.2",
@@ -24,7 +24,7 @@
     "@types/mkdirp": "^1.0.2",
     "@types/mocha": "^8.2.3",
     "@types/node": "^14.18.63",
-    "@types/proxyquire": "^1.3.31",
+    "@types/rewire": "^2.5.30",
     "@types/tar": "^6.1.13",
     "@types/uuid": "^9.0.8",
     "@typescript-eslint/eslint-plugin": "^5.62.0",
@@ -34,7 +34,7 @@
     "mocha": "^10.8.2",
     "nyc": "^15.1.0",
     "oclif": "^4.17.46",
-    "proxyquire": "^2.1.3",
+    "rewire": "^9.0.1",
     "ts-node": "^10.9.2",
     "tsx": "^4.20.3",
     "typescript": "^4.9.5"