@contentstack/cli-cm-import 0.1.1-beta.9 → 1.0.0

package/src/lib/import/webhooks.js

@@ -9,22 +9,23 @@ const fs = require('fs');
 const path = require('path');
 const Promise = require('bluebird');
 const chalk = require('chalk');
+const {isEmpty} = require('lodash');
 
 const helper = require('../util/fs');
-const {addlogs} = require('../util/log');
-let config = require('../../config/default')
-let stack = require('../util/contentstack-management-sdk')
+const { addlogs } = require('../util/log');
+let config = require('../../config/default');
+let stack = require('../util/contentstack-management-sdk');
 let reqConcurrency = config.concurrency;
 let webhooksConfig = config.modules.webhooks;
 
-let webhooksFolderPath 
-let webMapperPath
-let webUidMapperPath
-let webSuccessPath
-let webFailsPath 
-let client
+let webhooksFolderPath;
+let webMapperPath;
+let webUidMapperPath;
+let webSuccessPath;
+let webFailsPath;
+let client;
 
-function importWebhooks () {
+function importWebhooks() {
   this.fails = [];
   this.success = [];
   this.webUidMapper = {};
@@ -33,9 +34,9 @@ function importWebhooks () {
 importWebhooks.prototype = {
   start: function (credentialConfig) {
     let self = this;
-    config = credentialConfig
-    addlogs(config, chalk.white('Migrating webhooks'), 'success')
-    client = stack.Client(config)
+    config = credentialConfig;
+    addlogs(config, chalk.white('Migrating webhooks'), 'success');
+    client = stack.Client(config);
     webhooksFolderPath = path.resolve(config.data, webhooksConfig.dirName);
     webMapperPath = path.resolve(config.data, 'mapper', 'webhooks');
     webUidMapperPath = path.resolve(config.data, 'mapper', 'webhooks', 'uid-mapping.json');
@@ -49,56 +50,72 @@ importWebhooks.prototype = {
     mkdirp.sync(webMapperPath);
 
     return new Promise(function (resolve, reject) {
-      if(self.webhooks == undefined) {
+      if (self.webhooks == undefined || isEmpty(self.webhooks)) {
         addlogs(config, chalk.white('No Webhooks Found'), 'success');
-        return resolve();
+        return resolve({ empty: true });
       }
       let webUids = Object.keys(self.webhooks);
-      return Promise.map(webUids, function (webUid) {
-        let web = self.webhooks[webUid];
-        if (!self.webUidMapper.hasOwnProperty(webUid)) {
-          let requestOption = {
-            json: {
-              webhook: web
-            }
+      return Promise.map(
+        webUids,
+        function (webUid) {
+          let web = self.webhooks[webUid];
+          if (config.importWebhookStatus !== 'current' || config.importWebhookStatus === 'disable') {
+            web.disabled = true;
           }
-          
-          // return self.createwebhooks(self.webhooks[webUid]);
-          return client.stack({api_key: config.target_stack, management_token: config.management_token}).webhook().create(requestOption.json)
-          // return request(requestOption)
-          .then(function (response) {
-            self.success.push(response);
-            self.webUidMapper[webUid] = response.uid;
-            helper.writeFile(webUidMapperPath, self.webUidMapper);
-            return
-          }).catch(function (err) {
-            let error = JSON.parse(err.message)
-            self.fails.push(web);
-            addlogs(config, chalk.red('Webhooks: \'' + web.name + '\' failed to be import\n' + JSON.stringify(error)), 'error')
-            return
-          })
-        } else {
-          // the webhooks has already been created
-          addlogs(config, chalk.white('The Webhooks: \'' + web.name +
-            '\' already exists. Skipping it to avoid duplicates!'), 'success')
-          return
-        }
-        // import 2 webhooks at a time
-      }, {
-        concurrency: reqConcurrency
-      }).then(function () {
-        // webhooks have imported successfully
-        helper.writeFile(webSuccessPath, self.success);
-        addlogs(config, chalk.green('Webhooks have been imported successfully!'), 'success')
-        return resolve()
-      }).catch(function (error) {
-        // error while importing environments
-        helper.writeFile(webFailsPath, self.fails);
-        addlogs(config, chalk.red('Webhooks import failed'), 'error')
-        return reject(error)
-      })
-    })
-  }
+
+          if (!self.webUidMapper.hasOwnProperty(webUid)) {
+            let requestOption = {
+              json: {
+                webhook: web,
+              },
+            };
+
+            return client
+              .stack({ api_key: config.target_stack, management_token: config.management_token })
+              .webhook()
+              .create(requestOption.json)
+              .then(function (response) {
+                self.success.push(response);
+                self.webUidMapper[webUid] = response.uid;
+                helper.writeFile(webUidMapperPath, self.webUidMapper);
+              })
+              .catch(function (err) {
+                let error = JSON.parse(err.message);
+                self.fails.push(web);
+                addlogs(
+                  config,
+                  chalk.red("Webhooks: '" + web.name + "' failed to be import\n" + JSON.stringify(error)),
+                  'error',
+                );
+              });
+          } else {
+            // the webhooks has already been created
+            addlogs(
+              config,
+              chalk.white("The Webhooks: '" + web.name + "' already exists. Skipping it to avoid duplicates!"),
+              'success',
+            );
+          }
+          // import 2 webhooks at a time
+        },
+        {
+          concurrency: reqConcurrency,
+        },
+      )
+        .then(function () {
+          // webhooks have imported successfully
+          helper.writeFile(webSuccessPath, self.success);
+          addlogs(config, chalk.green('Webhooks have been imported successfully!'), 'success');
+          return resolve();
+        })
+        .catch(function (error) {
+          // error while importing environments
+          helper.writeFile(webFailsPath, self.fails);
+          addlogs(config, chalk.red('Webhooks import failed'), 'error');
+          return reject(error);
+        });
+    });
+  },
 };
 
 module.exports = new importWebhooks();

package/src/lib/import/workflows.js

@@ -9,22 +9,21 @@ const fs = require('fs');
 const path = require('path');
 const Promise = require('bluebird');
 const chalk = require('chalk');
-const _ = require('lodash')
+const {isEmpty} = require('lodash');
 
 const helper = require('../util/fs');
 const { addlogs } = require('../util/log');
-let config = require('../../config/default')
+let config = require('../../config/default');
 let stack = require('../util/contentstack-management-sdk');
 
 let reqConcurrency = config.concurrency;
 let workflowConfig = config.modules.workflows;
-let workflowFolderPath
-let workflowMapperPath
-let workflowUidMapperPath
-let workflowSuccessPath
-let workflowFailsPath
-let client
-
+let workflowFolderPath;
+let workflowMapperPath;
+let workflowUidMapperPath;
+let workflowSuccessPath;
+let workflowFailsPath;
+let client;
 
 function importWorkflows() {
   this.fails = [];
@@ -40,10 +39,10 @@ function importWorkflows() {
 importWorkflows.prototype = {
   start: function (credentialConfig) {
     let self = this;
-    config = credentialConfig
-    client = stack.Client(config)
-    addlogs(config, chalk.white('Migrating workflows'), 'success')
-    workflowFolderPath = path.resolve(config.data, workflowConfig.dirName)
+    config = credentialConfig;
+    client = stack.Client(config);
+    addlogs(config, chalk.white('Migrating workflows'), 'success');
+    workflowFolderPath = path.resolve(config.data, workflowConfig.dirName);
     self.workflows = helper.readFile(path.resolve(workflowFolderPath, workflowConfig.fileName));
     workflowMapperPath = path.resolve(config.data, 'mapper', 'workflows');
     workflowUidMapperPath = path.resolve(config.data, 'mapper', 'workflows', 'uid-mapping.json');
@@ -51,68 +50,89 @@ importWorkflows.prototype = {
     workflowFailsPath = path.resolve(config.data, 'workflows', 'fails.json');
     mkdirp.sync(workflowMapperPath);
     return new Promise(function (resolve, reject) {
-      if (self.workflows == undefined) {
-        addlogs(config, chalk.white('No workflow Found'), 'error');
-        return resolve();
+      if (self.workflows == undefined || isEmpty(self.workflows)) {
+        addlogs(config, chalk.white('No workflow Found'), 'success');
+        return resolve({ empty: true });
       }
       self.workflowsUids = Object.keys(self.workflows);
-      return Promise.map(self.workflowsUids, function (workflowUid) {
-        let workflow = self.workflows[workflowUid];
+      return Promise.map(
+        self.workflowsUids,
+        function (workflowUid) {
+          let workflow = self.workflows[workflowUid];
 
-        if (!self.workflowUidMapper.hasOwnProperty(workflowUid)) {
-          for (let index = 0; index < workflow.workflow_stages.length; index++) {
-            if (workflow.workflow_stages[index].SYS_ACL.users.uids.length > 0 && workflow.workflow_stages[index].SYS_ACL.users.uids[0] !== "$all") {
-              workflow.workflow_stages[index].SYS_ACL.users.uids = ["$all"]
-            }
+          if (!self.workflowUidMapper.hasOwnProperty(workflowUid)) {
+            const workflowStages = workflow.workflow_stages
+            for (const stage of workflowStages) {
+              if (
+                stage.SYS_ACL.users.uids.length > 0 &&
+                stage.SYS_ACL.users.uids[0] !== '$all'
+              ) {
+                stage.SYS_ACL.users.uids = ['$all'];
+              }
 
-            if (workflow.workflow_stages[index].SYS_ACL.roles.uids.length > 0) {
-              workflow.workflow_stages[index].SYS_ACL.roles.uids = []
+              if (stage.SYS_ACL.roles.uids.length > 0) {
+                stage.SYS_ACL.roles.uids = [];
+              }
             }
 
-            if (workflow.workflow_stages[index].next_available_stages.length > 0) {
-              workflow.workflow_stages[index].next_available_stages = ["$all"]
+            if (workflow.admin_users !== undefined) {
+              addlogs(config, chalk.yellow('We are skipping import of `Workflow superuser(s)` from workflow'), 'info');
+              delete workflow.admin_users;
             }
-          }
 
-          let requestOption = {
-            workflow: workflow
-          };
+            let requestOption = {
+              workflow,
+            };
 
-          return client.stack({ api_key: config.target_stack, management_token: config.management_token }).workflow().create(requestOption)
-            .then(function (response) {
-              self.workflowUidMapper[workflowUid] = response;
-              helper.writeFile(workflowUidMapperPath, self.workflowUidMapper);
-              return;
-            }).catch(function (error) {
-              self.fails.push(workflow);
-              if (error.errors.name) {
-                addlogs(config, chalk.red('workflow: \'' + workflow.name + '\'  already exist'), 'error');
-              } else if (error.errors['workflow_stages.0.users']) {
-                addlogs(config, chalk.red("Failed to import Workflows as you've specified certain roles in the Stage transition and access rules section. We currently don't import roles to the stack."), 'error');
-              } else {
-                addlogs(config, chalk.red('workflow: \'' + workflow.name + '\'  failed'), 'error');
-              }
-              return;
-            });
-        } else {
-          // the workflow has already been created
-          addlogs(config, (chalk.white('The Workflows: \'' + workflow.name +
-            '\' already exists. Skipping it to avoid duplicates!')), 'success');
-          return;
-        }
-        // import 1 workflows at a time
-      }, {
-        concurrency: reqConcurrency
-      }).then(function () {
-        helper.writeFile(workflowSuccessPath, self.success);
-        addlogs(config, (chalk.green('Workflows have been imported successfully!')), 'success');
-        return resolve();
-      }).catch(function (error) {
-        helper.writeFile(workflowFailsPath, self.fails);
-        addlogs(config, chalk.red('Workflows import failed'), 'error');
-        return reject(error);
-      });
+            return client
+              .stack({ api_key: config.target_stack, management_token: config.management_token })
+              .workflow()
+              .create(requestOption)
+              .then(function (response) {
+                self.workflowUidMapper[workflowUid] = response;
+                helper.writeFile(workflowUidMapperPath, self.workflowUidMapper);
+              })
+              .catch(function (error) {
+                self.fails.push(workflow);
+                if (error.errors.name) {
+                  addlogs(config, chalk.red("workflow: '" + workflow.name + "'  already exist"), 'error');
+                } else if (error.errors['workflow_stages.0.users']) {
+                  addlogs(
+                    config,
+                    chalk.red(
+                      "Failed to import Workflows as you've specified certain roles in the Stage transition and access rules section. We currently don't import roles to the stack.",
+                    ),
+                    'error',
+                  );
+                } else {
+                  addlogs(config, chalk.red("workflow: '" + workflow.name + "'  failed"), 'error');
+                }
+              });
+          } else {
+            // the workflow has already been created
+            addlogs(
+              config,
+              chalk.white("The Workflows: '" + workflow.name + "' already exists. Skipping it to avoid duplicates!"),
+              'success',
+            );
+          }
+          // import 1 workflows at a time
+        },
+        {
+          concurrency: reqConcurrency,
+        },
+      )
+        .then(function () {
+          helper.writeFile(workflowSuccessPath, self.success);
+          addlogs(config, chalk.green('Workflows have been imported successfully!'), 'success');
+          return resolve();
+        })
+        .catch(function (error) {
+          helper.writeFile(workflowFailsPath, self.fails);
+          addlogs(config, chalk.red('Workflows import failed'), 'error');
+          return reject(error);
+        });
     });
-  }
-}
-module.exports = new importWorkflows();
+  },
+};
+module.exports = new importWorkflows();

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

@@ -1,4 +1,7 @@
-const contentstacksdk = require("@contentstack/management");
+const contentstacksdk = require('@contentstack/management');
+const https = require('https');
+
+const { addlogs } = require('./log');
 
 exports.Client = function (config) {
   const option = {
@@ -8,21 +11,31 @@ exports.Client = function (config) {
     api_key: config.target_stack,
     maxContentLength: 100000000,
     maxBodyLength: 1000000000,
+    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) => {
       // no async function should be used here
-      if (
-        error.response &&
-        (error.response.status === 429 || error.response.status === 408)
-      ) {
-        return true;
-      }
-      return false;
+      return error.response && (error.response.status === 429 || error.response.status === 408);
     },
     retryDelayOptions: {
       base: 1000,
     },
   };
+  if (typeof config.branchName === 'string') {
+    option.headers = {
+      branch: config.branchName,
+    };
+  }
   const client = contentstacksdk.client(option);
   return client;
 };

package/src/lib/util/extensionsUidReplace.js

@@ -5,46 +5,58 @@
  */
 
 // eslint-disable-next-line unicorn/filename-case
-var path = require('path')
-var helper = require('./fs')
-var util = require('../util')
-var config = util.getConfig()
-var extensionPath = path.resolve(config.data, 'mapper/extensions', 'uid-mapping.json')
-var globalfieldsPath = path.resolve(config.data, 'mapper/globalfields', 'uid-mapping.json')
+let path = require('path');
+let helper = require('./fs');
+let util = require('../util');
+let config = util.getConfig();
+let extensionPath = path.resolve(config.data, 'mapper/extensions', 'uid-mapping.json');
+let globalfieldsPath = path.resolve(config.data, 'mapper/globalfields', 'uid-mapping.json');
 
 // eslint-disable-next-line camelcase
-var extension_uid_Replace = module.exports = function (schema, preserveStackVersion) {
-  for (var i in schema) {
+let extension_uid_Replace = (module.exports = function (schema, preserveStackVersion) {
+  for (let i in schema) {
     if (schema[i].data_type === 'group') {
-      extension_uid_Replace(schema[i].schema, preserveStackVersion)
+      extension_uid_Replace(schema[i].schema, preserveStackVersion);
     } else if (schema[i].data_type === 'blocks') {
-      for (var block in schema[i].blocks) {
+      for (let block in schema[i].blocks) {
         if (schema[i].blocks[block].hasOwnProperty('reference_to')) {
-          delete schema[i].blocks[block].schema
+          delete schema[i].blocks[block].schema;
         } else {
-          extension_uid_Replace(schema[i].blocks[block].schema, preserveStackVersion)
+          extension_uid_Replace(schema[i].blocks[block].schema, preserveStackVersion);
         }
       }
-    } else if (schema[i].data_type === 'reference' && !schema[i].field_metadata.hasOwnProperty('ref_multiple_content_types')) {
+    } else if (
+      schema[i].data_type === 'reference' &&
+      !schema[i].field_metadata.hasOwnProperty('ref_multiple_content_types')
+    ) {
       if (preserveStackVersion) {
         // do nothing
       } else {
-        schema[i].reference_to = [schema[i].reference_to]
-        schema[i].field_metadata.ref_multiple_content_types = true
+        schema[i].reference_to = [schema[i].reference_to];
+        schema[i].field_metadata.ref_multiple_content_types = true;
       }
     } else if (schema[i].data_type === 'global_field') {
-      var global_fields_key_value = schema[i].reference_to
-      var global_fields_data = helper.readFile(path.join(globalfieldsPath))
+      let global_fields_key_value = schema[i].reference_to;
+      let global_fields_data = helper.readFile(path.join(globalfieldsPath));
       if (global_fields_data && global_fields_data.hasOwnProperty(global_fields_key_value)) {
-        schema[i].reference_to = global_fields_data[global_fields_key_value]
+        schema[i].reference_to = global_fields_data[global_fields_key_value];
       }
     } else if (schema[i].hasOwnProperty('extension_uid')) {
-      var extension_key_value = schema[i].extension_uid
-      var data = helper.readFile(path.join(extensionPath))
+      const extension_key_value = schema[i].extension_uid;
+      const data = helper.readFile(path.join(extensionPath));
       if (data && data.hasOwnProperty(extension_key_value)) {
         // eslint-disable-next-line camelcase
-        schema[i].extension_uid = data[extension_key_value]
+        schema[i].extension_uid = data[extension_key_value];
       }
+    } else if (schema[i].data_type === 'json' && schema[i].hasOwnProperty('plugins') && schema[i].plugins.length > 0) {
+      const newPluginUidsArray = [];
+      const data = helper.readFile(path.join(extensionPath));
+      schema[i].plugins.forEach((extension_key_value) => {
+        if (data && data.hasOwnProperty(extension_key_value)) {
+          newPluginUidsArray.push(data[extension_key_value]);
+        }
+      });
+      schema[i].plugins = newPluginUidsArray;
     }
   }
-}
+})

package/src/lib/util/fs.js

@@ -10,16 +10,16 @@ var mkdirp = require('mkdirp');
 
 exports.readFile = function (filePath, parse) {
   var data;
-  parse = (typeof parse === 'undefined') ? true : parse;
+  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, 'utf-8')) : data;
   }
   return data;
 };
 
 exports.writeFile = function (filePath, data) {
-  data = (typeof data === 'object') ? JSON.stringify(data) : data || '{}';
+  data = typeof data === 'object' ? JSON.stringify(data) : data || '{}';
   fs.writeFileSync(filePath, data);
 };
 
@@ -39,4 +39,3 @@ exports.readdir = function (dirPath) {
     return [];
   }
 };
-