@contentstack/cli-cm-import 0.1.1-beta.1 → 0.1.1-beta.10

package/src/lib/import/environments.js

@@ -51,7 +51,7 @@ importEnvironments.prototype = {
     mkdirp.sync(envMapperPath)
     return new Promise(function (resolve, reject) {
       if (self.environments === undefined) {
-        addlogs(config, chalk.yellow('No Environment Found'), 'error')
+        addlogs(config, chalk.yellow('No Environment Found'), 'success')
         return resolve()
       }
 

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

@@ -50,6 +50,7 @@ importGlobalFields.prototype = {
     globalfieldsMapperPath = path.resolve(config.data, 'mapper', 'global_fields')
     globalfieldsUidMapperPath = path.resolve(config.data, 'mapper', 'global_fields', 'uid-mapping.json')
     globalfieldsSuccessPath = path.resolve(config.data, 'mapper', 'global_fields', 'success.json')
+    globalFieldsPending = path.resolve(config.data, 'mapper', 'global_fields', 'pending_global_fields.js')
     globalfieldsFailsPath = path.resolve(config.data, 'mapper', 'global_fields', 'fails.json')
     self.globalfields = helper.readFile(path.resolve(globalfieldsFolderPath, globalfieldsConfig.fileName))
     if (fs.existsSync(globalfieldsUidMapperPath)) {
@@ -64,6 +65,7 @@ importGlobalFields.prototype = {
     return new Promise(function (resolve, reject) {
       if (self.globalfields === undefined) {
         addlogs(config, chalk.white('No globalfields Found'), 'success')
+        helper.writeFile(globalFieldsPending, _globalField_pending)
         return resolve()
       }
       let snipUids = Object.keys(self.globalfields)
@@ -114,6 +116,7 @@ importGlobalFields.prototype = {
       }).then(function () {
         // globalfields have imported successfully
         helper.writeFile(globalfieldsSuccessPath, self.success)
+        helper.writeFile(globalFieldsPending, _globalField_pending)
         addlogs(config, chalk.green('globalfields have been imported successfully!'), 'success')
         return resolve()
       }).catch(function (err) {

package/src/lib/import/labels.js

@@ -12,7 +12,7 @@ const chalk = require('chalk');
 const _ = require('lodash')
 
 const helper = require('../util/fs');
-const {addlogs} = require('../util/log');
+const { addlogs } = require('../util/log');
 let config = require('../../config/default')
 let stack = require('../util/contentstack-management-sdk')
 
@@ -26,7 +26,7 @@ let labelFailsPath
 let client
 
 
-function importLabels () {
+function importLabels() {
   this.fails = [];
   this.success = [];
   this.labelUidMapper = {};
@@ -50,35 +50,39 @@ importLabels.prototype = {
     labelSuccessPath = path.resolve(config.data, 'labels', 'success.json');
     labelFailsPath = path.resolve(config.data, 'labels', 'fails.json');
     mkdirp.sync(labelMapperPath);
-
     return new Promise(function (resolve, reject) {
-      if(self.labels == undefined) {
+      if (self.labels == undefined) {
         addlogs(config, chalk.white('No Label Found'), 'error');
         return resolve();
       }
       self.labelUids = Object.keys(self.labels);
       return Promise.map(self.labelUids, function (labelUid) {
         let label = self.labels[labelUid];
-        if(label.parent.length != 0) {
+        if (label.parent.length != 0) {
           delete label['parent'];
-        } 
+        }
 
         if (!self.labelUidMapper.hasOwnProperty(labelUid)) {
           let requestOption = {
-              label: label
+            label: label
           };
-          
+
           // return self.createLabels(self.labels[labelUid]);
-          return client.stack({api_key: config.target_stack, management_token: config.management_token}).label().create(requestOption)
-          .then(function (response) {
-            self.labelUidMapper[labelUid] = response;
-            helper.writeFile(labelUidMapperPath, self.labelUidMapper);
-            return;
-          }).catch(function (error) {
-            self.fails.push(label);
-            addlogs(config, chalk.red('Label: \'' + label.name + '\' failed to be imported\n' + JSON.stringify(error)), 'error');
-            return;
-          });
+          return client.stack({ api_key: config.target_stack, management_token: config.management_token }).label().create(requestOption)
+            .then(function (response) {
+              self.labelUidMapper[labelUid] = response;
+              helper.writeFile(labelUidMapperPath, self.labelUidMapper);
+              return;
+            }).catch(function (error) {
+              self.fails.push(label);
+              // addlogs(config, chalk.red('Label: \'' + label.name + '\' failed to be imported\n'), 'error');
+              if (error.errors.name) {
+                addlogs(config, chalk.red('Label: \'' + label.name + '\'  already exist'), 'error');
+              } else {
+                addlogs(config, chalk.red('Label: \'' + label.name + '\' failed to be imported\n'), 'error');
+              }
+              return;
+            });
         } else {
           // the label has already been created
           addlogs(config, (chalk.white('The label: \'' + label.name +
@@ -97,7 +101,7 @@ importLabels.prototype = {
         }).catch(function (error) {
           // eslint-disable-next-line no-console
           return reject(error);
-        });      
+        });
       }).catch(function (error) {
         // error while importing labels
         helper.writeFile(labelFailsPath, self.fails);
@@ -107,34 +111,36 @@ importLabels.prototype = {
     });
   },
 
-  updateLabels: function() {
-    let self = this;    
+  updateLabels: function () {
+    let self = this;
     return new Promise(function (resolve, reject) {
       let labelsObj = helper.readFile(path.resolve(labelsFolderPath, labelConfig.fileName));
       return Promise.map(self.labelUids, function (labelUid) {
         let label = labelsObj[labelUid];
-        if(self.labelUidMapper.hasOwnProperty(labelUid)) {
+        if (self.labelUidMapper.hasOwnProperty(labelUid)) {
           let newLabelUid = self.labelUidMapper[labelUid];
-          if(label.parent.length != 0) {
+          if (label.parent.length > 0) {
             let parentUids = label.parent;
-            for(let i=0; i<parentUids.length; i++) {
-              if(self.labelUidMapper.hasOwnProperty(parentUids[i])) {
-                label.parent[i] = self.labelUidMapper[parentUids[i]];  
+            for (let i = 0; i < parentUids.length; i++) {
+              if (self.labelUidMapper.hasOwnProperty(parentUids[i])) {
+                label.parent[i] = self.labelUidMapper[parentUids[i]].uid;
               }
             }
+            return client.stack({ api_key: config.target_stack, management_token: config.management_token }).label(newLabelUid.uid).fetch()
+            .then(function (response) {
+              //Object.assign(response, _.cloneDeep(label))
+              response.parent = label.parent
+              response.update().then((result) => {
+                self.success.push(result);
+              }).catch(error => {
+                return reject(error);
+              })
+            }).catch(function (error) {
+              return reject(error);
+            });
           }
 
-          return client.stack({api_key: config.target_stack, management_token: config.management_token}).label(newLabelUid.uid).fetch()
-          .then(function (response) {
-            Object.assign(response, _.cloneDeep(label))
-            response.update().then((result) => {              
-            self.success.push(result);
-            }).catch(error => {
-              return reject(error);
-            })
-          }).catch(function (error) {
-            return reject(error);
-          });
+          
         }
       }, {
         concurrency: reqConcurrency

package/src/lib/import/locales.js

@@ -16,6 +16,7 @@ let {addlogs} = require('../util/log')
 let util = require('../util')
 let stack = require('../util/contentstack-management-sdk')
 let config = require('../../config/default')
+let _ = require('lodash')
 let reqConcurrency = config.concurrency
 let langConfig = config.modules.locales
 let langFolderPath
@@ -69,7 +70,6 @@ importLanguages.prototype = {
           
          return client.stack({api_key: config.target_stack, management_token: config.management_token}).locale().create(requestOption)
           .then(locale => {                    
-            self.update_locales(lang)
             self.success.push(locale.items)
             self.langUidMapper[langUid] = locale.uid
             helper.writeFile(langUidMapperPath, self.langUidMapper)
@@ -92,9 +92,15 @@ importLanguages.prototype = {
         concurrency: reqConcurrency,
       }).then(function () {
         // languages have imported successfully
-        helper.writeFile(langSuccessPath, self.success)
-        addlogs(config, chalk.green('Languages have been imported successfully!'), 'success')
-        return resolve()
+        self.update_locales(langUids)
+        .then(() => {
+          helper.writeFile(langSuccessPath, self.success)
+          addlogs(config, chalk.green('Languages have been imported successfully!'), 'success')
+          return resolve()
+        }).catch(function (error) {
+          return reject(error)
+        })
+       
       }).catch(function (error) {
         // error while importing languages
         helper.writeFile(langFailsPath, self.fails)
@@ -103,25 +109,30 @@ importLanguages.prototype = {
       })
     })
   },
-  update_locales: function (lang) {
+  update_locales: function (langUids) {
     let self = this
-  return client.stack({api_key: config.target_stack, management_token: config.management_token}).locale(lang.code).fetch()
-    // return request(requestOption)
-    .then(function (locale) {      
-      locale.code = lang.code
-      locale.fallback_locale = lang.fallback_locale
-      locale.name = lang.name
-      return locale.update()
-    }).catch(function (error) {
-      // let error = JSON.parse(err.message)
-      if (error.hasOwnProperty('errorCode') && error.errorCode === 247) {
-        addlogs(config, error.errors.code[0], 'error')
-        return
-      }
-      self.fails.push(lang)
-      addlogs(config, 'Language: \'' + lang.code + '\' failed to update\n', 'error')
-      return
+    return new Promise(function (resolve, reject) {
+    Promise.all(
+      langUids.map(async langUid => {
+        let lang = {}
+          let requireKeys = config.modules.locales.requiredKeys
+          let _lang = self.languages[langUid]
+          requireKeys.forEach(e => {
+            lang[e] = _lang[e]
+          })
+        let langobj = client.stack({api_key: config.target_stack, management_token: config.management_token}).locale(lang.code)
+        Object.assign(langobj, _.cloneDeep(lang))
+        langobj.update()
+        .then(()=>{
+        })
+      })
+    )
+    .then(()=>{
+      return resolve()
+    }).catch((error) => {
+      return reject(error)
     })
+  })
   },
 }
 

package/src/lib/import/workflows.js

@@ -0,0 +1,118 @@
+/*!
+ * Contentstack Import
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+
+const mkdirp = require('mkdirp');
+const fs = require('fs');
+const path = require('path');
+const Promise = require('bluebird');
+const chalk = require('chalk');
+const _ = require('lodash')
+
+const helper = require('../util/fs');
+const { addlogs } = require('../util/log');
+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
+
+
+function importWorkflows() {
+  this.fails = [];
+  this.success = [];
+  this.workflowUidMapper = {};
+  this.labelUids = [];
+  if (fs.existsSync(workflowUidMapperPath)) {
+    this.workflowUidMapper = helper.readFile(workflowUidMapperPath);
+    this.workflowUidMapper = this.workflowUidMapper || {};
+  }
+}
+
+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)
+    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');
+    workflowSuccessPath = path.resolve(config.data, 'workflows', 'success.json');
+    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();
+      }
+      self.workflowsUids = Object.keys(self.workflows);
+      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 (workflow.workflow_stages[index].SYS_ACL.roles.uids.length > 0) {
+              workflow.workflow_stages[index].SYS_ACL.roles.uids = []
+            }
+
+            if (workflow.workflow_stages[index].next_available_stages.length > 0) {
+              workflow.workflow_stages[index].next_available_stages = ["$all"]
+            }
+          }
+
+          let requestOption = {
+            workflow: 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);
+      });
+    });
+  }
+}
+module.exports = new importWorkflows();

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

@@ -1,16 +1,28 @@
-const contentstacksdk = require('@contentstack/management')
-
-
-exports.Client = function (config) {  
+const contentstacksdk = require("@contentstack/management");
 
+exports.Client = function (config) {
   const option = {
     host: config.host,
     authtoken: config.auth_token,
+    management_token: config.management_token,
     api_key: config.target_stack,
     maxContentLength: 100000000,
     maxBodyLength: 1000000000,
-    logHandler: (level, data) => {}
-  }
-  const client = contentstacksdk.client(option)
-  return client
-}
+    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;
+    },
+    retryDelayOptions: {
+      base: 1000,
+    },
+  };
+  const client = contentstacksdk.client(option);
+  return client;
+};

package/src/lib/util/extensionsUidReplace.js

@@ -4,49 +4,47 @@
  * MIT Licensed
  */
 
+// 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')
 
-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');
-
-
+// eslint-disable-next-line camelcase
 var extension_uid_Replace = module.exports = function (schema, preserveStackVersion) {
   for (var 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) {
-        if(schema[i].blocks[block].hasOwnProperty('reference_to')) {
-          delete schema[i].blocks[block].schema;
+        if (schema[i].blocks[block].hasOwnProperty('reference_to')) {
+          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));
-      if(global_fields_data && global_fields_data.hasOwnProperty(global_fields_key_value)) {
-        schema[i]['reference_to'] = global_fields_data[global_fields_key_value];
+    } 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))
+      if (global_fields_data && global_fields_data.hasOwnProperty(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));
-        if(data && data.hasOwnProperty(extension_key_value)) {
-          schema[i]['extension_uid'] = data[extension_key_value];
-        }             
+    } else if (schema[i].hasOwnProperty('extension_uid')) {
+      var extension_key_value = schema[i].extension_uid
+      var 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]
       }
     }
   }
-};
+}