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

package/src/commands/cm/entries/publish.js

@@ -0,0 +1,254 @@
+/* eslint-disable no-console */
+/* eslint-disable node/no-extraneous-require */
+const { Command, flags } = require('@contentstack/cli-command');
+const { start: startPublish } = require('../../../producer/publish-entries');
+const { start: startCrossPublish } = require('../../../producer/cross-publish');
+const store = require('../../../util/store.js');
+const { cliux } = require('@contentstack/cli-utilities');
+const configKey = 'publish_entries';
+const configKeyCrossEnv = 'cross_env_publish';
+const { prettyPrint, formatError } = require('../../../util');
+const { getStack } = require('../../../util/client.js');
+const { printFlagDeprecation } = require('@contentstack/cli-utilities');
+let config;
+
+class PublishEntriesCommand extends Command {
+  async run() {
+    const entriesFlags = this.parse(PublishEntriesCommand).flags;
+    entriesFlags.retryFailed = entriesFlags['retry-failed'] || entriesFlags.retryFailed || false;
+    entriesFlags.contentTypes = entriesFlags['content-types'] || entriesFlags.contentTypes;
+    entriesFlags.bulkPublish = entriesFlags['bulk-publish'] || entriesFlags.bulkPublish;
+    entriesFlags.publishAllContentTypes = entriesFlags['publish-all-content-types'] || entriesFlags.publishAllContentTypes || false;
+    delete entriesFlags['retry-failed'];
+    delete entriesFlags['content-types'];
+    delete entriesFlags['bulk-publish'];
+    delete entriesFlags['publish-all-content-types'];
+
+    let updatedFlags;
+    try {
+      const storeConfigKey = entriesFlags['source-env'] ? configKeyCrossEnv : configKey
+      updatedFlags = entriesFlags.config ? store.updateMissing(storeConfigKey, entriesFlags) : entriesFlags;
+    } catch (error) {
+      this.error(error.message, { exit: 2 });
+    }
+    if (this.validate(updatedFlags)) {
+      let stack;
+      if (!updatedFlags.retryFailed) {
+        if (!updatedFlags.alias) {
+          updatedFlags.alias = await cliux.prompt('Provide the alias of the management token to use');
+        }
+        updatedFlags.bulkPublish = updatedFlags.bulkPublish !== 'false';
+        // 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,
+          cda: this.region.cda,
+          branch: entriesFlags.branch,
+        };
+        stack = getStack(config);
+      }
+      if (await this.confirmFlags(updatedFlags)) {
+        try {
+
+          const publishFunction = async (func) => {
+            // eslint-disable-next-line no-negated-condition
+            if (!updatedFlags.retryFailed) {
+              await func(updatedFlags, stack, config);
+            } else {
+              await func(updatedFlags);
+            }
+          }
+
+          if (updatedFlags['source-env']) {
+            updatedFlags.deliveryToken = updatedFlags['delivery-token']
+            updatedFlags.destEnv = updatedFlags.environments
+            updatedFlags.environment = updatedFlags['source-env']
+            updatedFlags.onlyEntries = true
+            if (updatedFlags.locales instanceof Array) {
+              updatedFlags.locales.forEach(locale => {
+                updatedFlags.locale = locale
+                publishFunction(startCrossPublish)
+              });
+            } else {
+              updatedFlags.locale = locales
+              publishFunction(startCrossPublish)
+            }
+
+          }
+          else {
+            publishFunction(startPublish)
+          }
+
+        } catch (error) {
+          let message = formatError(error);
+          this.error(message, { exit: 2 });
+        }
+      } else {
+        this.exit(0);
+      }
+    }
+  }
+
+  validate({ contentTypes, locales, environments, retryFailed, publishAllContentTypes, 'source-env': sourceEnv, 'delivery-token': deliveryToken }) {
+    let missing = [];
+    if (retryFailed) {
+      return true;
+    }
+
+    if (sourceEnv && !deliveryToken) {
+      this.error(
+        'Specify source environment delivery token. Please check --help for more details',
+        { exit: 2 },
+      );
+    }
+
+    if (publishAllContentTypes && contentTypes && contentTypes.length > 0) {
+      this.error(
+        'Do not specify contentTypes when publishAllContentTypes flag is set. Please check --help for more details',
+        { exit: 2 },
+      );
+    }
+
+    if ((!contentTypes || contentTypes.length === 0) && !publishAllContentTypes) {
+      missing.push('Content Types');
+    }
+
+    if (!locales || locales.length === 0) {
+      missing.push('Locales');
+    }
+
+    if (!environments || environments.length === 0) {
+      missing.push('Environments');
+    }
+
+    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 confirmFlags(data) {
+    prettyPrint(data);
+
+    if (data.yes) {
+      return true;
+    }
+
+    return cliux.confirm('Do you want to continue with this configuration ? [yes or no]');
+  }
+}
+
+PublishEntriesCommand.description = `Publish entries from multiple contenttypes to multiple environments and locales
+The publish command is used to publish entries from the specified content types, to the
+specified environments and locales 
+
+Note: Content Types, Environments and Locales are required to execute the command successfully
+But, if retry-failed flag is set, then only a logfile is required
+`;
+
+PublishEntriesCommand.flags = {
+  alias: flags.string({ char: 'a', description: 'Alias(name) for the management token' }),
+  retryFailed: flags.string({
+    char: 'r',
+    description:
+      'Retry failed entries from the logfile (optional, overrides all other flags) This flag is used to retry publishing entries that failed to publish in a previous attempt. A log file for the previous session will be required for processing the failed entries',
+    hidden: true,
+    parse: printFlagDeprecation(['-r', '--retryFailed'], ['--retry-failed']),
+  }),
+  'retry-failed': flags.string({
+    description:
+      '(optional) Retry failed entries from the logfile (overrides all other flags) This flag is used to retry publishing entries that failed to publish in a previous attempt. A log file for the previous session will be required for processing the failed entries',
+  }),
+  bulkPublish: flags.string({
+    char: 'b',
+    description:
+      "This flag is set to true by default. It indicates that contentstack's bulkpublish API will be used to publish the entries",
+    hidden: true,
+    parse: printFlagDeprecation(['-b', '--bulkPublish'], ['--bulk-publish']),
+  }),
+  'bulk-publish': flags.string({
+    description:
+      "This flag is set to true by default. It indicates that contentstack's bulkpublish API will be used to publish the entries",
+    default: 'true',
+  }),
+  'publish-all-content-types': flags.boolean({
+    description: '(optional) Publish all contenttypes (cannot be set when contentTypes flag is set)',
+  }),
+  publishAllContentTypes: flags.boolean({
+    char: 'o',
+    description: 'Publish all content-types (optional, cannot be set when contentTypes flag is set)',
+    hidden: true,
+    parse: printFlagDeprecation(['-o', '--publishAllContentTypes'], ['--publish-all-content-types']),
+  }),
+  'content-types': flags.string({
+    description: 'The Contenttypes from which entries need to be published',
+    multiple: true,
+  }),
+  contentTypes: flags.string({
+    char: 't',
+    description: 'The Contenttypes from which entries will be published',
+    multiple: true,
+    parse: printFlagDeprecation(['-t', '--contentTypes'], ['--content-types']),
+    hidden: true,
+  }),
+  locales: flags.string({
+    char: 'l',
+    description: 'Locales where entries will be published',
+    multiple: true,
+    parse: printFlagDeprecation(['-l'], ['--locales']),
+  }),
+  environments: flags.string({
+    char: 'e',
+    description: 'Environments where entries will be published',
+    multiple: true,
+  }),
+  config: flags.string({
+    char: 'c',
+    description:
+      'Path for the external config file (A new config file can be generated at the current working directory using `csdx cm:bulk-publish:configure -a [ALIAS]`)',
+  }),
+  yes: flags.boolean({ char: 'y', description: 'Agree to process the command with the current configuration' }),
+  branch: flags.string({
+    char: 'B',
+    default: 'main',
+    description: 'Specify the branch to fetch the content (by default the main branch is selected)',
+    parse: printFlagDeprecation(['-B'], ['--branch']),
+  }),
+  'delivery-token': flags.string({ description: 'Delivery token for source environment' }),
+  'source-env': flags.string({ description: 'Source environment'}),
+};
+
+PublishEntriesCommand.examples = [
+  'General Usage',
+  'csdx cm:entries:publish --content-types [CONTENT TYPE 1] [CONTENT TYPE 2] -e [ENVIRONMENT 1] [ENVIRONMENT 2] --locales [LOCALE 1] [LOCALE 2] -a [MANAGEMENT TOKEN ALIAS]',
+  '',
+  'Using --config or -c flag',
+  'Generate a config file at the current working directory using `csdx cm:stacks:publish-configure -a [ALIAS]`',
+  'csdx cm:entries:publish --config [PATH TO CONFIG FILE]',
+  'csdx cm:entries:publish -c [PATH TO CONFIG FILE]',
+  '',
+  'Using --retry-failed',
+  'csdx cm:entries:publish --retry-failed [LOG FILE NAME]',
+  'csdx cm:entries:publish -r [LOG FILE NAME]',
+  '',
+  'Using --branch',
+  'csdx cm:entries:publish --content-types [CONTENT TYPE 1] [CONTENT TYPE 2] -e [ENVIRONMENT 1] [ENVIRONMENT 2] --locales [LOCALE 1] [LOCALE 2] -a [MANAGEMENT TOKEN ALIAS] --branch [BRANCH NAME]',
+  '',
+  'Using --source-env',
+  'csdx cm:entries:publish --content-types [CONTENT TYPE 1] [CONTENT TYPE 2] -e [ENVIRONMENT 1] [ENVIRONMENT 2] --locales [LOCALE 1] [LOCALE 2] -a [MANAGEMENT TOKEN ALIAS] --source-env [SOURCE ENVIRONMENT] --delivery-token [DELIVERY TOKEN]',
+];
+
+PublishEntriesCommand.aliases = ['cm:bulk-publish:entries']
+
+PublishEntriesCommand.usage = 'cm:entries:publish [-a <value>] [--retry-failed <value>] [--bulk-publish <value>] [--publish-all-content-types] [--content-types <value>] [--locales <value>] [-e <value>] [-c <value>] [-y] [--branch <value>] [--delivery-token <value>] [--source-env <value>]'
+
+module.exports = PublishEntriesCommand;

