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

package/src/producer/publish-assets.js

@@ -1,131 +1,137 @@
 /* eslint-disable no-console */
 /* eslint-disable new-cap */
 /* eslint-disable camelcase */
-const {getQueue} = require('../util/queue')
-const {bulkPublish, publishAsset, 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, publishAsset, initializeLogger } = require('../consumer/publish');
+const retryFailedLogs = require('../util/retryfailed');
+const { validateFile } = require('../util/fs');
+const { isEmpty } = require('../util');
 
-const queue = getQueue()
-let logFileName
-let bulkPublishSet = []
-let filePath
+const queue = getQueue();
+let logFileName;
+let bulkPublishSet = [];
+let filePath;
 
 /* eslint-disable no-param-reassign */
 
 async function getAssets(stack, folder, bulkPublish, environments, locale, skip = 0) {
   return new Promise((resolve, reject) => {
-      let queryParams = {
-        folder: folder,
-        skip: skip,
-        include_count: true,
-        include_folders: true,
-        include_publish_details: true,
-      }
-      stack.asset().query(queryParams).find()
-      .then(async assetResponse => {
-      if (assetResponse && assetResponse.items.length > 0) {
-        skip += assetResponse.items.length
-        let assets = assetResponse.items
-        for(let index = 0; index < assetResponse.items.length; index++) {
-          if (assets[index].is_dir === true) {
-            await getAssets(stack, assets[index].uid, bulkPublish, environments, locale, 0)
-            continue;
-          }
-          if (bulkPublish) {
-            if (bulkPublishSet.length < 10) {
-              bulkPublishSet.push({
-                uid: assets[index].uid,
-                locale,
-                publish_details: assets[index].publish_details || [],
-              })
-            }
-            if (bulkPublishSet.length === 10) {
-              await queue.Enqueue({assets: bulkPublishSet, Type: 'asset', environments: environments, locale, stack: stack})
-              bulkPublishSet = []
+    let queryParams = {
+      folder: folder,
+      skip: skip,
+      include_count: true,
+      include_folders: true,
+      include_publish_details: true,
+    };
+    stack
+      .asset()
+      .query(queryParams)
+      .find()
+      .then(async (assetResponse) => {
+        if (assetResponse && assetResponse.items.length > 0) {
+          skip += assetResponse.items.length;
+          let assets = assetResponse.items;
+          for (let index = 0; index < assetResponse.items.length; index++) {
+            if (assets[index].is_dir === true) {
+              await getAssets(stack, assets[index].uid, bulkPublish, environments, locale, 0);
+              continue;
             }
+            if (bulkPublish) {
+              if (bulkPublishSet.length < 10) {
+                bulkPublishSet.push({
+                  uid: assets[index].uid,
+                  locale,
+                  publish_details: assets[index].publish_details || [],
+                });
+              }
+              if (bulkPublishSet.length === 10) {
+                await queue.Enqueue({
+                  assets: bulkPublishSet,
+                  Type: 'asset',
+                  environments: environments,
+                  locale,
+                  stack: stack,
+                });
+                bulkPublishSet = [];
+              }
 
-            if (assetResponse.items.length - 1 === index && bulkPublishSet.length > 0 && bulkPublishSet.length < 10) {
-              await queue.Enqueue({assets: bulkPublishSet, Type: 'asset', environments: environments, locale, stack: stack})
-              bulkPublishSet = []
+              if (assetResponse.items.length - 1 === index && bulkPublishSet.length > 0 && bulkPublishSet.length < 10) {
+                await queue.Enqueue({
+                  assets: bulkPublishSet,
+                  Type: 'asset',
+                  environments: environments,
+                  locale,
+                  stack: stack,
+                });
+                bulkPublishSet = [];
+              }
+            } else {
+              await queue.Enqueue({
+                assetUid: assets[index].uid,
+                publish_details: assets[index].publish_details || [],
+                environments: environments,
+                Type: 'asset',
+                locale,
+                stack: stack,
+              });
             }
-          } else {
-            await queue.Enqueue({
-              assetUid: assets[index].uid, publish_details: assets[index].publish_details || [], environments: environments, Type: 'asset', locale, stack: stack
-            })
           }
-          // return resolve()
-        }
-        if (skip === assetResponse.count) {
-          return resolve(true)
+          if (skip === assetResponse.count) {
+            return resolve(true);
+          }
+          await getAssets(stack, folder, bulkPublish, environments, locale, skip);
+          return resolve();
         }
-        await getAssets(stack, folder, bulkPublish, environments, locale, skip)
-        return resolve()
-      } else {
-        // throw new Error(JSON.stringify({errorMessage: "No Assets found"}))
-      }
-    })
-      .catch(error => {
-        reject(error)
       })
-  })
-  
-  return true
+      .catch((error) => {
+        reject(error);
+      });
+  });
 }
 
 function setConfig(conf, bp) {
   if (bp) {
-    queue.consumer = bulkPublish
-    logFileName = 'bulk-publish-assets'
+    queue.consumer = performBulkPublish;
+    logFileName = 'bulk-publish-assets';
   } else {
-    queue.consumer = publishAsset
-    logFileName = 'publish-assets'
+    queue.consumer = publishAsset;
+    logFileName = 'publish-assets';
   }
-  config = conf
-  queue.config = conf
-  filePath = initializeLogger(logFileName)
+  config = conf;
+  queue.config = conf;
+  filePath = initializeLogger(logFileName);
 }
 
-async function start({retryFailed, bulkPublish, environments, folderUid, locales}, stack, config) {
+async function start({ retryFailed, bulkPublish, environments, folderUid, locales }, 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);
+  });
 
-  try {
-    if (retryFailed) {
-      if (!validateFile(retryFailed, ['publish-assets', 'bulk-publish-assets'])) {
-        return false
-      }
+  if (retryFailed) {
+    if (!validateFile(retryFailed, ['publish-assets', 'bulk-publish-assets'])) {
+      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')
-      } else {
-        await retryFailedLogs(retryFailed, {assetQueue: queue}, 'publish')
-      }
-    } else if (folderUid) {
-      setConfig(config, bulkPublish)
-      for (let loc = 0; loc < locales.length; loc += 1) {
-        try {
-          await getAssets(stack, folderUid, bulkPublish, environments, locales[loc])
-        } catch(error) {
-          throw error
-        }
-      }
+    if (bulkPublish) {
+      await retryFailedLogs(retryFailed, queue, 'bulk');
+    } else {
+      await retryFailedLogs(retryFailed, { assetQueue: queue }, 'publish');
+    }
+  } else if (folderUid) {
+    setConfig(config, bulkPublish);
+    for (const element of locales) {
+      await getAssets(stack, folderUid, bulkPublish, environments, element);
     }
-  } catch (error) {
-    throw error
   }
 }
 
@@ -133,4 +139,4 @@ module.exports = {
   getAssets,
   setConfig,
   start,
-}
+};

package/src/producer/publish-edits.js

@@ -4,163 +4,176 @@
 /* eslint-disable no-console */
 /* eslint-disable max-params */
 /* eslint-disable camelcase */
-const {getQueue} = require('../util/queue')
-const {bulkPublish, 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 { setDelayForBulkPublish } = require('../util');
+const { isEmpty } = require('../util');
 
-let skipCount
-const queue = getQueue()
-let changedFlag = false
-let bulkPublishSet = []
-let logFileName
-let filePath
+let skipCount;
+const queue = getQueue();
+let changedFlag = false;
+let bulkPublishSet = [];
+let logFileName;
+let filePath;
 
 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,
       locale,
-    }
+    };
 
-    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 && publishedEntry.version < entries[index]._version) {
-            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 && publishedEntry.version < entries[index]._version) {
+              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,
-                  locale,
                   publish_details: entries[index].publish_details || [],
-                })
+                  environments: environments,
+                  entryUid: entries[index].uid,
+                  locale,
+                  Type: 'entry',
+                  stack: stack,
+                });
               }
