Fix/back merge development v2

packages/contentstack-cli-cm-regex-validate/package.json

@@ -32,8 +32,8 @@
     "jest": "^30.4.2",
     "mocha": "^10.8.2",
     "nyc": "^15.1.0",
-    "oclif": "^4.23.8",
-    "ts-jest": "^29.4.9",
+    "oclif": "^4.23.21",
+    "ts-jest": "^29.4.11",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
   },
@@ -84,4 +84,4 @@
       "cm:stacks:validate-regex": "RGXVLD"
     }
   }
-}
+}

packages/contentstack-external-migrate/package.json

@@ -26,7 +26,7 @@
     "@contentstack/cli-command": "~2.0.0-beta.9",
     "@contentstack/cli-utilities": "~2.0.0-beta.10",
     "@contentstack/json-rte-serializer": "~2.1.0",
-    "@contentstack/marketplace-sdk": "~1.5.2",
+    "@contentstack/marketplace-sdk": "~1.5.3",
     "@oclif/core": "^4.8.0",
     "axios": "^1.18.1",
     "chalk": "^4.1.2",

packages/contentstack-migration/examples/change-master-locale/02-change-master-locale-new-file-structure.js

@@ -25,7 +25,10 @@ module.exports = async ({ migration, config }) => {
       }
 
       async function tailorData() {
-        let locales = await fs.readFile(pathValidator(path.resolve(sanitizePath(config.data_dir), 'locales/locales.json')), 'utf-8');
+        let locales = await fs.readFile(
+          pathValidator(path.resolve(sanitizePath(config.data_dir), 'locales/locales.json')),
+          'utf-8',
+        );
         let masterLocale = await fs.readFile(
           pathValidator(path.resolve(sanitizePath(config.data_dir), 'locales/master-locale.json')),
           'utf-8',
@@ -34,12 +37,14 @@ module.exports = async ({ migration, config }) => {
         if (masterLocale) {
           masterLocale = JSON.parse(masterLocale);
           masterLocale = Object.values(masterLocale);
-          masterLocale = masterLocale[0]
-          
+          masterLocale = masterLocale[0];
+
           // Validate that we have a valid master locale code
-          if (!masterLocale) {
+          if (!masterLocale || !masterLocale.code) {
             throw new Error('Unable to determine master locale code from master-locale.json');
           }
+
+          masterLocale = masterLocale.code;
         }
         locales = JSON.parse(locales);
         let id = crypto.randomBytes(8).toString('hex');
@@ -60,6 +65,7 @@ module.exports = async ({ migration, config }) => {
         locales[id].fallback_locale = config.target_locale;
 
         await handleEntries(masterLocale);
+        await handleTaxonomies(masterLocale);
         await fs.writeFile(
           pathValidator(path.resolve(sanitizePath(config.data_dir), 'locales/locales.json')),
           JSON.stringify(locales),
@@ -84,21 +90,23 @@ module.exports = async ({ migration, config }) => {
           let sourceMasterLocaleEntries, targetMasterLocaleEntries;
 
           // Check if index.json exists (if no entries, index.json won't be created)
-          const indexFilePath = pathValidator(path.resolve(sanitizePath(config.data_dir), sanitizePath(`entries/${contentType}/${masterLocale}/index.json`)));
+          const indexFilePath = pathValidator(
+            path.resolve(
+              sanitizePath(config.data_dir),
+              sanitizePath(`entries/${contentType}/${masterLocale}/index.json`),
+            ),
+          );
           if (!existsSync(indexFilePath)) {
             console.log(`Skipping ${contentType} - no index.json found (likely no entries)`);
             continue;
           }
 
-          sourceMasterLocaleEntries = await fs.readFile(
-            indexFilePath,
-            { encoding: 'utf8' },
-          );
+          sourceMasterLocaleEntries = await fs.readFile(indexFilePath, { encoding: 'utf8' });
 
           // Parse the index.json to get the entries file name
           const indexData = JSON.parse(sourceMasterLocaleEntries);
           const entriesFileName = Object.values(indexData)[0];
-          
+
           // Check if we have a valid entries file name
           if (!entriesFileName) {
             console.log(`Skipping ${contentType} - no entries file found in index.json`);
@@ -112,10 +120,7 @@ module.exports = async ({ migration, config }) => {
             ),
           );
 
-          sourceMasterLocaleEntries = await fs.readFile(
-            entriesFilePath,
-            { encoding: 'utf8' },
-          );
+          sourceMasterLocaleEntries = await fs.readFile(entriesFilePath, { encoding: 'utf8' });
           sourceMasterLocaleEntries = JSON.parse(sourceMasterLocaleEntries);
           if (
             existsSync(pathValidator(path.resolve(config.data_dir, `entries/${contentType}/${config.target_locale}`)))
@@ -127,7 +132,7 @@ module.exports = async ({ migration, config }) => {
             if (targetMasterLocaleEntries) {
               const targetIndexData = JSON.parse(targetMasterLocaleEntries);
               const targetEntriesFileName = Object.values(targetIndexData)[0];
-              
+
               if (targetEntriesFileName) {
                 targetMasterLocaleEntries = await fs.readFile(
                   pathValidator(
@@ -152,7 +157,7 @@ module.exports = async ({ migration, config }) => {
           Object.keys(sourceMasterLocaleEntries).forEach((uid) => {
             if (!targetMasterLocaleEntries[uid]) {
               targetMasterLocaleEntries[uid] = JSON.parse(JSON.stringify(sourceMasterLocaleEntries[uid]));
-              delete targetMasterLocaleEntries[uid]['publish_details'];
+              targetMasterLocaleEntries[uid]['publish_details'] = [];
               targetMasterLocaleEntries[uid].locale = config.target_locale;
             }
           });
@@ -164,10 +169,10 @@ module.exports = async ({ migration, config }) => {
               pathValidator(path.resolve(config.data_dir, `entries/${contentType}/${config.target_locale}/index.json`)),
               { encoding: 'utf8', flag: 'a+' },
             );
-            
+
             const existingIndexData = JSON.parse(exsitingTargetMasterLocalEntries);
             const existingEntriesFileName = Object.values(existingIndexData)[0];
-            
+
             if (existingEntriesFileName) {
               await fs.writeFile(
                 pathValidator(
@@ -194,6 +199,88 @@ module.exports = async ({ migration, config }) => {
         }
       }
 
+      async function handleTaxonomies(masterLocale) {
+        const taxonomiesDirPath = pathValidator(path.resolve(sanitizePath(config.data_dir), 'taxonomies'));
+        const taxonomiesIndexPath = pathValidator(path.resolve(taxonomiesDirPath, 'taxonomies.json'));
+
+        if (!existsSync(taxonomiesIndexPath)) {
+          console.log('Skipping taxonomies - no taxonomies.json found');
+          return;
+        }
+
+        let taxonomiesIndex = await fs.readFile(taxonomiesIndexPath, { encoding: 'utf8' });
+        taxonomiesIndex = JSON.parse(taxonomiesIndex);
+
+        const targetLocaleDirPath = pathValidator(path.resolve(taxonomiesDirPath, sanitizePath(config.target_locale)));
+
+        for (const taxonomyUid of Object.keys(taxonomiesIndex)) {
+          const fileName = `${sanitizePath(taxonomyUid)}.json`;
+          const targetFilePath = pathValidator(path.resolve(targetLocaleDirPath, fileName));
+
+          // Prefer the old master locale's taxonomy data, then the locale recorded at export time,
+          // then fall back to any other locale that has it
+          const exportedLocale = taxonomiesIndex[taxonomyUid]?.locale;
+          let sourceFilePath;
+          for (const localeCode of [masterLocale, exportedLocale]) {
+            if (!localeCode) {
+              continue;
+            }
+            const candidatePath = pathValidator(path.resolve(taxonomiesDirPath, sanitizePath(localeCode), fileName));
+            if (existsSync(candidatePath)) {
+              sourceFilePath = candidatePath;
+              break;
+            }
+          }
+
+          if (!sourceFilePath) {
+            const localeEntries = await fs.readdir(taxonomiesDirPath, { withFileTypes: true });
+            for (const localeEntry of localeEntries) {
+              if (!localeEntry.isDirectory() || localeEntry.name === config.target_locale) {
+                continue;
+              }
+              const candidatePath = pathValidator(
+                path.resolve(taxonomiesDirPath, sanitizePath(localeEntry.name), fileName),
+              );
+              if (existsSync(candidatePath)) {
+                sourceFilePath = candidatePath;
+                break;
+              }
+            }
+          }
+
+          if (!sourceFilePath) {
+            console.log(`Skipping taxonomy '${taxonomyUid}' - no source locale data found`);
+            continue;
+          }
+
+          let sourceTaxonomy = await fs.readFile(sourceFilePath, { encoding: 'utf8' });
+          sourceTaxonomy = JSON.parse(sourceTaxonomy);
+
+          if (existsSync(targetFilePath)) {
+            let targetTaxonomy = await fs.readFile(targetFilePath, { encoding: 'utf8' });
+            targetTaxonomy = JSON.parse(targetTaxonomy);
+            targetTaxonomy.terms = targetTaxonomy.terms || [];
+
+            const existingTermUids = new Set(targetTaxonomy.terms.map((term) => term.uid));
+            for (const term of sourceTaxonomy.terms || []) {
+              if (!existingTermUids.has(term.uid)) {
+                targetTaxonomy.terms.push(JSON.parse(JSON.stringify(term)));
+              }
+            }
+
+            await fs.writeFile(targetFilePath, JSON.stringify(targetTaxonomy));
+          } else {
+            await fs.mkdir(targetLocaleDirPath, { recursive: true });
+
+            const targetTaxonomy = JSON.parse(JSON.stringify(sourceTaxonomy));
+            targetTaxonomy.taxonomy = targetTaxonomy.taxonomy || {};
+            targetTaxonomy.taxonomy.locale = config.target_locale;
+
+            await fs.writeFile(targetFilePath, JSON.stringify(targetTaxonomy));
+          }
+        }
+      }
+
       await tailorData();
     },
   };