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

package/src/producer/unpublish.js

@@ -3,80 +3,65 @@
 /* eslint-disable complexity */
 /* eslint-disable no-console */
 /* eslint-disable camelcase */
-const {getQueue} = require('../util/queue')
-const defaults = require('../config/defaults.json')
-const req = require('../util/request')
-const {
-  bulkUnPublish, UnpublishEntry, UnpublishAsset, initializeLogger,
-} = require('../consumer/publish')
-const retryFailedLogs = require('../util/retryfailed')
-const {validateFile} = require('../util/fs')
-const queue = getQueue()
-const entryQueue = getQueue()
-const assetQueue = getQueue()
-const {setDelayForBulkPublish} = require('../util')
-const {Command} = require('@contentstack/cli-command')
-const command = new Command()
-const {isEmpty} = require('../util')
-
-let bulkUnPublishSet = []
-let bulkUnPulishAssetSet = []
-let logFileName
-let filePath
+const { getQueue } = require('../util/queue');
+const defaults = require('../config/defaults.json');
+const { performBulkUnPublish, UnpublishEntry, UnpublishAsset, initializeLogger } = require('../consumer/publish');
+const retryFailedLogs = require('../util/retryfailed');
+const { validateFile } = require('../util/fs');
+const queue = getQueue();
+const entryQueue = getQueue();
+const assetQueue = getQueue();
+const { Command } = require('@contentstack/cli-command');
+const command = new Command();
+const { isEmpty } = require('../util');
+
+let bulkUnPublishSet = [];
+let bulkUnPulishAssetSet = [];
+let logFileName;
+let filePath;
 
 function setConfig(conf, bup) {
   if (bup) {
-    logFileName = 'bulk-unpublish'
-    queue.consumer = bulkUnPublish
+    logFileName = 'bulk-unpublish';
+    queue.consumer = performBulkUnPublish;
   } else {
-    logFileName = 'unpublish'
-    entryQueue.consumer = UnpublishEntry
-    assetQueue.consumer = UnpublishAsset
+    logFileName = 'unpublish';
+    entryQueue.consumer = UnpublishEntry;
+    assetQueue.consumer = UnpublishAsset;
   }
-  config = conf
-  queue.config = conf
-  entryQueue.config = conf
-  assetQueue.config = conf
-  filePath = initializeLogger(logFileName)
+  config = conf;
+  queue.config = conf;
+  entryQueue.config = conf;
+  assetQueue.config = conf;
+  filePath = initializeLogger(logFileName);
 }
 