-            } else {
+            }
+            if (bulkPublishSet.length === 10) {
               await queue.Enqueue({
-                content_type: contentType, publish_details: entries[index].publish_details || [], environments: environments, entryUid: entries[index].uid, locale, Type: 'entry', stack: stack
-              })
+                entries: bulkPublishSet,
+                locale,
+                Type: 'entry',
+                environments: environments,
+                stack: stack,
+              });
+              bulkPublishSet = [];
+            }
+            if (
+              index === responseEntries.items.length - 1 &&
+              bulkPublishSet.length > 0 &&
+              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 === responseEntries.items.length - 1 && bulkPublishSet.length > 0 && bulkPublishSet.length <= 10) {
-            await queue.Enqueue({
-              entries: bulkPublishSet, locale, Type: 'entry', environments: environments, stack: stack
-            })
-            bulkPublishSet = []
           }
         }
-      }
-      if (responseEntries.count === skipCount) {
-        if (!changedFlag) console.log(`No Edits Were observed on specified Environment for contentType ${contentType}`)
-        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 Edits Were observed on specified Environment for contentType ${contentType}`);
+          bulkPublishSet = [];
+          return resolve();
+        }
+        await getEntries(stack, contentType, environmentUid, locale, bulkPublish, environments, skipCount);
+        return resolve();
+      })
+      .catch((error) => {
+        reject(error);
+      });
+  });
 }
 
 function setConfig(conf, bp) {
   if (bp) {
-    logFileName = 'bulk-publish-edits'
-    queue.consumer = bulkPublish
+    logFileName = 'bulk-publish-edits';
+    queue.consumer = performBulkPublish;
   } else {
-    logFileName = 'publish-edits'
-    queue.consumer = publishEntry
+    logFileName = 'publish-edits';
+    queue.consumer = publishEntry;
   }
-  config = conf
-  queue.config = config
-  filePath = initializeLogger(logFileName)
+  config = conf;
+  queue.config = config;
+  filePath = initializeLogger(logFileName);
 }
 
-async function start({retryFailed, bulkPublish, sourceEnv, contentTypes, locales, environments}, stack, config) {
+async function start({ retryFailed, bulkPublish, sourceEnv, 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);
+  });
 
-  try {
-    if (retryFailed) {
-      if (typeof retryFailed === 'string') {
-        if (!validateFile(retryFailed, ['publish-edits', 'bulk-publish-edits'])) {
-          return false
-        }
-        
-        bulkPublish = retryFailed.match(new RegExp('bulk')) ? true : false
-        setConfig(config, bulkPublish)
+  if (retryFailed) {
+    if (typeof retryFailed === 'string') {
+      if (!validateFile(retryFailed, ['publish-edits', 'bulk-publish-edits'])) {
+        return false;
+      }
 
-        if (bulkPublish) {
-          await retryFailedLogs(retryFailed, queue, 'bulk')
-        } else {
-          await retryFailedLogs(retryFailed, {entryQueue: queue}, 'publish')
-        }
+      bulkPublish = retryFailed.match(new RegExp('bulk')) ? true : false;
+      setConfig(config, bulkPublish);
+
+      if (bulkPublish) {
+        await retryFailedLogs(retryFailed, queue, 'bulk');
+      } else {
+        await retryFailedLogs(retryFailed, { entryQueue: queue }, 'publish');
       }
-    } else if (sourceEnv) {
-      setConfig(config, bulkPublish)
-      try {
-        const environmentDetails = await getEnvironment(stack, sourceEnv)
-        for (let i = 0; i < contentTypes.length; i += 1) {
-          for (let j = 0; j < locales.length; j += 1) {
-            try {
-              /* eslint-disable no-await-in-loop */
-              await getEntries(stack, contentTypes[i], environmentDetails.uid, locales[j], bulkPublish, environments)
-              /* eslint-enable no-await-in-loop */
-            } catch (error) {
-              throw error
-            }
-          }
-        }
-      } catch (error) {
-        throw error
+    }
+  } else if (sourceEnv) {
+    setConfig(config, bulkPublish);
+    const environmentDetails = await getEnvironment(stack, sourceEnv);
+    for (let i = 0; i < contentTypes.length; i += 1) {
+      for (let j = 0; j < locales.length; j += 1) {
+        /* eslint-disable no-await-in-loop */
+        await getEntries(stack, contentTypes[i], environmentDetails.uid, locales[j], bulkPublish, environments);
+        /* eslint-enable no-await-in-loop */
       }
     }
-  } catch(error) {
-    throw error
   }
 }
 
-// start();
-
 module.exports = {
   getEntries,
   getEnvironment,
   setConfig,
   start,
-}
+};