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

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

@@ -21,11 +21,19 @@ class PublishEntriesCommand extends Command {
     entriesFlags.publishAllContentTypes =
       entriesFlags['publish-all-content-types'] || entriesFlags.publishAllContentTypes || false;
     entriesFlags.apiVersion = entriesFlags['api-version'] || '3';
+    entriesFlags.includeVariants = entriesFlags['include-variants'] || entriesFlags.includeVariants || false;
+    entriesFlags.entryUid = entriesFlags['entry-uid'] || entriesFlags.entryUid;
+
+    if (entriesFlags.entryUid === undefined) {
+      delete entriesFlags['entryUid'];
+    }
     delete entriesFlags['api-version'];
     delete entriesFlags['retry-failed'];
     delete entriesFlags['content-types'];
     delete entriesFlags['bulk-publish'];
     delete entriesFlags['publish-all-content-types'];
+    delete entriesFlags['include-variants'];
+    delete entriesFlags['entry-uid'];
 
     let updatedFlags;
     try {
@@ -168,82 +176,86 @@ 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' }),
+  alias: flags.string({ char: 'a', description: 'Alias (name) of the management token. You must use either the --alias flag or the --stack-api-key flag.' }),
   'stack-api-key': flags.string({
     char: 'k',
-    description: 'Stack api key to be used',
+    description: 'API key of the source stack. You must use either the --stack-api-key flag or the --alias flag.',
   }),
   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',
+      '(optional) Use this option to retry publishing the failed entries/ assets from the logfile. Specify the name of the logfile that lists failed publish calls. If this option is used, it will override all other flags.',
     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',
+      '(optional) Use this option to retry publishing the failed entries/ assets from the logfile. Specify the name of the logfile that lists failed publish calls. If this option is used, it will override all other flags.',
   }),
   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",
+    description: `Set this flag to use Contentstack\'s Bulk Publish APIs. This flag is set to true, by default.`,
     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",