package/src/commands/cm/entries/unpublish.js

@@ -0,0 +1,184 @@
+/* eslint-disable no-console */
+/* eslint-disable node/no-extraneous-require */
+const { Command, flags } = require('@contentstack/cli-command');
+const { cliux } = require('@contentstack/cli-utilities');
+const { start } = require('../../../producer/unpublish');
+const store = require('../../../util/store.js');
+const configKey = 'Unpublish';
+const { prettyPrint, formatError } = require('../../../util');
+const { getStack } = require('../../../util/client.js');
+let config;
+
+class UnpublishCommand extends Command {
+  async run() {
+    const unpublishFlags = this.parse(UnpublishCommand).flags;
+    unpublishFlags.retryFailed = unpublishFlags['retry-failed'] || unpublishFlags.retryFailed || false;
+    unpublishFlags.bulkUnpublish = unpublishFlags['bulk-unpublish'] || unpublishFlags.bulkUnpublish;
+    unpublishFlags.contentType = unpublishFlags['content-type'] || unpublishFlags.contentType || '';
+    unpublishFlags.deliveryToken = unpublishFlags['delivery-token'] || unpublishFlags.deliveryToken;
+    unpublishFlags.onlyAssets = false;
+    unpublishFlags.onlyEntries = true;
+    delete unpublishFlags['retry-failed'];
+    delete unpublishFlags['bulk-unpublish'];
+    delete unpublishFlags['content-type'];
+    delete unpublishFlags['delivery-token'];
+
+    let updatedFlags;
+    try {
+      updatedFlags = unpublishFlags.config ? store.updateMissing(configKey, unpublishFlags) : unpublishFlags;
+    } catch (error) {
+      this.error(error.message, { exit: 2 });
+    }
+
+    if (this.validate(updatedFlags)) {
+      let stack;
+      if (!updatedFlags.retryFailed) {
+        if (!updatedFlags.alias) {
+          updatedFlags.alias = await cliux.prompt('Please enter the management token alias to be used');
+        }
+        if (!updatedFlags.deliveryToken) {
+          updatedFlags.deliveryToken = await cliux.prompt('Enter delivery token of your source environment');
+        }
+        updatedFlags.bulkUnpublish = updatedFlags.bulkUnpublish === '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 --alias ${updatedFlags.alias}'`,
+            { exit: 2 },
+          );
+        }
+        config = {
+          alias: updatedFlags.alias,
+          host: this.region.cma,
+          cda: this.region.cda,
+          branch: unpublishFlags.branch,
+        };
+        stack = getStack(config);
+      }
+      if (!updatedFlags.deliveryToken && updatedFlags.deliveryToken.length === 0) {
+        this.error('Delivery Token is required for executing this command', { exit: 2 });
+      }
+
+      if (await this.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);
+      }
+    }
+  }
+
+  validate({ environment, retryFailed, locale }) {
+    let missing = [];
+    if (retryFailed) {
+      return true;
+    }
+
+    if (!environment) {
+      missing.push('Environment');
+    }
+
+    // Locales apply to assets as well
+    if (!locale) {
+      missing.push('Locale');
+    }
+
+    if (missing.length > 0) {
+      this.error(
+        `${missing.join(', ')} is required for processing this command. Please check --help for more details`,
+        { exit: 2 },
+      );
+    } else {
+      return true;
+    }
+  }
+
+  async confirmFlags(data) {
+    prettyPrint(data);
+    if (data.yes) {
+      return true;
+    }
+    if (!data.contentType) {
+      return cliux.confirm(
+        'Do you want to continue with this configuration. This will unpublish all the entries from all content types? [yes or no]',
+      );
+    } else {
+      return cliux.confirm('Do you want to continue with this configuration ? [yes or no]');
+    }
+  }
+}
+
+UnpublishCommand.description = `Unpublish entries from the given environment
+The unpublish command is used to unpublish entries from the given environment
+
+Note: Environment (Source Environment) and Locale are required to execute the command successfully
+But, if retry-failed flag is set, then only a logfile is required`;
+
+UnpublishCommand.flags = {
+  alias: flags.string({
+    char: 'a',
+    description: 'Alias(name) for the management token',
+  }),
+  environment: flags.string({
+    char: 'e',
+    description: 'Source Environment',
+  }),
+  config: flags.string({
+    char: 'c',
+    description: 'Path to the config file',
+  }),
+  yes: flags.boolean({
+    char: 'y',
+    description: 'Agree to process the command with the current configuration',
+  }),
+  locale: flags.string({
+    description: 'Locale filter',
+  }),
+  branch: flags.string({
+    default: 'main',
+    description: 'Specify the branch to fetch the content (by default the main branch is selected)',
+  }),
+  'retry-failed': flags.string({
+    description: 'Retry publishing failed entries from the logfile',
+  }),
+  'bulk-unpublish': flags.string({
+    description:
+      "This flag is set to true by default. It indicates that contentstack's bulkpublish API will be used to unpublish the entries",
+    default: 'true',
+  }),
+  'content-type': flags.string({
+    description: 'Content type filter',
+  }),
+  'delivery-token': flags.string({
+    description: 'Delivery token for source environment',
+  }),
+};
+
+UnpublishCommand.examples = [
+  'General Usage',
+  'csdx cm:stacks:unpublish --bulk-unpublish --content-type [CONTENT TYPE] --environment [SOURCE ENV] --locale [LOCALE] --alias [MANAGEMENT TOKEN ALIAS] --delivery-token [DELIVERY TOKEN]',
+  '',
+  'Using --config or -c flag',
+  'Generate a config file at the current working directory using `csdx cm:bulk-publish:configure --alias [ALIAS]`',
+  'csdx cm:stacks:unpublish --config [PATH TO CONFIG FILE]',
+  'csdx cm:stacks:unpublish -c [PATH TO CONFIG FILE]',
+  '',
+  'Using --retry-failed flag',
+  'csdx cm:stacks:unpublish --retry-failed [LOG FILE NAME]',
+  '',
+  '',
+  'Using --branch flag',
+  'csdx cm:stacks:unpublish --bulk-unpublish --content-type [CONTENT TYPE] --environment [SOURCE ENV] --locale [LOCALE] --alias [MANAGEMENT TOKEN ALIAS] --delivery-token [DELIVERY TOKEN] --branch [BRANCH NAME]',
+];
+
+module.exports = UnpublishCommand;

package/src/commands/cm/entries/update-and-publish.js

@@ -0,0 +1,191 @@
+const { Command, flags } = require('@contentstack/cli-command');
+const { printFlagDeprecation, cliux } = require('@contentstack/cli-utilities');
+
+const store = require('../../../util/store.js');
+const { getStack } = require('../../../util/client.js');
+const { start } = require('../../../producer/add-fields');
+const { prettyPrint, formatError } = require('../../../util');
+
+let config;
+const configKey = 'addFields';
+
+class UpdateAndPublishCommand extends Command {
+  async run() {
+    const addFieldsFlags = this.parse(UpdateAndPublishCommand).flags;
+    addFieldsFlags.retryFailed = addFieldsFlags['retry-failed'] || addFieldsFlags.retryFailed || false;
+    addFieldsFlags.contentTypes = addFieldsFlags['content-types'] || addFieldsFlags.contentTypes;
+    addFieldsFlags.bulkPublish = addFieldsFlags['bulk-publish'] || addFieldsFlags.bulkPublish;
+    delete addFieldsFlags['retry-failed'];
+    delete addFieldsFlags['content-types'];
+    delete addFieldsFlags['bulk-publish'];
+
+    let updatedFlags;
+    try {
+      updatedFlags = addFieldsFlags.config ? store.updateMissing(configKey, addFieldsFlags) : addFieldsFlags;
+    } catch (error) {
+      this.error(error.message, { exit: 2 });
+    }
+    if (this.validate(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: addFieldsFlags.branch,
+        };
+        stack = getStack(config);
+      }
+      if (await this.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);
+      }
+    }
+  }
+
+  validate({ contentTypes, locales, environments, retryFailed }) {
+    let missing = [];
+    if (retryFailed) {
+      return true;
+    }
+
+    if (!contentTypes || contentTypes.length === 0) {
+      missing.push('Content Types');
+    }
+
+    if (!locales || locales.length === 0) {
+      missing.push('Locales');
+    }
+
+    if (!environments || environments.length === 0) {
+      missing.push('Environments');
+    }
+
+    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 confirmFlags(data) {
+    prettyPrint(data);
+    if (data.yes) {
+      return true;
+    }
+    return cliux.confirm('Do you want to continue with this configuration ? [yes or no]');
+  }
+}
+
+UpdateAndPublishCommand.description = `Add fields from updated content types to their respective entries
+The update-and-publish command is used to update existing entries with the updated schema of the respective content type
+
+Note: Content types, Environments and Locales are required to execute the command successfully
+But, if retry-failed flag is set, then only a logfile is required
+`;
+
+UpdateAndPublishCommand.flags = {
+  alias: flags.string({ char: 'a', description: 'Alias(name) for the management token' }),
+  'retry-failed': flags.string({
+    description: 'Retry publishing failed entries from the logfile (optional, overrides all other flags)',
+  }),
+  retryFailed: flags.string({
+    char: 'r',
+    description: 'Retry publishing failed entries from the logfile (optional, overrides all other flags)',
+    hidden: true,
+    parse: printFlagDeprecation(['-r', '--retryFailed'], ['--retry-failed']),
+  }),
+  'bulk-publish': flags.string({
+    description:
+      "This flag is set to true by default. It indicates that contentstack's bulkpublish API will be used to publish the entries",
+    default: 'true',
+  }),
+  bulkPublish: flags.string({
+    char: 'b',
+    description:
+      "This flag is set to true by default. It indicates that contentstack's bulkpublish API will be used to publish the entries",
+    hidden: true,
+    parse: printFlagDeprecation(['-b', '--bulkPublish'], ['--bulk-publish']),
+  }),
+  'content-types': flags.string({
+    description: 'The Contenttypes from which entries will be published',
+    multiple: true,
+  }),
+  contentTypes: flags.string({
+    char: 't',
+    description: 'The Contenttypes from which entries will be published',
+    multiple: true,
+    parse: printFlagDeprecation(['-t', '--contentTypes'], ['--content-types']),
+  }),
+  environments: flags.string({
+    char: 'e',
+    description: 'Environments where entries will be published',
+    multiple: true,
+  }),
+  config: flags.string({ char: 'c', description: 'Path to the config file' }),
+  yes: flags.boolean({ char: 'y', description: 'Agree to process the command with the current configuration' }),
+  locales: flags.string({
+    char: 'l',
+    description: 'Locales where entries will be published',
+    multiple: true,
+    parse: printFlagDeprecation(['-l'], ['--locales']),
+  }),
+  branch: flags.string({
+    char: 'B',
+    default: 'main',
+    description: 'Specify the branch to fetch the content (by default the main branch is selected)',
+    parse: printFlagDeprecation(['-B'], ['--branch']),
+  }),
+  force: flags.boolean({
+    default: false,
+    description: 'Update and publish all entries even if no fields have been added',
+  }),
+};
+
+UpdateAndPublishCommand.examples = [
+  'General Usage',
+  'csdx cm:entries:update-and-publish --content-types [CONTENT TYPE 1] [CONTENT TYPE 2] -e [ENVIRONMENT 1] [ENVIRONMENT 2] --locale [LOCALE 1] [LOCALE 2] -a [MANAGEMENT TOKEN ALIAS]',
+  '',
+  'Using --config or -c flag',
+  'Generate a config file at the current working directory using `csdx cm:stacks:publish-configure -a [ALIAS]`',
+  'csdx cm:entries:update-and-publish --config [PATH TO CONFIG FILE]',
+  'csdx cm:entries:update-and-publish -c [PATH TO CONFIG FILE]',
+  '',
+  'Using --retry-failed',
+  'csdx cm:entries:update-and-publish --retry-failed [LOG FILE NAME]',
+  '',
+  'Using --branch',
+  'csdx cm:entries:update-and-publish --content-types [CONTENT TYPE 1] [CONTENT TYPE 2] -e [ENVIRONMENT 1] [ENVIRONMENT 2] --locale [LOCALE 1] [LOCALE 2] -a [MANAGEMENT TOKEN ALIAS] --branch [BRANCH NAME]',
+];
+
+UpdateAndPublishCommand.aliases = ['cm:bulk-publish:add-fields'];
+
+UpdateAndPublishCommand.usage =
+  'cm:entries:update-and-publish [-a <value>] [--retry-failed <value>] [--bulk-publish <value>] [--content-types <value>] [-t <value>] [-e <value>] [-c <value>] [-y] [--locales <value>] [--branch <value>]';
+
+module.exports = UpdateAndPublishCommand;