@contentstack/cli-cm-bulk-publish 0.1.1-beta.5 → 1.0.0

package/src/producer/publish-entries.js

@@ -3,144 +3,175 @@
 /* eslint-disable camelcase */
 /* eslint-disable max-depth */
 /* eslint-disable no-console */
-const {getQueue} = require('../util/queue')
-const {performBulkPublish, publishEntry, initializeLogger} = require('../consumer/publish')
-const retryFailedLogs = require('../util/retryfailed')
-const {validateFile} = require('../util/fs')
-const {isEmpty} = require('../util')
+const { getQueue } = require('../util/queue');
+const { performBulkPublish, publishEntry, initializeLogger } = require('../consumer/publish');
+const retryFailedLogs = require('../util/retryfailed');
+const { validateFile } = require('../util/fs');
+const { isEmpty } = require('../util');
 
-const queue = getQueue()
+const queue = getQueue();
 
-let skipCount
-let logFileName
-let contentTypesList = []
-let allContentTypes = []
-let bulkPublishSet = []
-let filePath
+let skipCount;
+let logFileName;
+let contentTypesList = [];
+let allContentTypes = [];
+let bulkPublishSet = [];
+let filePath;
 
 async function getEntries(stack, contentType, locale, bulkPublish, environments, skip = 0) {
   return new Promise((resolve, reject) => {
-    skipCount = skip
+    skipCount = skip;
 
     let queryParams = {
-      locale: (locale || 'en-us'),
+      locale: locale || 'en-us',
       include_count: true,
       skip: skipCount,
       include_publish_details: true,
-    }
+    };
 
-    stack.contentType(contentType).entry().query(queryParams).find()
-    .then(async entriesResponse => {
-      skipCount += entriesResponse.items.length
-      let entries = entriesResponse.items
-      for (let index = 0; index < entriesResponse.items.length; index++) {
-        if (bulkPublish) {
-          if (bulkPublishSet.length < 10) {
-            bulkPublishSet.push({
-              uid: entries[index].uid,
-              content_type: contentType,
-              locale,
-              publish_details: entries[index].publish_details || [],
-            })
-          }
+    stack
+      .contentType(contentType)
+      .entry()
+      .query(queryParams)
+      .find()
+      .then(async (entriesResponse) => {
+        skipCount += entriesResponse.items.length;
+        let entries = entriesResponse.items;
+        for (let index = 0; index < entriesResponse.items.length; index++) {
+          if (bulkPublish) {
+            if (bulkPublishSet.length < 10) {
+              bulkPublishSet.push({
+                uid: entries[index].uid,
+                content_type: contentType,
+                locale,
+                publish_details: entries[index].publish_details || [],
+              });
+            }
 
-          if (bulkPublishSet.length === 10) {
-            await queue.Enqueue({
-              entries: bulkPublishSet, locale, Type: 'entry', environments: environments, stack: stack
-            })
-            bulkPublishSet = []
-          }
+            if (bulkPublishSet.length === 10) {
+              await queue.Enqueue({
+                entries: bulkPublishSet,
+                locale,
+                Type: 'entry',
+                environments: environments,
+                stack: stack,
+              });
+              bulkPublishSet = [];
+            }
 
-          if (index === entriesResponse.items.length - 1 && bulkPublishSet.length <= 10 && bulkPublishSet.length > 0) {
+            if (
+              index === entriesResponse.items.length - 1 &&
+              bulkPublishSet.length <= 10 &&
+              bulkPublishSet.length > 0
+            ) {
+              await queue.Enqueue({
+                entries: bulkPublishSet,
+                locale,
+                Type: 'entry',
+                environments: environments,
+                stack: stack,
+              });
+              bulkPublishSet = [];
+            } // bulkPublish
+          } else {
             await queue.Enqueue({
-              entries: bulkPublishSet, locale, Type: 'entry', environments: environments, stack: stack
-            })
-            bulkPublishSet = []
-          } // bulkPublish
-        } else {
-          await queue.Enqueue({
-            content_type: contentType, publish_details: entries[index].publish_details || [], environments: environments, entryUid: entries[index].uid, locale, Type: 'entry', stack: stack
-          })
+              content_type: contentType,
+              publish_details: entries[index].publish_details || [],
+              environments: environments,
+              entryUid: entries[index].uid,
+              locale,
+              Type: 'entry',
+              stack: stack,
+            });
+          }
         }
-      }
 
-      if (entriesResponse.count === skipCount) {
-        bulkPublishSet = []
-        return resolve()
-      }
-      await getEntries(stack, contentType, locale, bulkPublish, environments, skipCount)
-      return resolve()
-    })
-    .catch(error => reject(error))
-  })
+        if (entriesResponse.count === skipCount) {
+          bulkPublishSet = [];
+          return resolve();
+        }
+        await getEntries(stack, contentType, locale, bulkPublish, environments, skipCount);
+        return resolve();
+      })
+      .catch((error) => reject(error));
+  });
 }
 
 async function getContentTypes(stack, skip = 0, contentTypes = []) {
   return new Promise((resolve, reject) => {
-    skipCount = skip
-    contentTypesList = contentTypes
-    stack.contentType().query({include_count: true, skip: skipCount}).find().then(contentTypeResponse => {
-      if (contentTypeResponse.items.length > 0) {
-        contentTypesList = [...contentTypesList, ...contentTypeResponse.items]
-        skipCount += contentTypeResponse.items.length
-        if (skipCount < contentTypeResponse.count) {
-          getContentTypes(stack, skipCount, contentTypesList)
+    skipCount = skip;
+    contentTypesList = contentTypes;
+    stack
+      .contentType()
+      .query({ include_count: true, skip: skipCount })
+      .find()
+      .then((contentTypeResponse) => {
+        if (contentTypeResponse.items.length > 0) {
+          contentTypesList = [...contentTypesList, ...contentTypeResponse.items];
+          skipCount += contentTypeResponse.items.length;
+          if (skipCount < contentTypeResponse.count) {
+            getContentTypes(stack, skipCount, contentTypesList);
+          }
+          resolve(contentTypesList);
         }
-        resolve(contentTypesList)
-      }
-    }).catch(error => reject(error))
-  })
+      })
+      .catch((error) => reject(error));
+  });
 }
 
 function setConfig(conf, bp) {
   if (bp) {
-    queue.consumer = performBulkPublish
-    logFileName = 'bulk-publish-entries'
+    queue.consumer = performBulkPublish;
+    logFileName = 'bulk-publish-entries';
   } else {
-    queue.consumer = publishEntry
-    logFileName = 'publish-entries'
+    queue.consumer = publishEntry;
+    logFileName = 'publish-entries';
   }
-  config = conf
-  queue.config = conf
-  filePath = initializeLogger(logFileName)
+  config = conf;
+  queue.config = conf;
+  filePath = initializeLogger(logFileName);
 }
 
