@contentstack/cli-cm-export 1.2.3 → 1.4.0

package/src/lib/export/stack.js

@@ -4,102 +4,96 @@
  * MIT Licensed
  */
 
-let path = require('path');
-let mkdirp = require('mkdirp');
+const path = require('path');
+const mkdirp = require('mkdirp');
+const { merge } = require('lodash');
+const helper = require('../util/helper');
+const { addlogs } = require('../util/log');
+const config = require('../../config/default');
+const { managementSDKClient } = require('@contentstack/cli-utilities');
+module.exports = class ExportStack {
+  stackConfig = config.modules.stack;
 
-let helper = require('../util/helper');
-let { addlogs } = require('../util/log');
-let config = require('../../config/default');
-const stack = require('../util/contentstack-management-sdk');
+  constructor(exportConfig, stackAPIClient, APIClient) {
+    this.config = merge(config, exportConfig);
+    this.stackAPIClient = stackAPIClient;
+    this.APIClient = APIClient;
+    this.requestOption = {
+      uri: this.config.host + this.config.apis.stacks,
+      headers: this.config.headers,
+      json: true,
+    };
+  }
 
-let client;
-let stackConfig = config.modules.stack;
+  async start() {
+    const self = this;
+    if (self.config.auth_token) {
+      const tempAPIClient = await managementSDKClient({ host: config.host });
+      const tempStackData = await tempAPIClient
+        .stack({ api_key: self.config.source_stack })
+        .fetch()
+        .catch((error) => {
+          console.log(error);
+        });
 
-function ExportStack() {
-  this.requestOption = {
-    uri: config.host + config.apis.stacks,
-    headers: config.headers,
-    json: true,
-  };
-}
+      if (tempStackData && tempStackData.org_uid) {
+        self.config.org_uid = tempStackData.org_uid;
+        self.config.sourceStackName = tempStackData.name;
+      }
+    }
 
-ExportStack.prototype.start = async function (credentialConfig) {
-  config = credentialConfig;
-  client = stack.Client(config);
-  const self = this;
+    if (!self.config.preserveStackVersion && !self.config.hasOwnProperty('master_locale')) {
+      const apiDetails = {
+        limit: 100,
+        skip: 0,
+        include_count: true,
+      };
+      return self.getLocales(apiDetails);
+    } else if (self.config.preserveStackVersion) {
+      addlogs(self.config, 'Exporting stack details', 'success');
+      let stackFolderPath = path.resolve(self.config.data, stackConfig.dirName);
+      let stackContentsFile = path.resolve(stackFolderPath, stackConfig.fileName);
 
-  // NOTE get org uid
-  if (config.auth_token) {
-    const stack = await client
-      .stack({ api_key: config.source_stack, authtoken: config.auth_token })
-      .fetch()
-      .catch((error) => {
-        console.log(error);
-      });
+      mkdirp.sync(stackFolderPath);
 
-    if (stack && stack.org_uid) {
-      config.org_uid = stack.org_uid;
-      config.sourceStackName = stack.name;
+      return new Promise((resolve, reject) => {
+        return self.APIClient.stack({ api_key: self.config.source_stack })
+          .fetch()
+          .then((response) => {
+            helper.writeFile(stackContentsFile, response);
+            addlogs(self.config, 'Exported stack details successfully!', 'success');
+            return resolve(response);
+          })
+          .catch(reject);
+      });
     }
   }
 
-  if (!config.preserveStackVersion && !config.hasOwnProperty('master_locale')) {
-    const apiDetails = {
-      limit: 100,
-      skip: 0,
-      include_count: true,
-    };
-    return self.getLocales(apiDetails);
-  } else if (config.preserveStackVersion) {
-    addlogs(config, 'Exporting stack details', 'success');
-    let stackFolderPath = path.resolve(config.data, stackConfig.dirName);
-    let stackContentsFile = path.resolve(stackFolderPath, stackConfig.fileName);
-
-    mkdirp.sync(stackFolderPath);
-
+  getLocales(apiDetails) {
+    const self = this;
     return new Promise((resolve, reject) => {
-      return client
-        .stack({ api_key: config.source_stack })
-        .fetch()
+      const result = self.stackAPIClient.locale().query(apiDetails);
+
+      result
+        .find()
         .then((response) => {
-          helper.writeFile(stackContentsFile, response);
-          addlogs(config, 'Exported stack details successfully!', 'success');
-          return resolve(response);
+          const masterLocalObj = response.items.find((obj) => {
+            if (obj.fallback_locale === null) {
+              return obj;
+            }
+          });
+          apiDetails.skip += apiDetails.limit;
+          if (masterLocalObj) {
+            return resolve(masterLocalObj);
+          } else if (apiDetails.skip <= response.count) {
+            return resolve(self.getLocales(apiDetails));
+          } else {
+            return reject('Master locale not found');
+          }
         })
-        .catch(reject);
+        .catch((error) => {
+          return reject(error);
+        });
     });
   }
 };
-
-ExportStack.prototype.getLocales = function (apiDetails) {
-  let self = this;
-  return new Promise((resolve, reject) => {
-    const result = client
-      .stack({ api_key: config.source_stack, management_token: config.management_token })
-      .locale()
-      .query(apiDetails);
-
-    result
-      .find()
-      .then((response) => {
-        const masterLocalObj = response.items.find((obj) => {
-          if (obj.fallback_locale === null) {
-            return obj;
-          }
-        });
-        apiDetails.skip += apiDetails.limit;
-        if (masterLocalObj) {
-          return resolve(masterLocalObj);
-        } else if (apiDetails.skip <= response.count) {
-          return resolve(self.getLocales(apiDetails));
-        } else {
-          return reject('Master locale not found');
-        }
-      })
-      .catch((error) => {
-        return reject(error);
-      });
-  });
-};
-
-module.exports = ExportStack;

package/src/lib/export/webhooks.js

@@ -13,9 +13,6 @@ const helper = require('../util/helper');
 const { formatError } = require('../util');
 const { addlogs } = require('../util/log');
 const config = require('../../config/default');
-const stack = require('../util/contentstack-management-sdk');
-
-// Create folder for environments
 
 module.exports = class ExportWebhooks {
   config;
@@ -27,15 +24,14 @@ module.exports = class ExportWebhooks {
   };
   webhooksConfig = config.modules.webhooks;
 
-  constructor(credentialConfig) {
-    this.config = merge(config, credentialConfig);
+  constructor(exportConfig, stackAPIClient) {
+    this.stackAPIClient = stackAPIClient;
+    this.config = merge(config, exportConfig);
   }
 
   start() {
     addlogs(this.config, 'Starting webhooks export', 'success');
-
     const self = this;
-    const client = stack.Client(this.config);
     const webhooksFolderPath = path.resolve(
       this.config.data,
       this.config.branchName || '',
@@ -43,8 +39,7 @@ module.exports = class ExportWebhooks {
     );
     mkdirp.sync(webhooksFolderPath);
     return new Promise((resolve, reject) => {
-      client
-        .stack({ api_key: self.config.source_stack, management_token: self.config.management_token })
+      self.stackAPIClient
         .webhook()
         .fetchAll(self.requestOptions)
         .then((webhooks) => {

package/src/lib/export/workflows.js

@@ -13,30 +13,31 @@ const helper = require('../util/helper');
 const { addlogs } = require('../util/log');
 const { formatError } = require('../util');
 const config = require('../../config/default');
-const stack = require('../util/contentstack-management-sdk');
 
 module.exports = class ExportWorkFlows {
-  client;
   config;
   workflows = {};
   workFlowConfig = config.modules.workflows;
 
-  constructor(credentialConfig) {
-    this.config = merge(config, credentialConfig);
+  constructor(exportConfig, stackAPIClient) {
+    this.stackAPIClient = stackAPIClient;
+    this.config = merge(config, exportConfig);
   }
 
   start() {
     addlogs(this.config, 'Starting workflow export', 'success');
 
     const self = this;
-    this.client = stack.Client(this.config);
-    let workflowsFolderPath = path.resolve(this.config.data, this.config.branchName || '', this.workFlowConfig.dirName);
+    const workflowsFolderPath = path.resolve(
+      this.config.data,
+      this.config.branchName || '',
+      this.workFlowConfig.dirName,
+    );
 
     mkdirp.sync(workflowsFolderPath);
 
     return new Promise(function (resolve, reject) {
-      return self.client
-        .stack({ api_key: self.config.source_stack, management_token: self.config.management_token })
+      return self.stackAPIClient
         .workflow()
         .fetchAll()
         .then(async (response) => {
@@ -78,8 +79,7 @@ module.exports = class ExportWorkFlows {
         if (stage.SYS_ACL.roles.uids.length) {
           for (let i = 0; i < stage.SYS_ACL.roles.uids.length; i++) {
             const roleUid = stage.SYS_ACL.roles.uids[i];
-            const roleData = await self.client
-              .stack({ api_key: config.source_stack, management_token: config.management_token })
+            const roleData = await self.stackAPIClient
               .role(roleUid)
               .fetch({ include_rules: true, include_permissions: true });
             stage.SYS_ACL.roles.uids[i] = roleData;
@@ -99,7 +99,7 @@ module.exports = class ExportWorkFlows {
         addlogs(self.config, workflow.name + ' workflow was exported successfully', 'success');
         await self.getWorkflowRoles(self, workflow);
         self.workflows[workflow.uid] = workflow;
-        let deleteItems = config.modules.workflows.invalidKeys;
+        const deleteItems = config.modules.workflows.invalidKeys;
         deleteItems.forEach((e) => delete workflow[e]);
       }
     } catch (error) {

package/src/lib/util/helper.js

@@ -4,17 +4,17 @@
  * MIT Licensed
  */
 
-var fs = require('fs');
-var path = require('path');
-var mkdirp = require('mkdirp');
-var bigJSON = require('big-json');
+const fs = require('fs');
+const path = require('path');
+const mkdirp = require('mkdirp');
+const bigJSON = require('big-json');
 
-exports.readFileSync = function (filePath, parse) {
-  var data;
+exports.readFileSync = (filePath, parse) => {
+  let data;
   parse = typeof parse === 'undefined' ? true : parse;
   filePath = path.resolve(filePath);
   if (fs.existsSync(filePath)) {
-    data = parse ? JSON.parse(fs.readFileSync(filePath, 'utf-8')) : data;
+    data = parse ? JSON.parse(fs.readFileSync(filePath, 'utf8')) : data;
   }
   return data;
 };
@@ -36,14 +36,14 @@ exports.readFile = async (filePath, options = { type: 'json' }) => {
   });
 };
 
-exports.makeDirectory = async function (path) {
+exports.makeDirectory = async (path) => {
   if (!path) {
     throw new Error('Invalid path to create directory');
   }
   return mkdirp(path);
 };
 
-exports.readLargeFile = function (filePath, opts = {}) {
+exports.readLargeFile = (filePath, opts = {}) => {
   if (typeof filePath !== 'string') {
     return;
   }
@@ -52,13 +52,13 @@ exports.readLargeFile = function (filePath, opts = {}) {
     return new Promise((resolve, reject) => {
       const readStream = fs.createReadStream(filePath, { encoding: 'utf-8' });
       const parseStream = bigJSON.createParseStream();
-      parseStream.on('data', function (data) {
+      parseStream.on('data', (data) => {
         if (opts.type === 'array') {
           return resolve(Object.values(data));
         }
         resolve(data);
       });
-      parseStream.on('error', function (error) {
+      parseStream.on('error', (error) => {
         console.log('error', error);
         reject(error);
       });
@@ -67,7 +67,7 @@ exports.readLargeFile = function (filePath, opts = {}) {
   }
 };
 
-exports.writeLargeFile = function (filePath, data) {
+exports.writeLargeFile = (filePath, data) => {
   if (typeof filePath !== 'string' || typeof data !== 'object') {
     return;
   }
@@ -76,7 +76,7 @@ exports.writeLargeFile = function (filePath, data) {
     const stringifyStream = bigJSON.createStringifyStream({
       body: data,
     });
-    var writeStream = fs.createWriteStream(filePath, 'utf-8');
+    const writeStream = fs.createWriteStream(filePath, 'utf-8');
     stringifyStream.pipe(writeStream);
     writeStream.on('finish', () => {
       resolve();
@@ -87,12 +87,12 @@ exports.writeLargeFile = function (filePath, data) {
   });
 };
 
-exports.writeFileSync = function (filePath, data) {
+exports.writeFileSync = (filePath, data) => {
   data = typeof data === 'object' ? JSON.stringify(data) : data || '{}';
   fs.writeFileSync(filePath, data);
 };
 
-exports.writeFile = function (filePath, data) {
+exports.writeFile = (filePath, data) => {
   return new Promise((resolve, reject) => {
     data = typeof data === 'object' ? JSON.stringify(data) : data || '{}';
     fs.writeFile(filePath, data, (error) => {
@@ -104,16 +104,7 @@ exports.writeFile = function (filePath, data) {
   });
 };
 
-exports.makeDirectory = function () {
-  for (var key in arguments) {
-    var dirname = path.resolve(arguments[key]);
-    if (!fs.existsSync(dirname)) {
-      mkdirp.sync(dirname);
-    }
-  }
-};
-
-exports.readdir = function (dirPath) {
+exports.readdir = (dirPath) => {
   if (fs.existsSync(path)) {
     return fs.readdirSync(dirPath);
   } else {

package/src/lib/util/login.js

@@ -7,70 +7,74 @@
  * MIT Licensed
  */
 
-var chalk = require('chalk');
-var { addlogs } = require('../util/log');
-let stack = require('../util/contentstack-management-sdk');
-let client;
+const chalk = require('chalk');
+const { addlogs } = require('../util/log');
+const { managementSDKClient } = require('@contentstack/cli-utilities');
 
 module.exports.login = (config) => {
-  client = stack.Client(config);
-  return new Promise(function (resolve, reject) {
-    if (config.email && config.password) {
-      // eslint-disable-next-line no-console
-      console.log('Logging into Contentstack');
-      client
-        .login({ email: config.email, password: config.password })
-        .then(function (response) {
+  return new Promise((resolve, reject) => {
+    managementSDKClient(config)
+      .then((APIClient) => {
+        if (config.email && config.password) {
           // eslint-disable-next-line no-console
-          console.log(chalk.green('Contentstack account authenticated successfully!'));
-          config.authtoken = response.user.authtoken;
+          console.log('Logging into Contentstack');
+          APIClient.login({ email: config.email, password: config.password })
+            .then((response) => {
+              // eslint-disable-next-line no-console
+              console.log(chalk.green('Contentstack account authenticated successfully!'));
+              config.authtoken = response.user.authtoken;
+              config.headers = {
+                api_key: config.source_stack,
+                access_token: config.access_token,
+                authtoken: config.authtoken,
+                'X-User-Agent': 'contentstack-export/v',
+              };
+              resolve(config);
+            })
+            .catch((error) => {
+              reject(error);
+            });
+        } else if (config.auth_token && !config.management_token) {
+          const stackAPIClient = APIClient.stack({
+            api_key: config.source_stack,
+            management_token: config.management_token,
+          });
+          stackAPIClient
+            .users()
+            .then(() => {
+              resolve();
+            })
+            .catch((error) => {
+              if (error.errors.api_key) {
+                return reject(error);
+              }
+              addlogs(config, error.errorMessage, 'error');
+              reject(error);
+            });
+        } 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 = {
             api_key: config.source_stack,
             access_token: config.access_token,
-            authtoken: config.authtoken,
             'X-User-Agent': 'contentstack-export/v',
           };
           resolve(config);
-        })
-        .catch(function (error) {
-          reject(error);
-        });
-    } 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 = {
-        api_key: config.source_stack,
-        access_token: config.access_token,
-        'X-User-Agent': 'contentstack-export/v',
-      };
-      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 () {
+          // eslint-disable-next-line no-else-return
+        } else if (config.management_token) {
           resolve();
-        })
-        .catch((error) => {
-          if (error.errors.api_key) {
-            return reject(error);
-          }
-          addlogs(config, error.errorMessage, 'error');
-          reject(error);
-        });
-    } else if (config.management_token) {
-      resolve();
-    }
+        }
+      })
+      .catch((error) => reject(error));
   });
 };

package/src/lib/util/marketplace-app-helper.js

@@ -1,42 +1,5 @@
 let config = require('../../config/default');
-const sdk = require('./contentstack-management-sdk');
-const { cliux, HttpClient, configHandler } = require('@contentstack/cli-utilities');
-
-const getInstalledExtensions = (config) => {
-  const client = sdk.Client(config)
-
-  return new Promise((resolve, reject) => {
-    const queryRequestOptions = {
-      include_marketplace_extensions: true
-    }
-    const {
-      management_token_data: { apiKey: api_key, token: management_token } = { apiKey: config.source_stack },
-      auth_token
-    } = config || { management_token_data: {} }
-
-    if (api_key && management_token) {
-      client
-        .stack({ api_key, management_token })
-        .extension()
-        .query(queryRequestOptions)
-        .find()
-        .then(({ items }) => resolve(items))
-        .catch(reject)
-    } else if (api_key && auth_token) {
-      const { cma } = configHandler.get('region') || {};
-      const headers = {
-        api_key,
-        authtoken: auth_token
-      }
-      const httpClient = new HttpClient().headers(headers);
-      httpClient.get(`${cma}/v3/extensions/?include_marketplace_extensions=true`)
-        .then(({ data: { extensions } }) => resolve(extensions))
-        .catch(reject)
-    } else {
-      resolve([])
-    }
-  })
-}
+const { cliux, configHandler } = require('@contentstack/cli-utilities');
 
 const getDeveloperHubUrl = async () => {
   const { cma, name } = configHandler.get('region') || {};
@@ -56,6 +19,6 @@ const getDeveloperHubUrl = async () => {
   }
 
   return developerHubBaseUrl.startsWith('http') ? developerHubBaseUrl : `https://${developerHubBaseUrl}`;
-}
+};
 
-module.exports = { getInstalledExtensions, getDeveloperHubUrl }
+module.exports = { getDeveloperHubUrl };

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

@@ -1,9 +1,8 @@
 const mkdirp = require('mkdirp');
 const path = require('path');
 const helper = require('./helper');
-const { HttpClient } = require('@contentstack/cli-utilities');
 
-const setupBranches = async (config, branch) => {
+const setupBranches = async (config, branch, stackAPIClient) => {
   if (typeof config !== 'object') {
     throw new Error('Invalid config to setup the branch');
   }
@@ -18,21 +17,24 @@ const setupBranches = async (config, branch) => {
 
   if (typeof branch === 'string') {
     // check branch exists
-    const result = await HttpClient.create()
-      .headers(headers)
-      .get(`https://${config.host}/v3/stacks/branches/${branch}`);
-
-    if (result && typeof result.data === 'object' && typeof result.data.branch === 'object') {
-      branches.push(result.data.branch);
+    const result = await stackAPIClient
+      .branch(branch)
+      .fetch()
+      .catch((_err) => {});
+    if (result && typeof result === 'object') {
+      branches.push(result);
     } else {
       throw new Error('No branch found with the name ' + branch);
     }
   } else {
     try {
-      const result = await HttpClient.create().headers(headers).get(`https://${config.host}/v3/stacks/branches`);
-
-      if (result && result.data && Array.isArray(result.data.branches) && result.data.branches.length > 0) {
-        branches = result.data.branches;
+      const result = await stackAPIClient
+        .branch()
+        .query()
+        .find()
+        .catch((_err) => {});
+      if (result && result.items && Array.isArray(result.items) && result.items.length > 0) {
+        branches = result.items;
       } else {
         return;
       }

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

@@ -1,39 +0,0 @@
-const contentstacksdk = require('@contentstack/management');
-const https = require('https');
-
-const { addlogs } = require('./log');
-
-exports.Client = function (config) {
-  const option = {
-    host: config.host,
-    authtoken: config.auth_token,
-    api_key: config.source_stack,
-    maxRequests: 10,
-    retryLimit: 5,
-    timeout: 60000,
-    httpsAgent: new https.Agent({
-      maxSockets: 100,
-      maxFreeSockets: 10,
-      keepAlive: true,
-      timeout: 60000, // active socket keepalive for 60 seconds
-      freeSocketTimeout: 30000, // free socket keepalive for 30 seconds
-    }),
-    retryDelay: Math.floor(Math.random() * (8000 - 3000 + 1) + 3000),
-    logHandler: (level, data) => {},
-    retryCondition: (error) => {
-      if (error.response.status === 408) {
-        addlogs({ data: error.response }, 'Timeout error', 'error');
-      }
-      return false;
-    },
-  };
-
-  if (typeof config.branchName === 'string') {
-    option.headers = {
-      branch: config.branchName,
-    };
-  }
-
-  const client = contentstacksdk.client(option);
-  return client;
-};