@contentstack/cli-cm-export 0.1.1-beta.1 → 0.1.1-beta.12

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

@@ -5,6 +5,13 @@ exports.Client = function (config) {
     host: config.host,
     authtoken: config.auth_token,
     api_key: config.source_stack,
+    logHandler: (level, data) => {},
+  }
+
+  if (typeof config.branchName === 'string') {
+    option.headers = {
+      branch: config.branchName,
+    }
   }
 
   const client = contentstacksdk.client(option)

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

@@ -6,89 +6,153 @@
 let defaultConfig = require('../../config/default')
 let message = require('../../../messages/index.json')
 let {initial} = require('../../app')
+let path = require('path')
+const helper = require('../util/helper');
 let _ = require('lodash')
 const {cli} = require('cli-ux')
 
-exports.configWithMToken = function (config, managementTokens, host) {
+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 (masterLang, managementTokens, sourceStack, data, moduleName, host) {
-  let masterloc = {master_locale: {code: masterLang}}
+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
-  if (moduleName && moduleName !== undefined) {
+  defaultConfig.branchName = branchName
+  defaultConfig.securedAssets = securedAssets
+  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 = sourceStack
+  defaultConfig.source_stack = managementTokens.apiKey
   defaultConfig.data = data
-  defaultConfig = _.merge(defaultConfig, masterloc)
   initial(defaultConfig)
 }
 
 // using ManagementToken
-exports.withoutParameterMToken = async (managementTokens, moduleName, host) => {
-  const masterLocale = await cli.prompt(message.promptMessageList.promptMasterLocale)
+exports.withoutParameterMToken = async (managementTokens, moduleName, host, _authToken, contentTypes, branchName, securedAssets) => {
   const stackUid = managementTokens.apiKey
   const pathOfExport = await cli.prompt(message.promptMessageList.promptPathStoredData)
-  let masterloc = {master_locale: {code: masterLocale}}
   defaultConfig.management_token = managementTokens.token
   defaultConfig.host = host.cma
   defaultConfig.cdn = host.cda
-  if (moduleName && moduleName !== undefined) {
+  defaultConfig.branchName = branchName
+  defaultConfig.auth_token = _authToken
+  defaultConfig.securedAssets = securedAssets
+  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
-  defaultConfig = _.merge(defaultConfig, masterloc)
   initial(defaultConfig)
 }
 
-exports.configWithAuthToken = function (config, _authToken, moduleName, host) {
-  let externalConfig = require(config)
+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
-  if (moduleName && moduleName !== undefined) {
+  defaultConfig.branchName = branchName
+  defaultConfig.securedAssets = securedAssets
+  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 (masterLang, _authToken, sourceStack, data, moduleName, host) {
-  let masterloc = {master_locale: {code: masterLang}}
-  defaultConfig.auth_token = _authToken
-  defaultConfig.source_stack = sourceStack
-  if (moduleName && moduleName !== undefined) {
-    defaultConfig.moduleName = moduleName
-  }
-  defaultConfig.host = host.cma
-  defaultConfig.cdn = host.cda
-  defaultConfig.data = data
-  defaultConfig = _.merge(defaultConfig, masterloc)
-  initial(defaultConfig)
+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) {
+      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
+    defaultConfig.securedAssets = securedAssets
+    var exportStart = initial(defaultConfig)
+    exportStart.then(() => {
+      return resolve()
+    }).catch((error) => {
+      return reject(error)
+    })
+  })
 }
 
-exports.withoutParametersWithAuthToken = async (_authToken, moduleName, host) => {
-  const masterLocale = await cli.prompt(message.promptMessageList.promptMasterLocale)
+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)
-  let masterloc = {master_locale: {code: masterLocale}}
   defaultConfig.auth_token = _authToken
   defaultConfig.source_stack = stackUid
-  if (moduleName && moduleName !== undefined) {
+  defaultConfig.securedAssets = securedAssets
+  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
-  defaultConfig = _.merge(defaultConfig, masterloc)
   initial(defaultConfig)
 }

package/src/lib/util/index.js

@@ -23,14 +23,10 @@ exports.validateConfig = function (config) {
   } else if (!config.email && !config.password && config.preserveStackVersion) {
     throw new Error('Kindly provide Email and password for stack details')
   }
-  
-  if(!config.languagesCode.includes(config.master_locale.code)) {
-     addlogs(config, chalk.red('Kindly provide valid master_locale code'), 'error')
-    process.exit()
-  }
 }
 
 exports.buildAppConfig = function (config) {
   config = _.merge(defaultConfig, config)
   return config
 }
+

package/src/lib/util/log.js

@@ -24,12 +24,11 @@ function returnString(args) {
 
 var myCustomLevels = {
   levels: {
-    error: 0,
     warn: 1,
     info: 2,
     debug: 3,
   },
-  colors: {
+  colors: { //colors aren't being used anywhere as of now, we're using chalk to add colors while logging
     info: 'blue',
     debug: 'green',
     warn: 'yellow',
@@ -37,26 +36,52 @@ var myCustomLevels = {
   },
 }
 
-function init (_logPath, logfileName) {
-  var logsDir = path.resolve(_logPath, 'logs', 'export')
-  // Create dir if doesn't already exist
-  mkdirp.sync(logsDir)
-  var logPath = path.join(logsDir, logfileName + '.log')
+let logger
+let errorLogger
 
-  var transports = [new (winston.transports.File)({
-    filename: logPath,
-    maxFiles: 20,
-    maxsize: 1000000,
-    tailable: true,
-    json: true,
-  })]
+let successTransport
+let errorTransport
 
-  transports.push(new (winston.transports.Console)())
+function init(_logPath) {
+  if (!logger || !errorLogger) {
+    var logsDir = path.resolve(_logPath, 'logs', 'export')
+    // Create dir if doesn't already exist
+    mkdirp.sync(logsDir)
 
-  var logger = new(winston.Logger)({
-    transports: transports,
-    levels: myCustomLevels.levels
-  })
+    successTransport = {
+      filename: path.join(logsDir, 'success.log'),
+      maxFiles: 20,
+      maxsize: 1000000,
+      tailable: true,
+      json: true,
+      level: 'info',
+    }
+
+    errorTransport = {
+      filename: path.join(logsDir, 'error.log'),
+      maxFiles: 20,
+      maxsize: 1000000,
+      tailable: true,
+      json: true,
+      level: 'error',
+    }
+
+    logger = new (winston.Logger)({
+      transports: [
+        new (winston.transports.File)(successTransport),
+        new (winston.transports.Console)()
+      ],
+      levels: myCustomLevels.levels
+    });
+
+    errorLogger = new (winston.Logger)({
+      transports: [
+        new (winston.transports.File)(errorTransport),
+        new (winston.transports.Console)({ level: 'error' })
+      ],
+      levels: { error: 0 }
+    })
+  }
 
   return {
     log: function () {
@@ -77,7 +102,7 @@ function init (_logPath, logfileName) {
       var args = slice.call(arguments)
       var logString = returnString(args)
       if (logString) {
-        logger.log('error', logString)
+        errorLogger.log('error', logString)
       }
     },
     debug: function () {
@@ -91,10 +116,23 @@ function init (_logPath, logfileName) {
 }
 
 exports.addlogs = async (config, message, type) => {
-  // console.log("datattaat", data)
+  // ignoring the type argument, as we are not using it to create a logfile anymore
   if (type !== 'error') {
-    init(config.data, type).log(message)
+    // removed type argument from init method
+    init(config.data).log(message)
   } else {
-    init(config.data, type).error(message)
+    init(config.data).error(message)
   }
 }
+
+exports.unlinkFileLogger = () => {
+  if (logger) {
+    const fileLogger = logger.transports.file
+    logger.remove(fileLogger)
+  }
+
+  if (errorLogger) {
+    const fileLogger = errorLogger.transports.file
+    errorLogger.remove(fileLogger)
+  }
+}

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,22 +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) {
+    } 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()
-      })
-      .catch(error => {
+        resolve()
+      }).catch(error => {
         if (error.errors.api_key) {
           return reject(error)
         }
         addlogs(config, error.errorMessage, 'error')
-        return reject()
+        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;