-let changedFlag = false
+let changedFlag = false;
 
 function getQueryParams(filter) {
-  let queryString = ''
-  Object.keys(filter).forEach(key => {
+  let queryString = '';
+  Object.keys(filter).forEach((key) => {
     if (filter[key]) {
-      queryString = `${queryString}&${key}=${filter[key]}`
+      queryString = `${queryString}&${key}=${filter[key]}`;
     }
-  })
+  });
 
-  return queryString
+  return queryString;
 }
 
 function bulkAction(stack, items, bulkUnpublish, environment, locale) {
-  return new Promise(async resolve => {
+  return new Promise(async (resolve) => {
     for (let index = 0; index < items.length; index++) {
-      changedFlag = true
-
-      if (!items[index].data.publish_details) {
-        // adding this condition because sometimes
-        // item.data.publish_details.locale failes because publish_details is undefined
-        items[index].data.publish_details = {}
-      }
-
-      if (items[index].data.publish_details) {
-        items[index].data.publish_details.version = items[index].data._version
-      }
+      changedFlag = true;
 
       if (bulkUnpublish) {
         if (bulkUnPublishSet.length < 10 && items[index].type === 'entry_published') {
           bulkUnPublishSet.push({
             uid: items[index].data.uid,
             content_type: items[index].content_type_uid,
-            locale: items[index].data.publish_details.locale || 'en-us',
-            version: items[index].data._version,
+            locale: items[index].data.locale || 'en-us',
             publish_details: [items[index].data.publish_details] || [],
-          })
+          });
         }
 
         if (bulkUnPulishAssetSet.length < 10 && items[index].type === 'asset_published') {
@@ -84,138 +69,191 @@ function bulkAction(stack, items, bulkUnpublish, environment, locale) {
             uid: items[index].data.uid,
             version: items[index].data._version,
             publish_details: [items[index].data.publish_details] || [],
-          })
+          });
         }
 
         if (bulkUnPulishAssetSet.length === 10) {
           await queue.Enqueue({
-            assets: bulkUnPulishAssetSet, Type: 'asset', locale: locale, environments: [environment], stack: stack
-          })
-          bulkUnPulishAssetSet = []
+            assets: bulkUnPulishAssetSet,
+            Type: 'asset',
+            locale: locale,
+            environments: [environment],
+            stack: stack,
+          });
+          bulkUnPulishAssetSet = [];
         }
 
         if (bulkUnPublishSet.length === 10) {
           await queue.Enqueue({
-            entries: bulkUnPublishSet, locale: locale, Type: 'entry', environments: [environment], stack: stack
-          })
-          bulkUnPublishSet = []
+            entries: bulkUnPublishSet,
+            locale: locale,
+            Type: 'entry',
+            environments: [environment],
+            stack: stack,
+          });
+          bulkUnPublishSet = [];
         }
         if (index === items.length - 1 && bulkUnPulishAssetSet.length <= 10 && bulkUnPulishAssetSet.length > 0) {
           await queue.Enqueue({
-            assets: bulkUnPulishAssetSet, Type: 'asset', locale: locale, environments: [environment], stack: stack
-          })
-          bulkUnPulishAssetSet = []
+            assets: bulkUnPulishAssetSet,
+            Type: 'asset',
+            locale: locale,
+            environments: [environment],
+            stack: stack,
+          });
+          bulkUnPulishAssetSet = [];
         }
 
         if (index === items.length - 1 && bulkUnPublishSet.length <= 10 && bulkUnPublishSet.length > 0) {
           await queue.Enqueue({
-            entries: bulkUnPublishSet, locale: locale, Type: 'entry', environments: [environment], stack: stack
-          })
-          bulkUnPublishSet = []
+            entries: bulkUnPublishSet,
+            locale: locale,
+            Type: 'entry',
+            environments: [environment],
+            stack: stack,
+          });
+          bulkUnPublishSet = [];
         }
       } else {
         if (items[index].type === 'entry_published') {
           await entryQueue.Enqueue({
-            content_type: items[index].content_type_uid, publish_details: [items[index].data.publish_details], environments: [environment], entryUid: items[index].data.uid, locale: items[index].data.publish_details.locale || 'en-us', Type: 'entry', stack: stack
-          })
+            content_type: items[index].content_type_uid,
+            publish_details: [items[index].data.publish_details],
+            environments: [environment],
+            entryUid: items[index].data.uid,
+            locale: items[index].data.locale || 'en-us',
+            Type: 'entry',
+            stack: stack,
+          });
         }
         if (items[index].type === 'asset_published') {
           await assetQueue.Enqueue({
-            assetUid: items[index].data.uid, publish_details: [items[index].data.publish_details], environments: [environment], Type: 'entry', stack: stack
-          })
+            assetUid: items[index].data.uid,
+            publish_details: [items[index].data.publish_details],
+            environments: [environment],
+            Type: 'entry',
+            stack: stack,
+          });
         }
       }
     }
-    return resolve()
-  })
+    return resolve();
+  });
 }
 
