@contentstack/cli-cm-export 0.1.1-beta.6 → 0.1.1-beta.9

package/README.md

@@ -18,7 +18,7 @@ $ npm install -g @contentstack/cli-cm-export
 $ csdx COMMAND
 running command...
 $ csdx (-v|--version|version)
-@contentstack/cli-cm-export/0.1.1-beta.6 darwin-x64 node-v14.16.0
+@contentstack/cli-cm-export/0.1.1-beta.9 linux-x64 node-v12.18.4
 $ csdx --help [COMMAND]
 USAGE
   $ csdx COMMAND
@@ -41,11 +41,13 @@ USAGE
 
 OPTIONS
   -A, --auth-token                                     to use auth token
+  -B, --branch=branch                                  [optional] branch name
   -a, --management-token-alias=management-token-alias  alias of the management token
   -c, --config=config                                  [optional] path of the config
   -d, --data=data                                      path or location to store the data
   -m, --module=module                                  [optional] specific module name
   -s, --stack-uid=stack-uid                            API key of the source stack
+  -t, --content-type=content-type                      [optional] content type
   --secured-assets                                     [optional] use when assets are secured
 
 DESCRIPTION
@@ -61,7 +63,10 @@ EXAMPLES
   csdx cm:export -a <management_token_alias>
   csdx cm:export -a <management_token_alias> -d <path/to/export/destination/dir>
   csdx cm:export -a <management_token_alias> -c <path/to/config/file>