-async function start({retryFailed, bulkPublish, publishAllContentTypes, contentTypes, locales, environments}, stack, config) {
+async function start(
+  { retryFailed, bulkPublish, publishAllContentTypes, contentTypes, locales, environments },
+  stack,
+  config,
+) {
   process.on('beforeExit', async () => {
-    const isErrorLogEmpty = await isEmpty(`${filePath}.error`)
-    const isSuccessLogEmpty = await isEmpty(`${filePath}.success`)
+    const isErrorLogEmpty = await isEmpty(`${filePath}.error`);
+    const isSuccessLogEmpty = await isEmpty(`${filePath}.success`);
     if (!isErrorLogEmpty) {
-      console.log(`The error log for this session is stored at ${filePath}.error`)
+      console.log(`The error log for this session is stored at ${filePath}.error`);
     } else if (!isSuccessLogEmpty) {
-      console.log(`The success log for this session is stored at ${filePath}.success`)
+      console.log(`The success log for this session is stored at ${filePath}.success`);
     }
-    process.exit(0)  
-  })
+    process.exit(0);
+  });
   if (retryFailed) {
     if (typeof retryFailed === 'string') {
       if (!validateFile(retryFailed, ['publish-entries', 'bulk-publish-entries'])) {
-        return false
+        return false;
       }
 
-      bulkPublish = retryFailed.match(new RegExp('bulk')) ? true : false
-      setConfig(config, bulkPublish)
+      bulkPublish = retryFailed.match(new RegExp('bulk')) ? true : false;
+      setConfig(config, bulkPublish);
       if (bulkPublish) {
-        await retryFailedLogs(retryFailed, queue, 'bulk')
+        await retryFailedLogs(retryFailed, queue, 'bulk');
       } else {
-        await retryFailedLogs(retryFailed, {entryQueue: queue}, 'publish')
+        await retryFailedLogs(retryFailed, { entryQueue: queue }, 'publish');
       }
     }
   } else {
-    setConfig(config, bulkPublish)
+    setConfig(config, bulkPublish);
     if (publishAllContentTypes) {
-      allContentTypes = await getContentTypes(stack)
+      allContentTypes = await getContentTypes(stack);
     } else {
-      allContentTypes = contentTypes
+      allContentTypes = contentTypes;
     }
     for (let loc = 0; loc < locales.length; loc += 1) {
       for (let i = 0; i < allContentTypes.length; i += 1) {
         /* eslint-disable no-await-in-loop */
-        await getEntries(stack, allContentTypes[i].uid || allContentTypes[i], locales[loc], bulkPublish, environments)
+        await getEntries(stack, allContentTypes[i].uid || allContentTypes[i], locales[loc], bulkPublish, environments);
         /* eslint-enable no-await-in-loop */
       }
     }
@@ -152,4 +183,4 @@ module.exports = {
   setConfig,
   getContentTypes,
   start,
-}
+};