-async function getSyncEntries(stack, config, locale, queryParams, bulkUnpublish, environment, deliveryToken, paginationToken = null) {
+async function getSyncEntries(
+  stack,
+  config,
+  locale,
+  queryParams,
+  bulkUnpublish,
+  environment,
+  deliveryToken,
+  paginationToken = null,
+) {
   return new Promise(async (resolve, reject) => {
     try {
-      let tokenDetails = command.getToken(config.alias)
-      const conf = {
-        uri: `${config.cda}/v${defaults.apiVersion}/stacks/sync?${paginationToken ? `pagination_token=${paginationToken}` : 'init=true'}${queryParams}`,
-        headers: {
-          api_key: tokenDetails.apiKey,
-          access_token: deliveryToken,
-        },
+      const tokenDetails = command.getToken(config.alias);
+      const queryParamsObj = {};
+      const pairs = queryParams.split('&');
+      for (let i in pairs) {
+        const split = pairs[i].split('=');
+        queryParamsObj[decodeURIComponent(split[0])] = decodeURIComponent(split[1]);
       }
-      const entriesResponse = await req(conf)
+
+      const Stack = new command.deliveryAPIClient.Stack({
+        api_key: tokenDetails.apiKey,
+        delivery_token: deliveryToken,
+        environment: queryParamsObj.environment,
+        branch: config.branch,
+      });
+
+      const syncData = {};
+
+      if (paginationToken) {
+        syncData['pagination_token'] = paginationToken;
+      } else {
+        syncData['init'] = true;
+      }
+      if (queryParamsObj.locale) {
+        syncData['locale'] = queryParamsObj.locale;
+      }
+      if (queryParamsObj.type) {
+        syncData['type'] = queryParamsObj.type;
+      }
+
+      const entriesResponse = await Stack.sync(syncData);
+
       if (entriesResponse.items.length > 0) {
-        await bulkAction(stack, entriesResponse.items, bulkUnpublish, environment, locale)
+        await bulkAction(stack, entriesResponse.items, bulkUnpublish, environment, locale);
       }
       if (entriesResponse.items.length === 0) {
-        if (!changedFlag) console.log('No Entries/Assets Found published on specified environment')
-        return resolve()
+        if (!changedFlag) console.log('No Entries/Assets Found published on specified environment');
+        return resolve();
       }
       setTimeout(async () => {
-        await getSyncEntries(stack, config, locale, queryParams, bulkUnpublish, environment, deliveryToken, null)
-      }, 3000)
+        await getSyncEntries(stack, config, locale, queryParams, bulkUnpublish, environment, deliveryToken, null);
+      }, 3000);
     } catch (error) {
-      reject(error)
+      reject(error);
     }
-  })
-  return resolve()
+  });
 }
 