+  csdx cm:export -A -m <single module name>
+  csdx cm:export -A -m <single module name> -t <content type>
+  csdx cm:export -A -B [optional] branch name
 ```
 
-_See code: [src/commands/cm/export.js](https://github.com/contentstack/cli/blob/v0.1.1-beta.6/packages/contentstack-export/src/commands/cm/export.js)_
+_See code: [src/commands/cm/export.js](https://github.com/contentstack/cli/blob/v0.1.1-beta.9/packages/contentstack-export/src/commands/cm/export.js)_
 <!-- commandsstop -->

package/oclif.manifest.json

@@ -1 +1 @@
-{"version":"0.1.1-beta.6","commands":{"cm:export":{"id":"cm:export","description":"Export content from a stack\n...\nExport content from one stack to another\n","pluginName":"@contentstack/cli-cm-export","pluginType":"core","aliases":[],"examples":["csdx cm:export -A","csdx cm:export -A -s <stack_ApiKey> -d <path/of/export/destination/dir>","csdx cm:export -A -c <path/to/config/dir>","csdx cm:export -A -m <single module name>","csdx cm:export -A --secured-assets","csdx cm:export -a <management_token_alias>","csdx cm:export -a <management_token_alias> -d <path/to/export/destination/dir>","csdx cm:export -a <management_token_alias> -c <path/to/config/file>"],"flags":{"config":{"name":"config","type":"option","char":"c","description":"[optional] path of the config"},"stack-uid":{"name":"stack-uid","type":"option","char":"s","description":"API key of the source stack"},"data":{"name":"data","type":"option","char":"d","description":"path or location to store the data"},"management-token-alias":{"name":"management-token-alias","type":"option","char":"a","description":"alias of the management token"},"auth-token":{"name":"auth-token","type":"boolean","char":"A","description":"to use auth token","allowNo":false},"module":{"name":"module","type":"option","char":"m","description":"[optional] specific module name"},"secured-assets":{"name":"secured-assets","type":"boolean","description":"[optional] use when assets are secured","allowNo":false}},"args":[]}}}
+{"version":"0.1.1-beta.9","commands":{"cm:export":{"id":"cm:export","description":"Export content from a stack\n...\nExport content from one stack to another\n","pluginName":"@contentstack/cli-cm-export","pluginType":"core","aliases":[],"examples":["csdx cm:export -A","csdx cm:export -A -s <stack_ApiKey> -d <path/of/export/destination/dir>","csdx cm:export -A -c <path/to/config/dir>","csdx cm:export -A -m <single module name>","csdx cm:export -A --secured-assets","csdx cm:export -a <management_token_alias>","csdx cm:export -a <management_token_alias> -d <path/to/export/destination/dir>","csdx cm:export -a <management_token_alias> -c <path/to/config/file>","csdx cm:export -A -m <single module name>","csdx cm:export -A -m <single module name> -t <content type>","csdx cm:export -A -B [optional] branch name"],"flags":{"config":{"name":"config","type":"option","char":"c","description":"[optional] path of the config"},"stack-uid":{"name":"stack-uid","type":"option","char":"s","description":"API key of the source stack"},"data":{"name":"data","type":"option","char":"d","description":"path or location to store the data"},"management-token-alias":{"name":"management-token-alias","type":"option","char":"a","description":"alias of the management token"},"auth-token":{"name":"auth-token","type":"boolean","char":"A","description":"to use auth token","allowNo":false},"module":{"name":"module","type":"option","char":"m","description":"[optional] specific module name"},"content-type":{"name":"content-type","type":"option","char":"t","description":"[optional] content type"},"branch":{"name":"branch","type":"option","char":"B","description":"[optional] branch name"},"secured-assets":{"name":"secured-assets","type":"boolean","description":"[optional] use when assets are secured","allowNo":false}},"args":[]}}}

package/package.json

@@ -1,12 +1,12 @@
 {
 	"name": "@contentstack/cli-cm-export",
 	"description": "Contentstack CLI plugin to export content from stack",
-	"version": "0.1.1-beta.6",
+	"version": "0.1.1-beta.9",
 	"author": "Contentstack",
 	"bugs": "https://github.com/contentstack/cli/issues",
 	"dependencies": {
 		"@contentstack/cli-command": "0.1.0-beta",
-		"@contentstack/management": "^1.2.1",
+		"@contentstack/management": "github:contentstack/contentstack-management-javascript#65e8588",
 		"@oclif/command": "^1.6.1",
 		"@oclif/config": "^1.15.1",
 		"async": "^3.2.0",

package/src/app.js

@@ -1,90 +1,157 @@
 /* eslint-disable no-redeclare */
-var util = require('./lib/util')
-var login = require('./lib/util/login')
-var {addlogs} = require('./lib/util/log')
-const chalk = require('chalk')
-let path = require('path')
-let _ = require('lodash')
+var util = require("./lib/util");
+var login = require("./lib/util/login");
+var { addlogs } = require("./lib/util/log");
+const setupBranches = require("./lib/util/setup-branches");
+const chalk = require("chalk");
+let path = require("path");
+let _ = require("lodash");
+const cli = require("cli-ux");
 
 exports.initial = async function (config) {
   return new Promise(function (resolve, reject) {
-    config = util.buildAppConfig(config)
-    util.validateConfig(config)
+    config = util.buildAppConfig(config);
+    util.validateConfig(config);
     exports.getConfig = function () {
-      return config
-    }
+      return config;
+    };
     // try {
-    login.login(config).then(async function () {
-      var types = config.modules.types
-      if (config.moduleName && config.moduleName !== undefined) {
-        singleExport(config.moduleName, types, config)
-        return resolve()
-      } else {
-        allExport(config, types).then(() => {
-          return resolve()
-        })
-      }
-    }).catch(error => {
-      if (error.errors.api_key) {
-        addlogs(config, chalk.red('Stack Api key ' + error.errors.api_key[0], 'Please enter valid Key', 'error'))
-        addlogs(config, 'The log for this is stored at ' + config.data + '/export/logs', 'success')
-      } else {
-        let objKey = Object.keys(error.errors)
-        addlogs(config, chalk.red('Stack fail to export, ' + objKey + '' + error.errors[objKey][0]), 'error')
-      }
-    })
-  })
-}
+    login
+      .login(config)
+      .then(async function () {
+        //setup branches
+        await setupBranches(config, config.branchName);
+        var types = config.modules.types;
+        if (Array.isArray(config.branches) && config.branches.length > 0) {
+          for (let branch of config.branches) {
+            config.branchName = branch.uid;
+            try {
+              if (config.moduleName) {
+                await singleExport(config.moduleName, types, config, branch.uid);
+              } else {
+                await allExport(config, types, branch.uid);
+              } 
+            } catch (error) {
+              console.log('failed export branch', branch.uid, error)
+            }
+          } 
+        } else {
+          try {
+            if (config.moduleName) {
+              await singleExport(config.moduleName, types, config);
+            } else {
+              await allExport(config, types);
+            } 
+          } catch (error) {
+            console.log('failed export contents', error)
+          }
+        }
+        resolve()
+      })
+      .catch((error) => {
+        console.log("error", error);
+        if (error && error.errors && error.errors.api_key) {
+          addlogs(
+            config,
+            chalk.red(
+              "Stack Api key " + error.errors.api_key[0],
+              "Please enter valid Key",
+              "error"
+            )
+          );
+          addlogs(
+            config,
+            "The log for this is stored at " + config.data + "/export/logs",
+            "success"
+          );
+        } else {
+          console.log("Stack fail to export")
+        }
+        reject(error)
+      });
+  });
+};
 
-var singleExport = async (moduleName, types, config) => {
-  var types = config.modules.types
+var singleExport = async (moduleName, types, config, branchName) => {
   try {
     if (types.indexOf(moduleName) > -1) {
-      let iterateList = ['stack', moduleName]
+      let iterateList;
+      if (config.modules.dependency && config.modules.dependency[moduleName]) {
+        iterateList = config.modules.dependency[moduleName];
+      } else {
+        iterateList = ["stack"];
+      }
+      iterateList.push(moduleName);
+
       for (let i = 0; i < iterateList.length; i++) {
-        var exportedModule = require('./lib/export/' + iterateList[i])
-        await exportedModule.start(config).then(function (result) {
-          if (iterateList[i] === 'stack') {
-            let master_locale = { master_locale: { code: result.master_locale } }
-            config = _.merge(config, master_locale)
-          }
-        })
+
+        var exportedModule = require("./lib/export/" + iterateList[i]);
+        const result = await exportedModule.start(config, branchName);
+        if (result && iterateList[i] === "stack") {
+          let master_locale = {
+            master_locale: { code: result.master_locale },
+          };
+          config = _.merge(config, master_locale);
+        }
       }
-      addlogs(config, moduleName + ' was exported successfully!', 'success')
-      addlogs(config, 'The log for this is stored at ' + path.join(config.data, 'logs', 'export'), 'success')
+      addlogs(config, moduleName + " was exported successfully!", "success");
+      addlogs(
+        config,
+        "The log for this is stored at " +
+          path.join(config.data, "logs", "export"),
+        "success"
+      );
     } else {
-      addlogs(config, 'Please provide valid module name.', 'error')
+      addlogs(config, "Please provide valid module name.", "error");
     }
+    return true
   } catch (error) {
-    addlogs(config, 'Failed to migrate ' + moduleName, 'error')
-    addlogs(config, error, 'error')
-    addlogs(config, 'The log for this is stored at ' + path.join(config.data, 'logs', 'export'), 'error')
+    addlogs(config, "Failed to migrate " + moduleName, "error");
+    addlogs(config, error, "error");
+    addlogs(
+      config,
+      "The log for this is stored at " +
+        path.join(config.data, "logs", "export"),
+      "error"
+    );
+    throw error
   }
-}
+};
 
-var allExport = async (config, types) => {
+var allExport = async (config, types, branchName) => {
   // eslint-disable-next-line no-async-promise-executor
   return new Promise(async (resolve, reject) => {
     try {
       for (let i = 0; i < types.length; i++) {
-        let type = types[i]
-        var exportedModule = require('./lib/export/' + type)
-        await exportedModule.start(config).then(result => {
-          if (type === 'stack') {
-            let master_locale = { master_locale: { code: result.code } }
-            config = _.merge(config, master_locale)
-          }
-          return
-        })
+        let type = types[i];
+        var exportedModule = require("./lib/export/" + type);
+        const result = await exportedModule.start(config, branchName);
+        if (result && type === "stack") {
+          let master_locale = { master_locale: { code: result.code } };
+          config = _.merge(config, master_locale);
+        }
       }
-      addlogs(config, chalk.green('The content of the ' + config.source_stack + ' has been exported succesfully!'), 'success')
-      addlogs(config, 'The log for this is stored at ' + path.join(config.data, 'logs', 'export'), 'success')
-      return resolve()
+      addlogs(
+        config,
+        chalk.green(
+          "The content of the " +
+            config.source_stack +
+            " has been exported succesfully!"
+        ),
+        "success"
+      );
+      addlogs(
+        config,
+        "The log for this is stored at " +
+          path.join(config.data, "logs", "export"),
+        "success"
+      );
+      return resolve();
     } catch (error) {
       addlogs(config, chalk.red('Failed to migrate stack: ' + config.source_stack + '. Please check error logs for more info'), 'error')
       addlogs(config, chalk.red(error.errorMessage), 'error')
       addlogs(config, 'The log for this is stored at ' + path.join(config.data, 'logs', 'export'), 'error')
-      return reject()
+      return reject(error)
     }
-  })
-}
+  });
+};

package/src/commands/cm/export.js

@@ -1,25 +1,27 @@
 /* eslint-disable complexity */
-const {Command, flags} = require('@contentstack/cli-command')
-const {configWithMToken,
+const { Command, flags } = require('@contentstack/cli-command')
+const { configWithMToken,
   parameterWithMToken,
   withoutParameterMToken,
   configWithAuthToken,
   parametersWithAuthToken,
   withoutParametersWithAuthToken,
 } = require('../../lib/util/export-flags')
-const Configstore  = require('configstore')
+const Configstore = require('configstore')
 const credStore = new Configstore('contentstack_cli')
 
 class ExportCommand extends Command {
   async run() {
-    const {flags} = this.parse(ExportCommand)
-    const extConfig = flags.config
-    let sourceStack = flags['stack-uid']
-    const alias = flags['management-token-alias']
-    const authToken = flags['auth-token']
-    const securedAssets = flags['secured-assets']
-    const data = flags.data
-    const moduleName = flags.module
+    const exportCommandFlags = this.parse(ExportCommand).flags
+    const extConfig = exportCommandFlags.config
+    let sourceStack = exportCommandFlags['stack-uid']
+    const alias = exportCommandFlags['management-token-alias']
+    const authToken = exportCommandFlags['auth-token']
+    const securedAssets = exportCommandFlags['secured-assets']
+    const data = exportCommandFlags.data
+    const moduleName = exportCommandFlags.module
+    const contentTypes = exportCommandFlags['content-type']
+    const branchName = exportCommandFlags.branch;
     let _authToken = credStore.get('authtoken')
     let host = this.region
     let cmaHost = host.cma.split('//')
@@ -27,14 +29,16 @@ class ExportCommand extends Command {
     host.cma = cmaHost[1]
     host.cda = cdaHost[1]
 
-    if (alias && alias !== undefined) {
+    if (alias) {
       let managementTokens = this.getToken(alias)
-      if (managementTokens && managementTokens !== undefined) {
-        if (extConfig && extConfig !== undefined) {
+      if (managementTokens) {
+        if (extConfig) {
           configWithMToken(
             extConfig,
             managementTokens,
             host,
+            contentTypes,
+            branchName,
             securedAssets
           )
         } else if (data) {
@@ -44,6 +48,8 @@ class ExportCommand extends Command {
             moduleName,
             host,
             _authToken,
+            contentTypes,
+            branchName,
             securedAssets
           )
         } else if (data === undefined && sourceStack === undefined) {
@@ -52,6 +58,8 @@ class ExportCommand extends Command {
             moduleName,
             host,
             _authToken,
+            contentTypes,
+            branchName,
             securedAssets
           )
         } else {
@@ -60,13 +68,15 @@ class ExportCommand extends Command {
       } else {
         this.log(alias + ' management token is not present, please add managment token first')
       }
-    } else if (authToken && authToken !== undefined && _authToken && _authToken !== undefined) {
-      if (extConfig && extConfig !== undefined) {
+    } else if (authToken && _authToken) {
+      if (extConfig) {
         configWithAuthToken(
           extConfig,
           _authToken,
           moduleName,
           host,
+          contentTypes,
+          branchName,
           securedAssets
         )
       } else if (sourceStack && data) {
@@ -76,6 +86,8 @@ class ExportCommand extends Command {
           data,
           moduleName,
           host,
+          contentTypes,
+          branchName,
           securedAssets
         )
       } else if (data === undefined && sourceStack === undefined) {
@@ -83,6 +95,8 @@ class ExportCommand extends Command {
           _authToken,
           moduleName,
           host,
+          contentTypes,
+          branchName,
           securedAssets
         )
       } else {
@@ -107,17 +121,22 @@ ExportCommand.examples = [
   'csdx cm:export -A --secured-assets',
   'csdx cm:export -a <management_token_alias>',
   'csdx cm:export -a <management_token_alias> -d <path/to/export/destination/dir>',
-  'csdx cm:export -a <management_token_alias> -c <path/to/config/file>'
+  'csdx cm:export -a <management_token_alias> -c <path/to/config/file>',
+  'csdx cm:export -A -m <single module name>',
+  'csdx cm:export -A -m <single module name> -t <content type>',
+  'csdx cm:export -A -B [optional] branch name',
 ]
 
 ExportCommand.flags = {
-  config: flags.string({char: 'c', description: '[optional] path of the config'}),
-  'stack-uid': flags.string({char: 's', description: 'API key of the source stack'}),
-  data: flags.string({char: 'd', description: 'path or location to store the data'}),
-  'management-token-alias': flags.string({char: 'a', description: 'alias of the management token'}),
-  'auth-token': flags.boolean({char: 'A', description: 'to use auth token'}),
-  module: flags.string({char: 'm', description: '[optional] specific module name'}),
-  'secured-assets': flags.boolean({description: '[optional] use when assets are secured'}),
+  config: flags.string({ char: 'c', description: '[optional] path of the config' }),
+  'stack-uid': flags.string({ char: 's', description: 'API key of the source stack' }),
+  data: flags.string({ char: 'd', description: 'path or location to store the data' }),
+  'management-token-alias': flags.string({ char: 'a', description: 'alias of the management token' }),
+  'auth-token': flags.boolean({ char: 'A', description: 'to use auth token' }),
+  module: flags.string({ char: 'm', description: '[optional] specific module name' }),
+  'content-type': flags.string({ char: 't', description: '[optional] content type', multiple: true }),
+  branch: flags.string({ char: 'B', description: '[optional] branch name' }),
+  'secured-assets': flags.boolean({ description: '[optional] use when assets are secured' }),
 }
 
 module.exports = ExportCommand

package/src/config/default.js

@@ -21,7 +21,7 @@ module.exports = {
         'code',
         'uid',
         'name',
-        'fallback_locale',
+        'fallback_locale'
       ],
     },
     environments: {
@@ -141,6 +141,9 @@ module.exports = {
       dirName: 'stack',
       fileName: 'stack.json',
     },
+    dependency: {
+      entries: ['stack', 'locales', 'content-types'],
+    },
   },
   languagesCode: [
     'af-za',

package/src/lib/export/assets.js

@@ -37,9 +37,11 @@ function ExportAssets() {
 
 ExportAssets.prototype = {
   start: function (credentialConfig) {
+    this.assetContents = {}
+    this.folderData = []
     let  self = this
     config = credentialConfig
-    assetsFolderPath = path.resolve(config.data, assetConfig.dirName)
+    assetsFolderPath = path.resolve(config.data, (config.branchName || ""), assetConfig.dirName)
     assetContentsFile = path.resolve(assetsFolderPath, 'assets.json')
     folderJSONPath = path.resolve(assetsFolderPath, 'folders.json')
     client = stack.Client(config)
@@ -48,6 +50,7 @@ ExportAssets.prototype = {
     // Create asset folder
     mkdirp.sync(assetsFolderPath)
     return new Promise(function (resolve, reject) {
+      //TBD: getting all the assets should have optimized
       return self.getAssetCount().then(function (count) {
         if (typeof count !== 'number' || count === 0) {
           addlogs(config, 'No assets found', 'success')
@@ -157,7 +160,6 @@ ExportAssets.prototype = {
     })
   },
   getAssetCount: function (folder) {
-    let self = this
     return new Promise(function (resolve, reject) {
       if (folder && typeof folder === 'boolean') {
         let queryOptions = {include_folders: true, query: {'is_dir': true}, include_count: true}
@@ -182,7 +184,6 @@ ExportAssets.prototype = {
     })
   },
   getAssetJSON: function (skip) {
-    let  self = this
     return new Promise(function (resolve, reject) {
       if (typeof skip !== 'number') {
         skip = 0

package/src/lib/export/content-types.js

@@ -35,10 +35,16 @@ function ExportContentTypes() {
 
 ExportContentTypes.prototype = {
   start: function (credentialConfig) {
+    this.content_types = []
     let self = this
     config = credentialConfig
-    contentTypesFolderPath = path.resolve(config.data, contentTypeConfig.dirName)
+    contentTypesFolderPath = path.resolve(config.data, (config.branchName || ""), contentTypeConfig.dirName)
+
     client = stack.Client(config)
+    // If content type id is provided then use it as part of query
+    if (Array.isArray(config.contentTypes) && config.contentTypes.length > 0) {
+      self.requestOptions.qs.uid = {'$in': config.contentTypes}
+    }
     // Create folder for content types
     mkdirp.sync(contentTypesFolderPath)
     addlogs(config, 'Starting content type export', 'success')

package/src/lib/export/entries.js

@@ -42,9 +42,9 @@ function exportEntries() {
 exportEntries.prototype.start = function (credentialConfig) {
   let self = this
   config = credentialConfig
-  entryFolderPath = path.resolve(config.data, config.modules.entries.dirName)
-  localesFilePath = path.resolve(config.data, config.modules.locales.dirName, config.modules.locales.fileName)
-  schemaFilePath = path.resolve(config.data,  config.modules.content_types.dirName, 'schema.json')
+  entryFolderPath = path.resolve(config.data, (config.branchName || ""), config.modules.entries.dirName)
+  localesFilePath = path.resolve(config.data, (config.branchName || ""), config.modules.locales.dirName, config.modules.locales.fileName)
+  schemaFilePath = path.resolve(config.data, (config.branchName || ""), config.modules.content_types.dirName, 'schema.json')
   client = stack.Client(config)
   addlogs(config, 'Starting entry migration', 'success')
   return new Promise(function (resolve, reject) {
@@ -130,7 +130,7 @@ exportEntries.prototype.getEntries = function (apiDetails) {
       },
     }
     client.stack({api_key: config.source_stack, management_token: config.management_token}).contentType(apiDetails.content_type).entry().query(queryrequestObject).find()
-    .then(entriesList => {
+      .then(entriesList => {
       // /entries/content_type_uid/locale.json
       if (!fs.existsSync(path.join(entryFolderPath, apiDetails.content_type))) {
         mkdirp.sync(path.join(entryFolderPath, apiDetails.content_type))
@@ -179,7 +179,7 @@ exportEntries.prototype.getEntries = function (apiDetails) {
           })
         })
       }
-      if (apiDetails.skip > entriesList.items.length) {
+      if (apiDetails.skip > entriesList.count) {
         addlogs(config, 'Exported entries of ' + apiDetails.content_type +
             ' to the ' + apiDetails.locale + ' language successfully', 'success')
         return resolve()

package/src/lib/export/environments.js

@@ -26,11 +26,13 @@ function ExportEnvironments() {
 }
 
 ExportEnvironments.prototype.start = function (mergConfig) {
+  this.master = {}
+  this.environments = {}
   let self = this
   config = mergConfig
   addlogs(config, 'Starting environment export', 'success')
   const environmentConfig = config.modules.environments
-  const environmentsFolderPath = path.resolve(config.data, environmentConfig.dirName)
+  const environmentsFolderPath = path.resolve(config.data, (config.branchName || ""), environmentConfig.dirName)
   // Create folder for environments
   mkdirp.sync(environmentsFolderPath)
   let client = stack.Client(config)

package/src/lib/export/extensions.js

@@ -25,10 +25,12 @@ function ExportExtensions() {
 }
 
 ExportExtensions.prototype.start = function (mergeConfig) {
+  this.master = {}
+  this.extensions = {}
   addlogs(config, 'Starting extension export', 'success')
   let self = this
   config = mergeConfig
-  let extensionsFolderPath = path.resolve(config.data, extensionConfig.dirName)
+  let extensionsFolderPath = path.resolve(config.data, (config.branchName || ""), extensionConfig.dirName)
   // Create folder for extensions
   mkdirp.sync(extensionsFolderPath)
   let client = stack.Client(config)

package/src/lib/export/global-fields.js

@@ -1,113 +1,139 @@
 /*!
-* Contentstack Export
-* Copyright (c) 2019 Contentstack LLC
-* MIT Licensed
-*/
+ * Contentstack Export
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
 
-const mkdirp = require('mkdirp')
-const path = require('path')
-const chalk = require('chalk')
+const mkdirp = require("mkdirp");
+const path = require("path");
+const chalk = require("chalk");
 
-const stack = require('../util/contentstack-management-sdk')
-const helper = require('../util/helper')
-const {addlogs} = require('../util/log')
-
-let config = require('../../config/default')
-const globalfieldsConfig = config.modules.globalfields
-const globalfieldsFolderPath = path.resolve(config.data, globalfieldsConfig.dirName)
-const validKeys = globalfieldsConfig.validKeys
-const limit = 100
-
-// Create folder for Global Fields
-mkdirp.sync(globalfieldsFolderPath)
+const stack = require("../util/contentstack-management-sdk");
+const helper = require("../util/helper");
+const { addlogs } = require("../util/log");
 
+let config = require("../../config/default");
+const limit = 100;
+const validKeys = config.modules.globalfields.validKeys;
+let globalfieldsFolderPath;
+const globalfieldsConfig = config.modules.globalfields;
 function ExportGlobalFields() {
-  this.global_fields = []
+  this.global_fields = [];
   this.requestOptions = {
     qs: {
       include_count: true,
-      asc: 'updated_at',
+      asc: "updated_at",
       limit: limit,
     },
-  }
-  this.master = {}
-  this.globalfields = {}
+  };
+  this.master = {};
+  this.globalfields = {};
 }
 
 ExportGlobalFields.prototype = {
   start: function (credentialConfig) {
-    const self = this
-    config = credentialConfig
-    addlogs(config, 'Starting Global Fields export', 'success')
+    this.master = {};
+    this.globalfields = {};
+    config = {...config, ...credentialConfig};
+    globalfieldsFolderPath = path.resolve(
+      config.data,
+      (config.branchName || ""),
+      globalfieldsConfig.dirName
+    );
+    // Create folder for Global Fields
+    mkdirp.sync(globalfieldsFolderPath);
+    const self = this;
+    addlogs(config, "Starting Global Fields export", "success");
     return new Promise(function (resolve, reject) {
       try {
-        return self.getGlobalFields(null, config).then(function (result) {
-          if (!result) {
-            return self.writeGlobalFields().then(result => {
-              return resolve()
-            }).catch(error => {
-              return reject(error)
-            })
-          }
-          return resolve()
-        }).catch(error => {
-          return reject(error)
-        })
+        return self
+          .getGlobalFields(null, config)
+          .then(function (result) {
+            if (!result) {
+              return self
+                .writeGlobalFields()
+                .then(() => {
+                  return resolve();
+                })
+                .catch((error) => {
+                  return reject(error);
+                });
+            }
+            return resolve();
+          })
+          .catch((error) => {
+            return reject(error);
+          });
       } catch (error) {
-        return reject(error)
+        return reject(error);
       }
-    })
+    });
   },
-  getGlobalFields: function (skip, config) {
-    const self = this
-    if (typeof skip !== 'number') {
-      skip = 0
-      self.requestOptions.qs.skip = skip
+  getGlobalFields: function (skip, globalFieldConfig) {
+    const self = this;
+    if (typeof skip !== "number") {
+      skip = 0;
+      self.requestOptions.qs.skip = skip;
     } else {
-      self.requestOptions.qs.skip = skip
+      self.requestOptions.qs.skip = skip;
     }
-    
-    let client = stack.Client(config)
+
+    let client = stack.Client(globalFieldConfig);
     return new Promise(function (resolve, reject) {
-      client.stack({api_key: config.source_stack, management_token: config.management_token}).globalField().query(self.requestOptions.qs).find()
-      .then(globalFieldResponse => {
-        try {
-          if (globalFieldResponse.items.length === 0) {
-            addlogs(config, 'No global fields found', 'success')
-            return resolve('No Global Fields')
-          }
-          globalFieldResponse.items.forEach(function (globalField) {
-            for (const key in globalField) {
-              if (validKeys.indexOf(key) === -1) {
-                delete globalField[key]
-              }
+      client
+        .stack({
+          api_key: globalFieldConfig.source_stack,
+          management_token: globalFieldConfig.management_token,
+        })
+        .globalField()
+        .query(self.requestOptions.qs)
+        .find()
+        .then((globalFieldResponse) => {
+          try {
+            if (globalFieldResponse.items.length === 0) {
+              addlogs(globalFieldConfig, "No global fields found", "success");
+              return resolve("No Global Fields");
             }
-            self.global_fields.push(globalField)
-          })
+            globalFieldResponse.items.forEach(function (globalField) {
+              for (const key in globalField) {
+                if (validKeys.indexOf(key) === -1) {
+                  delete globalField[key];
+                }
+              }
+              self.global_fields.push(globalField);
+            });
 
-          skip += limit
+            skip += limit;
 
-          if (skip > globalFieldResponse.count) {
-            return resolve()
-          }
+            if (skip > globalFieldResponse.count) {
+              return resolve();
+            }
 
-          return self.getGlobalFields(skip, config)
-          .then(resolve)
-          .catch(reject)
-        } catch (error) {
-          return reject(error)
-        }
-      })
-    })
+            return self
+              .getGlobalFields(skip, globalFieldConfig)
+              .then(resolve)
+              .catch(reject);
+          } catch (error) {
+            return reject(error);
+          }
+        });
+    });
   },
   writeGlobalFields: function () {
-    const self = this
+    const self = this;
     return new Promise(function (resolve) {
-      helper.writeFile(path.join(globalfieldsFolderPath, globalfieldsConfig.fileName), self.global_fields)
-      addlogs(config, chalk.green('Global Fields export completed successfully'), 'success')
-      return resolve()
-    })
+      helper.writeFile(
+        path.join(globalfieldsFolderPath, globalfieldsConfig.fileName),
+        self.global_fields
+      );
+      addlogs(
+        config,
+        chalk.green("Global Fields export completed successfully"),
+        "success"
+      );
+      return resolve();
+    });
   },
-}
+};
 
-module.exports = new ExportGlobalFields()
+module.exports = new ExportGlobalFields();

package/src/lib/export/labels.js

@@ -28,10 +28,11 @@ function ExportLabels() {
 
 ExportLabels.prototype.start = function (credentialConfig) {
   addlogs(config, 'Starting labels export', 'success')
+  this.labels = {}
   let self = this
   config = credentialConfig
   client = stack.Client(config)
-  let labelsFolderPath = path.resolve(config.data, labelConfig.dirName)
+  let labelsFolderPath = path.resolve(config.data, (config.branchName || ""), labelConfig.dirName)
   // Create locale folder
   mkdirp.sync(labelsFolderPath)
   return new Promise(function (resolve, reject) {

package/src/lib/export/locales.js

@@ -34,10 +34,11 @@ function ExportLocales() {
 }
 
 ExportLocales.prototype.start = function (credentialConfig) {
+  this.locales = {}
   addlogs(credentialConfig, 'Starting locale export', 'success')
   let self = this
   config = credentialConfig
-  let localesFolderPath = path.resolve(config.data, localeConfig.dirName)
+  let localesFolderPath = path.resolve(config.data, (config.branchName || ""), localeConfig.dirName)
   mkdirp.sync(localesFolderPath)
 
   let client = stack.Client(config)

package/src/lib/export/webhooks.js

@@ -29,10 +29,12 @@ function ExportWebhooks() {
 
 ExportWebhooks.prototype.start = function (credentialConfig) {
   addlogs(config, 'Starting webhooks export', 'success')
+  this.master = {}
+  this.webhooks = {}
   let self = this
   config = credentialConfig
   client = stack.Client(config)
-  const webhooksFolderPath = path.resolve(config.data, webhooksConfig.dirName)
+  const webhooksFolderPath = path.resolve(config.data, (config.branchName || ""), webhooksConfig.dirName)
   mkdirp.sync(webhooksFolderPath)
   return new Promise(function (resolve, reject) {
     client.stack({api_key: config.source_stack, management_token: config.management_token}).webhook().fetchAll(self.requestOptions)

package/src/lib/export/workflows.js

@@ -22,11 +22,12 @@ function ExportWorkFlows() {
 
 ExportWorkFlows.prototype.start = function (credentialConfig) {
   addlogs(config, 'Starting workflow export', 'success')
+  this.workflows = {}
   let self = this
   config = credentialConfig
   client = stack.Client(config)
 
-  let workflowsFolderPath = path.resolve(config.data, workFlowConfig.dirName)
+  let workflowsFolderPath = path.resolve(config.data, (config.branchName || ""), workFlowConfig.dirName)
   mkdirp.sync(workflowsFolderPath)
   return new Promise(function (resolve, reject) {
     return client.stack({api_key: config.source_stack, management_token: config.management_token}).workflow().fetchAll()
@@ -49,9 +50,9 @@ ExportWorkFlows.prototype.start = function (credentialConfig) {
       if (error.statusCode === 401) {
         addlogs(config, chalk.red('You are not allowed to export workflow, Unless you provide email and password in config', 'error'))
         return resolve()
-      }
+      } 
       addlogs(config, error, 'error')
-      return reject()
+      return resolve()
     })
   })
 }

package/src/lib/util/contentstack-management-sdk.js

@@ -8,6 +8,12 @@ exports.Client = function (config) {
     logHandler: (level, data) => {},
   }
 
+  if (typeof config.branchName === 'string') {
+    option.headers = {
+      branch: config.branchName,
+    }
+  }
+
   const client = contentstacksdk.client(option)
   return client
 }

package/src/lib/util/export-flags.js

@@ -11,24 +11,45 @@ const helper = require('../util/helper');
 let _ = require('lodash')
 const {cli} = require('cli-ux')
 
-exports.configWithMToken = function (config, managementTokens, host, securedAssets) {
+exports.configWithMToken = function (config, managementTokens, host, contentTypes, branchName, securedAssets) {
   let externalConfig = require(config)
   defaultConfig.securedAssets = securedAssets
   defaultConfig.management_token = managementTokens.token
   defaultConfig.host = host.cma
   defaultConfig.cdn = host.cda
+  defaultConfig.branchName = branchName
+  if (moduleName) {
+    defaultConfig.moduleName = moduleName
+    // Specfic content type setting is only for entries module
+    if (
+        moduleName === 'entries' &&
+        Array.isArray(contentTypes) &&
+        contentTypes.length > 0
+      ) {
+          defaultConfig.contentTypes = contentTypes
+      }
+  }
   defaultConfig = _.merge(defaultConfig, externalConfig)
   initial(defaultConfig)
 }
 
-exports.parameterWithMToken = function (managementTokens, data, moduleName, host, _authToken, securedAssets) {
+exports.parameterWithMToken = function (managementTokens, data, moduleName, host, _authToken, contentTypes, branchName, securedAssets) {
   defaultConfig.management_token = managementTokens.token
   defaultConfig.auth_token = _authToken
   defaultConfig.host = host.cma
   defaultConfig.cdn = host.cda
+  defaultConfig.branchName = branchName
   defaultConfig.securedAssets = securedAssets
-  if (moduleName && moduleName !== undefined) {
+  if (moduleName) {
     defaultConfig.moduleName = moduleName
+    // Specfic content type setting is only for entries module
+    if (
+      moduleName === 'entries' &&
+      Array.isArray(contentTypes) &&
+      contentTypes.length > 0
+    ) {
+      defaultConfig.contentTypes = contentTypes
+    }
   }
   defaultConfig.source_stack = managementTokens.apiKey
   defaultConfig.data = data
@@ -36,42 +57,69 @@ exports.parameterWithMToken = function (managementTokens, data, moduleName, host
 }
 
 // using ManagementToken
-exports.withoutParameterMToken = async (managementTokens, moduleName, host, _authToken, securedAssets) => {
+exports.withoutParameterMToken = async (managementTokens, moduleName, host, _authToken, contentTypes, branchName, securedAssets) => {
   const stackUid = managementTokens.apiKey
   const pathOfExport = await cli.prompt(message.promptMessageList.promptPathStoredData)
   defaultConfig.management_token = managementTokens.token
   defaultConfig.host = host.cma
   defaultConfig.cdn = host.cda
+  defaultConfig.branchName = branchName
   defaultConfig.auth_token = _authToken
   defaultConfig.securedAssets = securedAssets
-  if (moduleName && moduleName !== undefined) {
+  if (moduleName) {
     defaultConfig.moduleName = moduleName
+    // Specfic content type setting is only for entries module
+    if (
+      moduleName === 'entries' &&
+      Array.isArray(contentTypes) &&
+      contentTypes.length > 0
+    ) {
+      defaultConfig.contentTypes = contentTypes
+    }
   }
   defaultConfig.source_stack = stackUid
   defaultConfig.data = pathOfExport
   initial(defaultConfig)
 }
 
-exports.configWithAuthToken = function (config, _authToken, moduleName, host, securedAssets) {
+exports.configWithAuthToken = function (config, _authToken, moduleName, host, contentTypes, branchName, securedAssets) {
   let externalConfig = helper.readFile(path.resolve(config))
   defaultConfig.auth_token = _authToken
   defaultConfig.host = host.cma
   defaultConfig.cdn = host.cda
+  defaultConfig.branchName = branchName
   defaultConfig.securedAssets = securedAssets
-  if (moduleName && moduleName !== undefined) {
+  if (moduleName) {
     defaultConfig.moduleName = moduleName
+    // Specfic content type setting is only for entries module
+    if (
+      moduleName === 'entries' &&
+      Array.isArray(contentTypes) &&
+      contentTypes.length > 0
+    ) {
+      defaultConfig.contentTypes = contentTypes
+    }
   }
   defaultConfig = _.merge(defaultConfig, externalConfig)
   initial(defaultConfig)
 }
 
-exports.parametersWithAuthToken = function (_authToken, sourceStack, data, moduleName, host, securedAssets) {
+exports.parametersWithAuthToken = function (_authToken, sourceStack, data, moduleName, host, contentTypes, branchName, securedAssets) {
   return new Promise(async(resolve, reject) => {
     defaultConfig.auth_token = _authToken
     defaultConfig.source_stack = sourceStack
-    if (moduleName && moduleName !== undefined) {
+    if (moduleName) {
       defaultConfig.moduleName = moduleName
+      // Specfic content type setting is only for entries module
+      if (
+        moduleName === 'entries' &&
+        Array.isArray(contentTypes) &&
+        contentTypes.length > 0
+      ) {
+        defaultConfig.contentTypes = contentTypes
+      }
     }
+    defaultConfig.branchName = branchName
     defaultConfig.host = host.cma
     defaultConfig.cdn = host.cda
     defaultConfig.data = data
@@ -85,15 +133,24 @@ exports.parametersWithAuthToken = function (_authToken, sourceStack, data, modul
   })
 }
 
-exports.withoutParametersWithAuthToken = async (_authToken, moduleName, host, securedAssets) => {
+exports.withoutParametersWithAuthToken = async (_authToken, moduleName, host, contentTypes, branchName, securedAssets) => {
   const stackUid = await cli.prompt(message.promptMessageList.promptSourceStack)
   const pathOfExport = await cli.prompt(message.promptMessageList.promptPathStoredData)
   defaultConfig.auth_token = _authToken
   defaultConfig.source_stack = stackUid
   defaultConfig.securedAssets = securedAssets
-  if (moduleName && moduleName !== undefined) {
+  if (moduleName) {
     defaultConfig.moduleName = moduleName
+    // Specfic content type setting is only for entries module
+    if (
+      moduleName === 'entries' &&
+      Array.isArray(contentTypes) &&
+      contentTypes.length > 0
+    ) {
+      defaultConfig.contentTypes = contentTypes
+    }
   }
+  defaultConfig.branchName = branchName
   defaultConfig.data = pathOfExport
   defaultConfig.host = host.cma
   defaultConfig.cdn = host.cda

package/src/lib/util/login.js

@@ -18,7 +18,7 @@ module.exports.login = config => {
     if (config.email && config.password) {
       // eslint-disable-next-line no-console
       console.log('Logging into Contentstack')
-      return client.login({email: config.email, password: config.password})
+      client.login({email: config.email, password: config.password})
       .then(function (response) {
         // eslint-disable-next-line no-console
         console.log(chalk.green('Contentstack account authenticated successfully!'))
@@ -29,11 +29,11 @@ module.exports.login = config => {
           authtoken: config.authtoken,
           'X-User-Agent': 'contentstack-export/v',
         }
-        return resolve(config)
+         resolve(config)
       }).catch(function (error) {
-        return reject(error)
+         reject(error)
       })
-    } if (!config.email && !config.password && config.source_stack && config.access_token) {
+    } else if (!config.email && !config.password && config.source_stack && config.access_token) {
       addlogs(config, chalk.yellow('Content types, entries, assets, labels, global fields, extensions modules will be exported'), 'success')
       addlogs(config, chalk.yellow('Email, password, or management token is not set in the config, cannot export Webhook and label modules'), 'success')
       config.headers = {
@@ -41,21 +41,21 @@ module.exports.login = config => {
         access_token: config.access_token,
         'X-User-Agent': 'contentstack-export/v',
       }
-      return resolve(config)
+      resolve(config)
     // eslint-disable-next-line no-else-return
     } else if (config.auth_token && !config.management_token) {
       client.stack({api_key: config.source_stack, management_token: config.management_token}).users()
       .then(function () {
-        return resolve()
+        resolve()
       }).catch(error => {
         if (error.errors.api_key) {
           return reject(error)
         }
         addlogs(config, error.errorMessage, 'error')
-        return reject(error)
+        reject(error)
       })
     } else if (config.management_token) {
-      return resolve()
+      resolve()
     }
   })
 }

package/src/lib/util/request.js

@@ -8,7 +8,6 @@
 
 var Bluebird = require('bluebird');
 var request = Bluebird.promisify(require('request'));
-var debug = require('debug')('util:requests');
 //var pkg = require('../../package');
 var app = require('../../app');
 
@@ -22,14 +21,12 @@ function validate(req) {
     throw new Error(`Missing uri in request!\n${JSON.stringify(req)}`);
   }
   if (typeof req.method === 'undefined') {
-    debug(`${req.uri || req.url} had no method, setting it as 'GET'`);
     req.method = 'GET';
   }
   if (typeof req.json === 'undefined') {
     req.json = true;
   }
   if (typeof req.headers === 'undefined') {
-    debug(`${req.uri || req.url} had no headers`);
     var config = app.getConfig();
     req.headers = config.headers;
   }
@@ -44,25 +41,25 @@ var makeCall = module.exports = function(req, RETRY) {
       } else if (RETRY > MAX_RETRY_LIMIT) {
         return reject(new Error('Max retry limit exceeded!'));
       }
-      debug(`${req.method.toUpperCase()}: ${req.uri || req.url}`);
+      // console.log(`${req.method.toUpperCase()}: ${req.uri || req.url}`);
       return request(req).then(function (response) {
         var timeDelay;
         if (response.statusCode >= 200 && response.statusCode <= 399) {
           return resolve(response);
         } else if (response.statusCode === 429) {
           timeDelay = Math.pow(Math.SQRT2, RETRY) * 100;
-          debug(`API rate limit exceeded.\nReceived ${response.statusCode} status\nBody ${JSON.stringify(response)}`);
-          debug(`Retrying ${req.uri || req.url} with ${timeDelay} sec delay`);
-          return setTimeout(function (req, RETRY) {
-            return makeCall(req, RETRY)
+          // console.log(`API rate limit exceeded.\nReceived ${response.statusCode} status\nBody ${JSON.stringify(response)}`);
+          console.log(`Retrying ${req.uri || req.url} with ${timeDelay} sec delay`);
+          return setTimeout(function (reqObj, retry) {
+            return makeCall(reqObj, retry)
               .then(resolve)
               .catch(reject);
           }, timeDelay, req, RETRY);
         } else if (response.statusCode >= 500) {
           // retry, with delay
           timeDelay = Math.pow(Math.SQRT2, RETRY) * 100;
-          debug(`Recevied ${response.statusCode} status\nBody ${JSON.stringify(response)}`);
-          debug(`Retrying ${req.uri || req.url} with ${timeDelay} sec delay`);
+          // console.log(`Recevied ${response.statusCode} status\nBody ${JSON.stringify(response)}`);
+          console.log(`Retrying ${req.uri || req.url} with ${timeDelay} sec delay`);
           RETRY++;
           return setTimeout(function (req, RETRY) {
             return makeCall(req, RETRY)
@@ -70,13 +67,11 @@ var makeCall = module.exports = function(req, RETRY) {
               .catch(reject);
           }, timeDelay, req, RETRY);
         } else {
-          debug(`Request failed\n${JSON.stringify(req)}`);
-          debug(`Response received\n${JSON.stringify(response)}`);
           return reject(response);
         }
       }).catch(reject);
     } catch (error) {
-      debug(error);
+      console.log(error);
       return reject(error);
     }
   });

package/src/lib/util/setup-branches.js

@@ -0,0 +1,62 @@
+const mkdirp = require("mkdirp");
+const path = require("path");
+const request = require("./request");
+const helper = require("./helper");
+
+const setupBranches = async (config, branch) => {
+  if (typeof config !== "object") {
+    throw new Error("Invalid config to setup the branch");
+  }
+  let branches = [];
+
+  if (typeof branch === "string") {
+    //check branch exists
+    const result = await request({
+      url: `https://${config.host}/v3/stacks/branches/${branch}`,
+      headers: {
+        api_key: config.source_stack,
+        authtoken: config.auth_token,
+      },
+    });
+    if (
+      result &&
+      typeof result.body === "object" &&
+      typeof result.body.branch === "object"
+    ) {
+      branches.push(result.body.branch);
+    } else {
+      throw new Error("No branch found with the name " + branch);
+    }
+  } else {
+    try {
+      const result = await request({
+        url: `https://${config.host}/v3/stacks/branches`,
+        headers: {
+          api_key: config.source_stack,
+          authtoken: config.auth_token,
+        },
+      });
+
+      if (
+        result &&
+        result.body &&
+        Array.isArray(result.body.branches) &&
+        result.body.branches.length > 0
+      ) {
+        branches = result.body.branches;
+      } else {
+        branches.push("main");
+      }
+    } catch (error) {
+      return;
+    }
+  }
+
+  mkdirp.sync(config.data);
+  // create branch info file
+  helper.writeFile(path.join(config.data, "branches.json"), branches);
+  // add branches list in the
+  config.branches = branches;
+};
+
+module.exports = setupBranches;