+      `Set this flag to use Contentstack\'s Bulk Publish APIs. This flag is set to true, by default.`,
     default: 'true',
   }),
   'api-version': flags.string({
-    description : "API Version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].",
+    description : 'API version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].',
   }),
   'publish-all-content-types': flags.boolean({
-    description: '(optional) Publish all contenttypes (cannot be set when contentTypes flag is set)',
+    description: '(optional) Set it to true to bulk publish entries from all content types. If the --content-types option is already used, then you cannot use this option.',
   }),
   publishAllContentTypes: flags.boolean({
     char: 'o',
-    description: 'Publish all content-types (optional, cannot be set when contentTypes flag is set)',
+    description: '(optional) Set it to true to bulk publish entries from all content types. If the --content-types option is already used, then you cannot use this option.',
     hidden: true,
     parse: printFlagDeprecation(['-o', '--publishAllContentTypes'], ['--publish-all-content-types']),
   }),
   'content-types': flags.string({
-    description: 'The Contenttypes from which entries need to be published',
+    description: 'The UID of the content type(s) whose entries you want to publish in bulk. In case of multiple content types, specify the IDs separated by spaces.',
     multiple: true,
   }),
   contentTypes: flags.string({
     char: 't',
-    description: 'The Contenttypes from which entries will be published',
+    description: 'The UID of the content type(s) whose entries you want to publish in bulk. In case of multiple content types, specify the IDs separated by spaces.',
     multiple: true,
     parse: printFlagDeprecation(['-t', '--contentTypes'], ['--content-types']),
     hidden: true,
   }),
   locales: flags.string({
     char: 'l',
-    description: 'Locales where entries will be published',
+    description: ' Locales in which entries will be published, e.g., en-us. In the case of multiple locales, specify the codes separated by spaces.',
     multiple: true,
     parse: printFlagDeprecation(['-l'], ['--locales']),
   }),
   environments: flags.string({
     char: 'e',
-    description: 'Environments where entries will be published',
+    description: 'The name of the environment on which entries will be published. In case of multiple environments, specify their names separated by spaces.',
     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]`)',
+      '(optional) The path of the optional configuration JSON file containing all the options for a single run. Refer to the configure command to create a configuration file.',
   }),
-  yes: flags.boolean({ char: 'y', description: 'Agree to process the command with the current configuration' }),
+  yes: flags.boolean({ char: 'y', description: 'Set it to true 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)',
+    description: 'The name of the branch where you want to perform the bulk publish operation. If you don’t mention the branch name, then by default the content from main branch will be published.',
     parse: printFlagDeprecation(['-B'], ['--branch']),
   }),
-  'delivery-token': flags.string({ description: 'Delivery token for source environment' }),
+  'delivery-token': flags.string({ description: 'The delivery token of the source environment.' }),
   'source-env': flags.string({ description: 'Source environment' }),
+  'entry-uid': flags.string({ description: 'Entry Uid for publish all associated variant entries.' }),
+  'include-variants': flags.boolean({
+    default: false, // set the default value to false
+    description: 'Include Variants flag will publish all associated variant entries with base entry.',
+  }),
 };
 
 PublishEntriesCommand.examples = [
@@ -267,11 +279,17 @@ PublishEntriesCommand.examples = [
   '',
   'Using --stack-api-key',
   'csdx cm:entries:publish -e [ENVIRONMENT 1] [ENVIRONMENT 2] --locales [LOCALE 1] [LOCALE 2] --stack-api-key [STACK API KEY] --source-env [SOURCE ENVIRONMENT] --delivery-token [DELIVERY TOKEN]',
+  '',
+  'Using --include-variants',
+  'csdx cm:entries:publish --content-types [CONTENT TYPE 1] [CONTENT TYPE 2] -e [ENVIRONMENT 1] [ENVIRONMENT 2] --locales [LOCALE 1] [LOCALE 2] --stack-api-key [STACK API KEY] --source-env [SOURCE ENVIRONMENT] --delivery-token [DELIVERY TOKEN] [--include-variants]',
+  '',
+  'Using --entry-uid and --include-variants',
+  'csdx cm:entries:publish --content-types [CONTENT TYPE 1] [CONTENT TYPE 2] -e [ENVIRONMENT 1] [ENVIRONMENT 2] --locales [LOCALE 1] [LOCALE 2] --stack-api-key [STACK API KEY] --source-env [SOURCE ENVIRONMENT] --delivery-token [DELIVERY TOKEN] --entry-uid [ENTRY UID] [--include-variants]',
 ];
 
 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>]';
+  '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>] [--entry-uid <value>] [--include-variants]';
 
 module.exports = PublishEntriesCommand;

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

@@ -19,11 +19,13 @@ class UnpublishCommand extends Command {
     unpublishFlags.onlyAssets = false;
     unpublishFlags.onlyEntries = true;
     unpublishFlags.apiVersion = unpublishFlags['api-version'] || '3';
+    unpublishFlags.includeVariants = unpublishFlags['include-variants'] || false;
     delete unpublishFlags['api-version'];
     delete unpublishFlags['retry-failed'];
     delete unpublishFlags['bulk-unpublish'];
     delete unpublishFlags['content-type'];
     delete unpublishFlags['delivery-token'];
+    delete unpublishFlags['include-variants'];
 
     let updatedFlags;
     try {
@@ -59,7 +61,6 @@ class UnpublishCommand extends Command {
           updatedFlags.deliveryToken = await cliux.prompt('Enter delivery token of your source environment');
         }
         updatedFlags.bulkUnpublish = updatedFlags.bulkUnpublish === 'false' ? false : true;
-
         stack = await getStack(config);
       }
       if (!updatedFlags.deliveryToken && updatedFlags.deliveryToken.length === 0) {
@@ -135,47 +136,50 @@ 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',
+    description: 'Alias (name) for the management token. You must use either the --alias flag or the --stack-api-key flag.',
   }),
   'stack-api-key': flags.string({
     char: 'k',
-    description: 'Stack api key to be used',
+    description: 'API key of the source stack. You must use either the --stack-api-key flag or the --alias flag.',
   }),
   environment: flags.string({
     char: 'e',
-    description: 'Source Environment',
+    description: 'The name of the environment from where entries/assets need to be unpublished.',
   }),
   config: flags.string({
     char: 'c',
-    description: 'Path to the config file',
+    description: '(optional) Path to the configuration JSON file containing all options for a single run. Refer to the configure command to create a configuration file.',
   }),
   yes: flags.boolean({
     char: 'y',
-    description: 'Agree to process the command with the current configuration',
+    description: 'Set to true to process the command with the current configuration.',
   }),
   locale: flags.string({
-    description: 'Locale filter',
+    description: 'Locale from which entries/assets will be unpublished, e.g., en-us.',
   }),
   branch: flags.string({
     default: 'main',
-    description: 'Specify the branch to fetch the content (by default the main branch is selected)',
+    description: 'Specify the branch to fetch the content. If not mentioned, the main branch will be used by default.',
   }),
   'retry-failed': flags.string({
-    description: 'Retry publishing failed entries from the logfile',
+    description: '(optional) Use this option to retry unpublishing the failed entries from the logfile. Specify the name of the logfile that lists failed unpublish calls. If used, this option will override all other flags.',
   }),
   '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",
+    description: "This flag is set to true by default. It indicates that Contentstack's Bulk Publish APIs will be used to unpublish the entries.",
     default: 'true',
   }),
   'api-version': flags.string({
-    description : "API Version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].",
+    description: 'API version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].',
   }),
   'content-type': flags.string({
-    description: 'Content type filter',
+    description: 'The UID of the content type whose entries you want to unpublish in bulk.',
   }),
   'delivery-token': flags.string({
-    description: 'Delivery token for source environment',
+    description: 'The delivery token of the source environment.',
+  }),
+  'include-variants': flags.boolean({ 
+    default: false, // set the default value to false
+    description: 'Include Variants flag will unpublish all associated variant entries.' 
   }),
 };
 
@@ -196,6 +200,9 @@ UnpublishCommand.examples = [
   '',
   'Using --stack-api-key flag',
   'csdx cm:stacks:unpublish --bulk-unpublish --content-type [CONTENT TYPE] --environment [SOURCE ENV] --locale [LOCALE] --stack-api-key [STACK API KEY] --delivery-token [DELIVERY TOKEN]',
+  '',
+  'Using --include-variants flag',
+  'csdx cm:stacks:unpublish --bulk-unpublish --content-type [CONTENT TYPE] --environment [SOURCE ENV] --locale [LOCALE] --stack-api-key [STACK API KEY] --delivery-token [DELIVERY TOKEN] --include-variants',
 ];
 
 module.exports = UnpublishCommand;

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

@@ -117,67 +117,74 @@ 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' }),
+  alias: flags.string({
+    char: 'a',
+    description: 'Alias (name) of the management token. You must use either the --alias flag or the --stack-api-key flag.',
+  }),
   'stack-api-key': flags.string({
     char: 'k',
-    description: 'Stack api key to be used',
+    description: 'API key of the source stack. You must use either the --stack-api-key flag or the --alias flag.',
   }),
   'retry-failed': flags.string({
-    description: 'Retry publishing failed entries from the logfile (optional, overrides all other flags)',
+    description: 'Use this option to retry publishing the failed entries from the logfile. Specify the name of the logfile that lists failed publish calls. If this option is used, it will override all other flags.',
   }),
   '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",
+    description: "Set this flag to use Contentstack’s Bulk Publish APIs. It is true, by default.",
     default: 'true',
   }),
   'api-version': flags.string({
-    description : "API Version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].",
+    description: "API version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].",
   }),
   'content-types': flags.string({
-    description: 'The Contenttypes from which entries will be published',
+    description: 'The UID of the content type ID whose entries you want to publish in bulk. In case of multiple content types, specify their IDs separated by spaces.',
     multiple: true,
   }),
   environments: flags.string({
     char: 'e',
-    description: 'Environments where entries will be published',
+    description: 'The name of the environment on which entries will be published. In case of multiple environments, specify their names separated by spaces.',
     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' }),
+  config: flags.string({
+    char: 'c',
+    description: '(optional) The path of the optional configuration JSON file containing all the options for a single run. Refer to the configure command to create a configuration file.',
+  }),
+  yes: flags.boolean({
+    char: 'y',
+    description: 'Set it to true to process the command with the current configuration.',
+  }),
   locales: flags.string({
     char: 'l',
-    description: 'Locales where entries will be published',
+    description: 'Locales in which entries will be published, e.g., en-us. In the case of multiple locales, specify the codes separated by spaces.',
     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)',
+    description: 'The name of the branch where you want to perform the bulk publish operation. If you don’t mention the branch name, then by default the content from the main branch will be published.',
     parse: printFlagDeprecation(['-B'], ['--branch']),
   }),
   force: flags.boolean({
     default: false,
-    description: 'Update and publish all entries even if no fields have been added',
+    description: 'Update and publish all entries even if no fields have been added.',
   }),
 
   // To be deprecated
   retryFailed: flags.string({
     char: 'r',
-    description: 'Retry publishing failed entries from the logfile (optional, overrides all other flags)',
+    description: 'Retry publishing failed entries from the logfile (optional, overrides all other flags).',
     hidden: true,
     parse: printFlagDeprecation(['-r', '--retryFailed'], ['--retry-failed']),
   }),
   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",
+    description: "This flag is set to true by default. It indicates that contentstack's bulk publish API will be used to publish the entries.",
     hidden: true,
     parse: printFlagDeprecation(['-b', '--bulkPublish'], ['--bulk-publish']),
   }),
   contentTypes: flags.string({
     char: 't',
-    description: 'The Contenttypes from which entries will be published',
+    description: 'The Contenttypes from which entries will be published.',
     multiple: true,
     parse: printFlagDeprecation(['-t', '--contentTypes'], ['--content-types']),
   }),

package/src/commands/cm/stacks/publish-configure.js

@@ -35,8 +35,8 @@ class ConfigureCommand extends Command {
 ConfigureCommand.description = `The configure command is used to generate a configuration file for publish scripts.`;
 
 ConfigureCommand.flags = {
-  alias: flags.string({ char: 'a', description: 'Alias(name) for the management token' }),
-  'stack-api-key': flags.string({ char: 'k', description: 'Stack api key to be used' }),
+  alias: flags.string({ char: 'a', description: 'Name (alias) of the management token you want to use. You must use either the --alias flag or the --stack-api-key flag.' }),
+  'stack-api-key': flags.string({ char: 'k', description: 'API key of the source stack. You must use either the --stack-api-key flag or the --alias flag.' }),
 };
 
 ConfigureCommand.examples = [

package/src/commands/cm/stacks/publish-revert.js

@@ -71,19 +71,19 @@ A log file name is required to execute revert command
 `;
 
 RevertCommand.flags = {
-  'retry-failed': flags.string({ description: 'retry publishing failed entries from the logfile' }),
-  'log-file': flags.string({ description: 'logfile to be used to revert' }),
+  'retry-failed': flags.string({ description: '(optional)  Use this option to retry publishing the failed entries from the logfile. Specify the name of the logfile that lists failed publish calls. If this option is used, it will override all other flags.' }),
+  'log-file': flags.string({ description: 'Path of the success logfile of a particular publish action.' }),
 
   //To be deprecated
   retryFailed: flags.string({
     char: 'r',
-    description: 'retry publishing failed entries from the logfile',
+    description: '(optional)  Use this option to retry publishing the failed entries from the logfile. Specify the name of the logfile that lists failed publish calls. If this option is used, it will override all other flags.',
     hidden: true,
     parse: printFlagDeprecation(['-r', '--retryFailed'], ['--retry-failed']),
   }),
   logFile: flags.string({
     char: 'l',
-    description: 'logfile to be used to revert',
+    description: 'Path of the success logfile of a particular publish action.',
     hidden: true,
     parse: printFlagDeprecation(['-l', '--logFile'], ['--log-file']),
   }),

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

@@ -203,13 +203,13 @@ UnpublishCommand.flags = {
     default: 'true',
   }),
   'api-version': flags.string({
-    description : "API Version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].",
+    description : "API version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].",
   }),
   'content-type': flags.string({
     description: 'Content type filter',
   }),
   'delivery-token': flags.string({
-    description: 'Delivery token for source environment',
+    description: 'The delivery token of the source environment.',
   }),
   'only-assets': flags.boolean({
     description: 'Unpublish only assets',

package/src/producer/cross-publish.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_PUBLISH_API_VERSION = '3.2';
 
 let bulkPublishSet = [];
 let bulkPublishAssetSet = [];
@@ -34,20 +35,30 @@ function getQueryParams(filter) {
   return queryString;
 }
 
-async function bulkAction(stack, items, bulkPublish, filter, destEnv, apiVersion, bulkPublishLimit) {
+async function bulkAction(stack, items, bulkPublish, filter, destEnv, apiVersion, bulkPublishLimit, variantsFlag = false) {
   return new Promise(async (resolve) => {
     for (let index = 0; index < items.length; index++) {
       changedFlag = true;
 
       if (bulkPublish) {
         if (bulkPublishSet.length < bulkPublishLimit && items[index].type === 'entry_published') {
-          bulkPublishSet.push({
+          const entry = {
             uid: items[index].data.uid,
             content_type: items[index].content_type_uid,
             locale: items[index].data.locale || 'en-us',
             version: items[index].data._version,
             publish_details: [items[index].data.publish_details] || [],
-          });
+          };
+
+          if (variantsFlag && Array.isArray(items[index].data.variants) && items[index].data.variants.length > 0) {
+            entry.variants = items[index].data.variants || [];
+            entry.variant_rules = {
+              publish_latest_base: false,
+              publish_latest_base_conditionally: true
+            };
+          }
+
+          bulkPublishSet.push(JSON.parse(JSON.stringify(entry)));
         }
 
         if (bulkPublishAssetSet.length < bulkPublishLimit && items[index].type === 'asset_published') {
@@ -145,6 +156,7 @@ async function getSyncEntries(
   destEnv,
   apiVersion,
   bulkPublishLimit,
+  variantsFlag = false,
   paginationToken = null,
 ) {
   return new Promise(async (resolve, reject) => {
@@ -200,8 +212,19 @@ async function getSyncEntries(
         );
       }
 
+      if (variantsFlag) {
+        for (let index = 0; index < entriesResponse?.items?.length; index++) {
+          let variants = [];
+          const entries = entriesResponse.items[index];
+          variants = await getVariantEntries(stack, entries.content_type_uid, entriesResponse, index, queryParamsObj);
+          if (variants.length > 0) {
+            entriesResponse.items[index].data.variants = variants;
+          }
+        }
+      }
+
       if (entriesResponse.items.length > 0) {
-        await bulkAction(stack, entriesResponse.items, bulkPublish, filter, destEnv, apiVersion, bulkPublishLimit);
+        await bulkAction(stack, entriesResponse.items, bulkPublish, filter, destEnv, apiVersion, bulkPublishLimit, variantsFlag);
       }
       if (!entriesResponse.pagination_token) {
         if (!changedFlag) console.log('No Entries/Assets Found published on specified environment');
@@ -244,6 +267,48 @@ function setConfig(conf, bp) {
   filePath = initializeLogger(logFileName);
 }
 
+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
+    };
+    const entryUid = entries.items[index].data.uid
+    const variantsEntriesResponse = await stack
+      .contentType(contentType)
+      .entry(entryUid)
+      .variants()
+      .query(variantQueryParams)
+      .find();
+
+    const variants = variantsEntriesResponse.items.map((entry) => ({
+      uid: entry.variants._variant._uid,
+    }));
+
+    if (variantsEntriesResponse.items.length === variantQueryParams.limit) {
+      const nextVariants = await getVariantEntries(
+        stack,
+        contentType,
+        entries,
+        index,
+        queryParams,
+        skip + variantQueryParams.limit,
+      );
+      return Array.isArray(nextVariants) ? variants.concat(nextVariants) : variants;
+    }
+    return variants;
+  } catch (error) {
+    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(
   {
     retryFailed,
@@ -258,6 +323,7 @@ async function start(
     destEnv,
     f_types,
     apiVersion,
+    includeVariants,
   },
   stack,
   config,
@@ -310,7 +376,20 @@ async function start(
     // filter.type = (f_types) ? f_types : types // types mentioned in the config file (f_types) are given preference
     const queryParams = getQueryParams(filter);
     const bulkPublishLimit = fetchBulkPublishLimit(stack?.org_uid);
-    await getSyncEntries(stack, config, queryParams, bulkPublish, filter, deliveryToken, destEnv, apiVersion, bulkPublishLimit);
+    if (includeVariants) {
+      apiVersion = VARIANTS_PUBLISH_API_VERSION;
+    }
+    await getSyncEntries(
+      stack,
+      config,
+      queryParams,
+      bulkPublish,
+      filter,
+      deliveryToken,
+      destEnv,
+      apiVersion, bulkPublishLimit,
+      includeVariants,
+    );
   }
 }