-async function start({retryFailed, bulkUnpublish, contentType, locale, environment, deliveryToken, onlyAssets, onlyEntries, f_types}, stack, config) {
+async function start(
+  { retryFailed, bulkUnpublish, contentType, locale, environment, deliveryToken, onlyAssets, onlyEntries, f_types },
+  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)  
-  })
-
-  try {
-    if (retryFailed) {
-      if (typeof retryFailed === 'string' && retryFailed.length > 0) {
-        if (!validateFile(retryFailed, ['unpublish', 'bulk-unpublish'])) {
-          return false
-        }
+    process.exit(0);
+  });
 
-        bulkUnpublish = retryFailed.match(new RegExp('bulk')) ? true : false
-        setConfig(config, bulkUnpublish)
-
-        if (bulkUnpublish) {
-          await retryFailedLogs(retryFailed, queue, 'bulk')
-        } else {
-          await retryFailedLogs(retryFailed, {entryQueue, assetQueue}, 'publish')
-        }
-      }
-    } else {
-      let filter = {
-        environment,
-        locale,
-      }
-      if (f_types)
-        filter.type = f_types
-      // filter.type = (f_types) ? f_types : types // types mentioned in the config file (f_types) are given preference
-      if (contentType) {
-        filter.content_type_uid = contentType
-        filter.type = 'entry_published'
+  if (retryFailed) {
+    if (typeof retryFailed === 'string' && retryFailed.length > 0) {
+      if (!validateFile(retryFailed, ['unpublish', 'bulk-unpublish'])) {
+        return false;
       }
-      if (onlyAssets) {
-        filter.type = 'asset_published'
-        delete filter.content_type_uid
-      }
-      if (onlyEntries) {
-        filter.type = 'entry_published'
-      }
-      setConfig(config, bulkUnpublish)
-      const queryParams = getQueryParams(filter)
-      try {
-        await getSyncEntries(stack, config, locale, queryParams, bulkUnpublish, environment, deliveryToken)
-      } catch (error) {
-        throw error
+
+      bulkUnpublish = retryFailed.match(new RegExp('bulk')) ? true : false;
+      setConfig(config, bulkUnpublish);
+
+      if (bulkUnpublish) {
+        await retryFailedLogs(retryFailed, queue, 'bulk');
+      } else {
+        await retryFailedLogs(retryFailed, { entryQueue, assetQueue }, 'publish');
       }
     }
-  } catch (error) {
-    throw error
+  } else {
+    let filter = {
+      environment,
+      locale,
+    };
+    if (f_types) {
+      filter.type = f_types;
+    }
+    // filter.type = (f_types) ? f_types : types // types mentioned in the config file (f_types) are given preference
+    if (contentType) {
+      filter.content_type_uid = contentType;
+      filter.type = 'entry_published';
+    }
+    if (onlyAssets) {
+      filter.type = 'asset_published';
+      delete filter.content_type_uid;
+    }
+    if (onlyEntries) {
+      filter.type = 'entry_published';
+    }
+    setConfig(config, bulkUnpublish);
+    const queryParams = getQueryParams(filter);
+    await getSyncEntries(stack, config, locale, queryParams, bulkUnpublish, environment, deliveryToken);
   }
 }
 
@@ -226,4 +264,4 @@ module.exports = {
   setConfig,
   getQueryParams,
   start,
-}
+};

package/src/services/publish-only-unpublished.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const { cliux } = require('@contentstack/cli-utilities');
+
+const { start } = require('../producer/publish-unpublished-env');
+const { prettyPrint, formatError } = require('../util');
+const { getStack } = require('../util/client');
+const store = require('../util/store');
+
+const configKey = 'publish_unpublished_env';
+
+async function publishOnlyUnpublishedService(UnpublishedEntriesCommand) {
+  let config;
+  const unpublishedEntriesFlags = flagsAdapter(this.parse(UnpublishedEntriesCommand).flags);
+  let updatedFlags;
+  try {
+    updatedFlags = unpublishedEntriesFlags.config
+      ? store.updateMissing(configKey, unpublishedEntriesFlags)
+      : unpublishedEntriesFlags;
+  } catch (error) {
+    this.error(error.message, { exit: 2 });
+  }
+  if (validate.apply(this, [updatedFlags])) {
+    let stack;
+    if (!updatedFlags.retryFailed) {
+      if (!updatedFlags.alias) {
+        updatedFlags.alias = await cliux.prompt('Please enter the management token alias to be used');
+      }
+      updatedFlags.bulkPublish = updatedFlags.bulkPublish === 'false' ? false : true;
+      // Validate management token alias.
+      try {
+        this.getToken(updatedFlags.alias);
+      } catch (error) {
+        this.error(
+          `The configured management token alias ${updatedFlags.alias} has not been added yet. Add it using 'csdx auth:tokens:add -a ${updatedFlags.alias}'`,
+          { exit: 2 },
+        );
+      }
+      config = {
+        alias: updatedFlags.alias,
+        host: this.region.cma,
+        branch: unpublishedEntriesFlags.branch,
+      };
+      stack = getStack(config);
+    }
+    if (await confirmFlags(updatedFlags)) {
+      try {
+        if (!updatedFlags.retryFailed) {
+          await start(updatedFlags, stack, config);
+        } else {
+          await start(updatedFlags);
+        }
+      } catch (error) {
+        let message = formatError(error);
+        this.error(message, { exit: 2 });
+      }
+    } else {
+      this.exit(0);
+    }
+  }
+}
+
+function validate({ contentTypes, environments, sourceEnv, locale, retryFailed }) {
+  let missing = [];
+  if (retryFailed) {
+    return true;
+  }
+
+  if (!contentTypes || contentTypes.length === 0) {
+    missing.push('Content Types');
+  }
+
+  if (!sourceEnv) {
+    missing.push('SourceEnv');
+  }
+
+  if (!environments || environments.length === 0) {
+    missing.push('Environments');
+  }
+
+  if (!locale) {
+    missing.push('Source Locale');
+  }
+
+  if (missing.length > 0) {
+    this.error(`${missing.join(', ')} are required for processing this command. Please check --help for more details`, {
+      exit: 2,
+    });
+  } else {
+    return true;
+  }
+}
+
+async function confirmFlags(data) {
+  prettyPrint(data);
+  if (data.yes) {
+    return true;
+  }
+  return cliux.confirm('Do you want to continue with this configuration ? [yes or no]');
+}
+
+function flagsAdapter(flags) {
+  if ('content-types' in flags) {
+    flags.contentTypes = flags['content-types'];
+    delete flags['content-types'];
+  }
+  if ('locales' in flags) {
+    flags.locale = flags.locales;
+    delete flags['locales'];
+  }
+  if ('source-env' in flags) {
+    flags.sourceEnv = flags['source-env'];
+    delete flags['source-env'];
+  }
+  if ('retry-failed' in flags) {
+    flags.retryFailed = flags['retry-failed'];
+    delete flags['retry-failed'];
+  }
+  if ('bulk-publish' in flags) {
+    flags.bulkPublish = flags['bulk-publish'];
+    delete flags['bulk-publish'];
+  }
+  return flags;
+}
+
+module.exports = {
+  publishOnlyUnpublishedService,
+  validate,
+  confirmFlags,
+};

package/src/util/client.js

@@ -1,23 +1,27 @@
-const contentstackSdk = require('@contentstack/management')
-const {Command} = require('@contentstack/cli-command')
-const command = new Command()
+const contentstackSdk = require('@contentstack/management');
+const { Command } = require('@contentstack/cli-command');
+const command = new Command();
 
-const Configstore = require('configstore')
-const config = new Configstore('contentstack_cli')
-const { formatHostname } = require('../util')
+const { formatHostname } = require('../util');
 
 function getStack(data) {
-	const tokenDetails = command.getToken(data.alias)
-	const client = contentstackSdk.client({
-		host: formatHostname(data.host),
-		logHandler: (level, data) => {}
-	})
-	const stack = client.stack({api_key: tokenDetails.apiKey, management_token: tokenDetails.token})
-	stack.alias = data.alias
-	stack.host = data.host
-	return stack
+  const tokenDetails = command.getToken(data.alias);
+  const client = contentstackSdk.client({
+    headers: {
+      branch: data.branch,
+    },
+    host: formatHostname(data.host),
+    // eslint-disable-next-line no-unused-vars
+    logHandler: (_level) => {
+      // empty block
+    },
+  });
+  const stack = client.stack({ api_key: tokenDetails.apiKey, management_token: tokenDetails.token });
+  stack.alias = data.alias;
+  stack.host = data.host;
+  return stack;
 }
 
 module.exports = {
-  getStack
-}
+  getStack,
+};