package/src/producer/publish-unpublished-env.js

@@ -4,144 +4,168 @@
 /* eslint-disable no-console */
 /* eslint-disable new-cap */
 /* eslint-disable camelcase */
-const {getQueue} = require('../util/queue')
-const {performBulkPublish, publishEntry, initializeLogger} = require('../consumer/publish')
-const retryFailedLogs = require('../util/retryfailed')
-const {validateFile} = require('../util/fs')
-const {setDelayForBulkPublish} = require('../util')
-const {isEmpty} = require('../util')
+const { getQueue } = require('../util/queue');
+const { performBulkPublish, publishEntry, initializeLogger } = require('../consumer/publish');
+const retryFailedLogs = require('../util/retryfailed');
+const { validateFile } = require('../util/fs');
+const { isEmpty } = require('../util');
 
-const queue = getQueue()
-let skipCount
-let changedFlag = false
-let logFileName = 'publish-unpublished-env'
-let bulkPublishSet = []
-let filePath
+const queue = getQueue();
+let skipCount;
+let changedFlag = false;
+let logFileName = 'publish-unpublished-env';
+let bulkPublishSet = [];
+let filePath;
 
 function setConfig(conf, bp) {
   if (bp) {
-    logFileName = 'bulk-publish-draft'
-    queue.consumer = performBulkPublish
+    logFileName = 'bulk-publish-draft';
+    queue.consumer = performBulkPublish;
   } else {
-    logFileName = 'publish-draft'
-    queue.consumer = publishEntry
+    logFileName = 'publish-draft';
+    queue.consumer = publishEntry;
   }
-  config = conf
-  queue.config = config
-  filePath = initializeLogger(logFileName)
+  config = conf;
+  queue.config = config;
+  filePath = initializeLogger(logFileName);
 }
 
 async function getEnvironment(stack, environmentName) {
   return new Promise((resolve, reject) => {
-    stack.environment(environmentName).fetch()
-    .then(env => {
-      resolve(env)
-    })
-    .catch(error => reject(error))
-  })
+    stack
+      .environment(environmentName)
+      .fetch()
+      .then((env) => {
+        resolve(env);
+      })
+      .catch((error) => reject(error));
+  });
 }
 
 async function getEntries(stack, contentType, environmentUid, locale, bulkPublish, environments, skip = 0) {
   return new Promise((resolve, reject) => {
-    skipCount = skip
+    skipCount = skip;
 
     let queryParams = {
       include_count: true,
       skip: skipCount,
       include_publish_details: true,
-    }
+    };
 
-    stack.contentType(contentType).entry().query(queryParams).find()
-    .then(async responseEntries => {
-      skipCount += responseEntries.items.length
-      if (responseEntries.items.length > 0) {
-        let entries = responseEntries.items
-        for (let index = 0; index < responseEntries.items.length; index++) {
-          // const locale = locale || 'en-us'
-          const publishedEntry = entries[index].publish_details.find(publishEnv => publishEnv.environment === environmentUid && publishEnv.locale === locale)
-          if (!publishedEntry) {
-            changedFlag = true
-            if (bulkPublish) {
-              if (bulkPublishSet.length < 10) {
-                bulkPublishSet.push({
-                  uid: entries[index].uid,
+    stack
+      .contentType(contentType)
+      .entry()
+      .query(queryParams)
+      .find()
+      .then(async (responseEntries) => {
+        skipCount += responseEntries.items.length;
+        if (responseEntries.items.length > 0) {
+          let entries = responseEntries.items;
+          for (let index = 0; index < responseEntries.items.length; index++) {
+            const publishedEntry = entries[index].publish_details.find(
+              (publishEnv) => publishEnv.environment === environmentUid && publishEnv.locale === locale,
+            );
+            if (!publishedEntry) {
+              changedFlag = true;
+              if (bulkPublish) {
+                if (bulkPublishSet.length < 10) {
+                  bulkPublishSet.push({
+                    uid: entries[index].uid,
+                    content_type: contentType,
+                    locale,
+                    publish_details: entries[index].publish_details || [],
+                  });
+                }
+              } else {
+                await queue.Enqueue({
                   content_type: contentType,
+                  publish_details: entries[index].publish_details,
+                  environments: environments,
+                  entryUid: entries[index].uid,
                   locale,
-                  publish_details: entries[index].publish_details || [],
-                })
+                  Type: 'entry',
+                  stack: stack,
+                });
               }
-            } else {
-              await queue.Enqueue({
-                content_type: contentType, publish_details: entries[index].publish_details, environments: environments, entryUid: entries[index].uid, locale, Type: 'entry', stack: stack
-              })
-            }
-          }
-          if (bulkPublish) {
-            if (bulkPublishSet.length === 10) {
-              await queue.Enqueue({
-                entries: bulkPublishSet, locale, Type: 'entry', environments: environments, stack: stack
-              })
-              bulkPublishSet = []
             }
-            if (index === responseEntries.items.length - 1 && bulkPublishSet.length < 10 && bulkPublishSet.length > 0) {
-              await queue.Enqueue({
-                entries: bulkPublishSet, locale, Type: 'entry', environments: environments, stack: stack
-              })
-              bulkPublishSet = []
+            if (bulkPublish) {
+              if (bulkPublishSet.length === 10) {
+                await queue.Enqueue({
+                  entries: bulkPublishSet,
+                  locale,
+                  Type: 'entry',
+                  environments: environments,
+                  stack: stack,
+                });
+                bulkPublishSet = [];
+              }
+              if (
+                index === responseEntries.items.length - 1 &&
+                bulkPublishSet.length < 10 &&
+                bulkPublishSet.length > 0
+              ) {
+                await queue.Enqueue({
+                  entries: bulkPublishSet,
+                  locale,
+                  Type: 'entry',
+                  environments: environments,
+                  stack: stack,
+                });
+                bulkPublishSet = [];
+              }
             }
           }
         }
-      }
-      if (responseEntries.count === skipCount) {
-        if (!changedFlag) console.log(`No Draft Entries of contentType ${contentType} was found`)
-        bulkPublishSet = []
-        return resolve()
-      }
-      await getEntries(stack, contentType, environmentUid, locale, bulkPublish, environments, skipCount)
-      return resolve()
-    })
-    .catch(error => {
-      reject(error)
-    })
-  })
+        if (responseEntries.count === skipCount) {
+          if (!changedFlag) console.log(`No Draft Entries of contentType ${contentType} was found`);
+          bulkPublishSet = [];
+          return resolve();
+        }
+        await getEntries(stack, contentType, environmentUid, locale, bulkPublish, environments, skipCount);
+        return resolve();
+      })
+      .catch((error) => {
+        reject(error);
+      });
+  });
 }
 
-async function start({sourceEnv, environments, locale, contentTypes, bulkPublish, retryFailed}, stack, config) {
+async function start({ sourceEnv, environments, locale, contentTypes, bulkPublish, retryFailed }, stack, config) {
   process.on('beforeExit', async () => {
-    const isErrorLogEmpty = await isEmpty(`${filePath}.error`)
-    const isSuccessLogEmpty = await isEmpty(`${filePath}.success`)
+    const isErrorLogEmpty = await isEmpty(`${filePath}.error`);
+    const isSuccessLogEmpty = await isEmpty(`${filePath}.success`);
     if (!isErrorLogEmpty) {
-      console.log(`The error log for this session is stored at ${filePath}.error`)
+      console.log(`The error log for this session is stored at ${filePath}.error`);
     } else if (!isSuccessLogEmpty) {
-      console.log(`The success log for this session is stored at ${filePath}.success`)
+      console.log(`The success log for this session is stored at ${filePath}.success`);
     }
-    process.exit(0)  
-  })
+    process.exit(0);
+  });
 
   if (retryFailed) {
     if (typeof retryFailed === 'string') {
       if (!validateFile(retryFailed, ['publish-draft', 'bulk-publish-draft'])) {
-        return false
+        return false;
       }
 
-      bulkPublish = retryFailed.match(new RegExp('bulk')) ? true : false
-      setConfig(config, bulkPublish)
+      bulkPublish = retryFailed.match(new RegExp('bulk')) ? true : false;
+      setConfig(config, bulkPublish);
 
       if (bulkPublish) {
-        await retryFailedLogs(retryFailed, queue, 'bulk')
+        await retryFailedLogs(retryFailed, queue, 'bulk');
       } else {
-        await retryFailedLogs(retryFailed, {entryQueue: queue}, 'publish')
+        await retryFailedLogs(retryFailed, { entryQueue: queue }, 'publish');
       }
     }
   } else {
-    setConfig(config, bulkPublish)  
+    setConfig(config, bulkPublish);
     if (sourceEnv) {
-      const environmentDetails = await getEnvironment(stack, sourceEnv)
+      const environmentDetails = await getEnvironment(stack, sourceEnv);
       for (let i = 0; i < contentTypes.length; i += 1) {
         /* eslint-disable no-await-in-loop */
-        await getEntries(stack, contentTypes[i], environmentDetails.uid, locale, bulkPublish, environments)
+        await getEntries(stack, contentTypes[i], environmentDetails.uid, locale, bulkPublish, environments);
         /* eslint-enable no-await-in-loop */
-        changedFlag = false
+        changedFlag = false;
       }
     }
   }
@@ -154,4 +178,4 @@ module.exports = {
   getEnvironment,
   setConfig,
   start,
-}
+};