@contentstack/cli-cm-bulk-publish 1.6.0 → 1.7.1

package/src/producer/publish-entries.js

@@ -9,6 +9,7 @@ const retryFailedLogs = require('../util/retryfailed');
 const { validateFile } = require('../util/fs');
 const { isEmpty } = require('../util');
 const { fetchBulkPublishLimit } = require('../util/common-utility');
+const VARIANTS_PUBLISH_API_VERSION = '3.2';
 
 const queue = getQueue();
 
@@ -27,6 +28,8 @@ async function getEntries(
   environments,
   apiVersion,
   bulkPublishLimit,
+  variantsFlag = false,
+  entry_uid = undefined,
   skip = 0,
 ) {
   return new Promise((resolve, reject) => {
@@ -39,6 +42,13 @@ async function getEntries(
       include_publish_details: true,
     };
 
+    if (variantsFlag) {
+      queryParams.apiVersion = VARIANTS_PUBLISH_API_VERSION;
+    }
+    if (entry_uid) {
+      queryParams.uid = entry_uid;
+    }
+
     stack
       .contentType(contentType)
       .entry()
@@ -47,16 +57,31 @@ async function getEntries(
       .then(async (entriesResponse) => {
         skipCount += entriesResponse.items.length;
         let entries = entriesResponse.items;
-        for (let index = 0; index < entriesResponse.items.length; index++) {
+
+        for (let index = 0; index < entries.length; index++) {
+          let variants = [];
           if (bulkPublish) {
+            let entry;
             if (bulkPublishSet.length < bulkPublishLimit) {
-              bulkPublishSet.push({
+              entry = {
                 uid: entries[index].uid,
                 content_type: contentType,
                 locale,
                 publish_details: entries[index].publish_details || [],
-              });
+              };
+
+              if (variantsFlag) {
+                variants = await getVariantEntries(stack, contentType, entries, index, queryParams);
+                if (variants.length > 0) {
+                  entry.variant_rules = {
+                    publish_latest_base: false,
+                    publish_latest_base_conditionally: true,
+                  };
+                  entry.variants = variants;
+                }
+              }
             }
+            bulkPublishSet.push(entry);
 
             if (bulkPublishSet.length === bulkPublishLimit) {
               await queue.Enqueue({
@@ -71,7 +96,7 @@ async function getEntries(
             }
 
             if (
-              index === entriesResponse.items.length - 1 &&
+              index === entries.length - 1 &&
               bulkPublishSet.length <= bulkPublishLimit &&
               bulkPublishSet.length > 0
             ) {
@@ -84,7 +109,7 @@ async function getEntries(
                 apiVersion,
               });
               bulkPublishSet = [];
-            } // bulkPublish
+            }
           } else {
             await queue.Enqueue({
               content_type: contentType,
@@ -110,6 +135,8 @@ async function getEntries(
           environments,
           apiVersion,
           bulkPublishLimit,
+          variantsFlag,
+          entry_uid,
           skipCount,
         );
         return resolve();
@@ -118,6 +145,56 @@ async function getEntries(
   });
 }
 
+async function getVariantEntries(stack, contentType, entries, index, queryParams, skip = 0) {
+  try {
+    let variantQueryParams = {
+      locale: queryParams.locale || 'en-us',
+      include_count: true,
+      skip: skip, // Adding skip parameter for pagination
+      limit: 100, // Set a limit to fetch up to 100 entries per request
+      include_publish_details: true,
+    };
+
+    const variantsEntriesResponse = await stack
+      .contentType(contentType)
+      .entry(entries[index].uid)
+      .variants()
+      .query(variantQueryParams)
+      .find();
+
+    // Map the response items to extract variant UIDs
+    const variants = variantsEntriesResponse.items.map((entry) => ({
+      uid: entry.variants._variant._uid,
+    }));
+
+    // Check if there are more entries to fetch
+    if (variantsEntriesResponse.items.length === variantQueryParams.limit) {
+      // Recursively fetch the next set of variants with updated skip value
+      const nextVariants = await getVariantEntries(
+        stack,
+        contentType,
+        entries,
+        index,
+        queryParams,
+        skip + variantQueryParams.limit,
+      );
+
+      // Ensure nextVariants is an array before concatenation
+      return Array.isArray(nextVariants) ? variants.concat(nextVariants) : variants;
+    }
+
+    return variants;
+  } catch (error) {
+    // Handle error message retrieval from different properties
+    const errorMessage =
+      error?.errorMessage ||
+      error?.message ||
+      error?.errors ||
+      'Falied to fetch the variant entries, Please contact the admin for support.';
+    throw new Error(`Error fetching variants: ${errorMessage}`);
+  }
+}
+
 async function getContentTypes(stack, skip = 0, contentTypes = []) {
   return new Promise((resolve, reject) => {
     skipCount = skip;
@@ -154,7 +231,17 @@ function setConfig(conf, bp) {
 }
 
 async function start(
-  { retryFailed, bulkPublish, publishAllContentTypes, contentTypes, locales, environments, apiVersion },
+  {
+    retryFailed,
+    bulkPublish,
+    publishAllContentTypes,
+    contentTypes,
+    locales,
+    environments,
+    apiVersion,
+    includeVariants,
+    entryUid,
+  },
   stack,
   config,
 ) {
@@ -168,12 +255,16 @@ async function start(
     }
     process.exit(0);
   });
+
+  if (includeVariants) {
+    apiVersion = VARIANTS_PUBLISH_API_VERSION;
+  }
+
   if (retryFailed) {
     if (typeof retryFailed === 'string') {
       if (!validateFile(retryFailed, ['publish-entries', 'bulk-publish-entries'])) {
         return false;
       }
-
       bulkPublish = retryFailed.match(new RegExp('bulk')) ? true : false;
       setConfig(config, bulkPublish);
       if (bulkPublish) {
@@ -201,6 +292,8 @@ async function start(
           environments,
           apiVersion,
           bulkPublishLimit,
+          includeVariants,
+          entryUid,
         );
         /* eslint-enable no-await-in-loop */
       }

package/src/producer/unpublish.js

@@ -16,6 +16,7 @@ const { Command } = require('@contentstack/cli-command');
 const command = new Command();
 const { isEmpty } = require('../util');
 const { fetchBulkPublishLimit } = require('../util/common-utility');
+const VARIANTS_UNPUBLISH_API_VERSION = '3.2';
 
 let bulkUnPublishSet = [];
 let bulkUnPulishAssetSet = [];
@@ -51,19 +52,26 @@ function getQueryParams(filter) {
   return queryString;
 }
 
-function bulkAction(stack, items, bulkUnpublish, environment, locale, apiVersion, bulkPublishLimit) {
+function bulkAction(stack, items, bulkUnpublish, environment, locale, apiVersion, bulkPublishLimit, variantsFlag = false) {
   return new Promise(async (resolve) => {
     for (let index = 0; index < items.length; index++) {
       changedFlag = true;
 
       if (bulkUnpublish) {
         if (bulkUnPublishSet.length < bulkPublishLimit && items[index].type === 'entry_published') {
-          bulkUnPublishSet.push({
+          const entryData = {
             uid: items[index].data.uid,
             content_type: items[index].content_type_uid,
             locale: items[index].data.locale || 'en-us',
-            publish_details: [items[index].data.publish_details] || [],
-          });
+            publish_details: items[index].data.publish_details || [],
+          };
+        
+          if (variantsFlag && Array.isArray(items[index].data.variants) && items[index].data.variants.length > 0) {
+            const entryWithVariants = { ...entryData, variants: items[index].data.variants };
+            bulkUnPublishSet.push(entryWithVariants);
+          } else {
+            bulkUnPublishSet.push(entryData);
+          }
         }
 
         if (bulkUnPulishAssetSet.length < bulkPublishLimit && items[index].type === 'asset_published') {
@@ -122,7 +130,7 @@ function bulkAction(stack, items, bulkUnpublish, environment, locale, apiVersion
         }
       } else {
         if (items[index].type === 'entry_published') {
-          await entryQueue.Enqueue({
+          await entryQueue.Enqueue({  
             content_type: items[index].content_type_uid,
             publish_details: [items[index].data.publish_details],
             environments: [environment],
@@ -130,6 +138,7 @@ function bulkAction(stack, items, bulkUnpublish, environment, locale, apiVersion
             locale: items[index].data.locale || 'en-us',
             Type: 'entry',
             stack: stack,
+            apiVersion,
           });
         }
         if (items[index].type === 'asset_published') {
@@ -157,6 +166,7 @@ async function getSyncEntries(
   deliveryToken,
   apiVersion,
   bulkPublishLimit,
+  variantsFlag,
   paginationToken = null,
 ) {
   return new Promise(async (resolve, reject) => {
@@ -203,12 +213,22 @@ async function getSyncEntries(
       if (queryParamsObj.type) {
         syncData['type'] = queryParamsObj.type;
       }
+      if(queryParamsObj.content_type_uid) {
+        syncData['content_type_uid'] = queryParamsObj.content_type_uid;
+      }
 
       const entriesResponse = await Stack.sync(syncData);
-
       if (entriesResponse.items.length > 0) {
-        await bulkAction(stack, entriesResponse.items, bulkUnpublish, environment, locale, apiVersion, bulkPublishLimit);
+        if (variantsFlag) {
+          queryParamsObj.apiVersion = VARIANTS_UNPUBLISH_API_VERSION;
+          const itemsWithVariants = await attachVariantsToItems(stack, entriesResponse.items, queryParamsObj);
+          // Call bulkAction for entries with variants
+          await bulkAction(stack, itemsWithVariants, bulkUnpublish, environment, locale, apiVersion, bulkPublishLimit, variantsFlag);
+        }
+        // Call bulkAction for entries without variants
+        await bulkAction(stack, entriesResponse.items, bulkUnpublish, environment, locale, apiVersion, bulkPublishLimit, false);
       }
+      
       if (entriesResponse.items.length === 0) {
         if (!changedFlag) console.log('No Entries/Assets Found published on specified environment');
         return resolve();
@@ -224,6 +244,7 @@ async function getSyncEntries(
           deliveryToken,
           apiVersion,
           bulkPublishLimit,
+          variantsFlag,
           null,
         );
       }, 3000);
@@ -232,6 +253,52 @@ async function getSyncEntries(
     }
   });
 }
+async function attachVariantsToItems(stack, items, queryParams) {
+  for (const item of items) {
+    const { content_type_uid, data } = item;
+    const variantEntries = await getVariantEntries(stack, content_type_uid, item, queryParams); // Fetch the variants using fetchVariants method
+    item.data.variants = variantEntries; // Attach the fetched variants to the data object in the item
+  }
+  return items;
+}
+
+async function getVariantEntries(stack, contentType, entries, queryParams, skip = 0) {
+  try {
+    let variantQueryParams = {
+      locale: queryParams.locale || 'en-us',
+      include_count: true,
+      skip: skip,  // Adding skip parameter for pagination
+      limit: 100,  // Set a limit to fetch up to 100 entries per request
+    };
+
+    const variantsEntriesResponse = await stack
+      .contentType(contentType)
+      .entry(entries.data.uid)
+      .variants()
+      .query(variantQueryParams)
+      .find();
+
+    // Map the response items to extract variant UIDs
+    const variants = variantsEntriesResponse.items.map(entry => ({
+      uid: entry.variants._variant._uid,
+    }));
+
+    // Check if there are more entries to fetch
+    if (variantsEntriesResponse.items.length === variantQueryParams.limit) {
+      // Recursively fetch the next set of variants with updated skip value
+      const nextVariants = await getVariantEntries(stack, contentType, entries, queryParams, skip + variantQueryParams.limit);
+      
+      // Ensure nextVariants is an array before concatenation
+      return Array.isArray(nextVariants) ? variants.concat(nextVariants) : variants;
+    }
+
+    return variants;
+  } catch (error) {
+    // Handle error message retrieval from different properties
+    const errorMessage = error?.errorMessage || error?.message || error?.errors || 'Falied to fetch the variant entries, Please contact the admin for support.';
+    throw new Error(`Error fetching variants: ${errorMessage}`);
+  }
+}
 
 async function start(
   {
@@ -245,6 +312,7 @@ async function start(
     onlyEntries,
     f_types,
     apiVersion,
+    includeVariants,
   },
   stack,
   config,
@@ -259,7 +327,9 @@ async function start(
     }
     process.exit(0);
   });
-
+  if (includeVariants) {
+    apiVersion = VARIANTS_UNPUBLISH_API_VERSION;
+  }
   if (retryFailed) {
     if (typeof retryFailed === 'string' && retryFailed.length > 0) {
       if (!validateFile(retryFailed, ['unpublish', 'bulk-unpublish'])) {
@@ -298,7 +368,7 @@ async function start(
     setConfig(config, bulkUnpublish);
     const queryParams = getQueryParams(filter);
     const bulkPublishLimit = fetchBulkPublishLimit(stack?.org_uid);
-    await getSyncEntries(stack, config, locale, queryParams, bulkUnpublish, environment, deliveryToken, apiVersion, bulkPublishLimit);
+    await getSyncEntries(stack, config, locale, queryParams, bulkUnpublish, environment, deliveryToken, apiVersion, bulkPublishLimit, includeVariants);
   }
 }
 
@@ -309,4 +379,4 @@ module.exports = {
   setConfig,
   getQueryParams,
   start,
-};
+};