package/src/util/command-helper.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const inquirer = require('inquirer');
+
+const COMMAND_CODE_MAP = {
+  'Publish Entries': 0,
+  'Publish Assets': 1,
+  'Publish Entries and Assets': 2,
+};
+
+const getSelectedCommand = async () => {
+  const inquirerOptions = [{
+    type: 'list',
+    message: 'Choose one of the following task to execute.',
+    choices: Object.keys(COMMAND_CODE_MAP),
+    name: 'selectedOption',
+    loop: false,
+  }];
+  const { selectedOption } = await inquirer.prompt(inquirerOptions);
+  return COMMAND_CODE_MAP[selectedOption];
+};
+
+module.exports = {
+  getSelectedCommand,
+};

package/src/util/fs.js

@@ -1,7 +1,7 @@
 const fs = require('fs');
 const chalk = require('chalk');
 const path = require('path');
-const {getLogsDirPath} = require('../util/logger.js')
+const { getLogsDirPath } = require('../util/logger.js');
 
 const logsDir = getLogsDirPath();
 
@@ -12,7 +12,7 @@ function doesFileExistInLogsDirectory(filename) {
   if (files.indexOf(filename) !== -1) {
     return true;
   }
-  throw new Error(`${filename} doesn't exist in logs directory at ${logsDir}`)
+  throw new Error(`${filename} doesn't exist in logs directory at ${logsDir}`);
 }
 
 function validateFile(filename, types) {
@@ -20,11 +20,11 @@ function validateFile(filename, types) {
     const [timestamp, logType, status] = filename.split('.');
 
     if (!timestamp || !logType || !status) {
-      throw new Error(`${filename} is not a valid log file or the log name has been changed`)
+      throw new Error(`${filename} is not a valid log file or the log name has been changed`);
     }
 
     if (status !== 'success' && status !== 'error') {
-      throw new Error(`${filename} is not a valid log file or the log name has been changed`)
+      throw new Error(`${filename} is not a valid log file or the log name has been changed`);
     }
 
     if (logType) {
@@ -48,19 +48,18 @@ function validateFile(filename, types) {
         case 'unpublish':
         case 'revert':
           if (types && types.length > 0) {
-
-            if(status !=='error') {
-              throw new Error('Error: The given log file is not an error log file.')
+            if (status !== 'error') {
+              throw new Error('Error: The given log file is not an error log file.');
             }
 
-            if(types.indexOf(logType) === -1) {
-              let validTypes = '' + types.join(', ')
-              throw new Error(`For this operation, the log file should be of the following types: ${validTypes}`)
+            if (types.indexOf(logType) === -1) {
+              let validTypes = '' + types.join(', ');
+              throw new Error(`For this operation, the log file should be of the following types: ${validTypes}`);
             }
           }
           return true;
         default:
-          throw new Error(`${filename} is not a valid log file or the log name has been changed`)
+          throw new Error(`${filename} is not a valid log file or the log name has been changed`);
       }
     }
   }