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

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

@@ -6,93 +6,147 @@
 let defaultConfig = require('../../config/default')
 let { initial } = require('../../app')
 let _ = require('lodash')
-const {cli} = require('cli-ux')
+const { cli } = require('cli-ux')
 let message = require('../../../messages/index.json')
 
-exports.configWithMToken = function (config, managementTokens, moduleName, host) {
-  let externalConfig = require(config)
-  defaultConfig.management_token = managementTokens.token
-  if (moduleName && moduleName !== undefined) {
-    defaultConfig.moduleName = moduleName
-  }
-  defaultConfig.host = host.cma
-  defaultConfig.cdn = host.cda
-  defaultConfig = _.merge(defaultConfig, externalConfig)
-  initial(defaultConfig)
+exports.configWithMToken = function (config, managementTokens, moduleName, host, _authToken, backupdir) {
+  return new Promise(async function (resolve, reject) {
+    let externalConfig = require(config)
+    defaultConfig.management_token = managementTokens.token
+    if (moduleName && moduleName !== undefined) {
+      defaultConfig.moduleName = moduleName
+    }
+    defaultConfig.host = host
+    if (backupdir) {
+      defaultConfig.useBackedupDir = backupdir;
+    }
+    defaultConfig.auth_token = _authToken
+    defaultConfig = _.merge(defaultConfig, externalConfig)
+    initial(defaultConfig)
+      .then(() => {
+        return resolve()
+      }).catch((error) => {
+        return reject()
+      })
+  })
 }
 
-exports.parameterWithMToken = function (masterLang, managementTokens, data, moduleName, host) {
-  var masterloc = {master_locale: {code: masterLang}}
-  defaultConfig.management_token = managementTokens.token  
-  defaultConfig.target_stack = managementTokens.apiKey
-  if (moduleName && moduleName !== undefined) {
-    defaultConfig.moduleName = moduleName
-  }
-  defaultConfig.data = data
-  defaultConfig.host = host.cma
-  defaultConfig.cdn = host.cda
-  defaultConfig = _.merge(defaultConfig, masterloc)
-  initial(defaultConfig)
+exports.parameterWithMToken = function (managementTokens, data, moduleName, host, _authToken, backupdir) {
+  return new Promise(async function (resolve, reject) {
+    defaultConfig.management_token = managementTokens.token
+    defaultConfig.target_stack = managementTokens.apiKey
+    defaultConfig.auth_token = _authToken
+    if (moduleName && moduleName !== undefined) {
+      defaultConfig.moduleName = moduleName
+    }
+    defaultConfig.data = data
+    defaultConfig.host = host
+    if (backupdir) {
+      defaultConfig.useBackedupDir = backupdir;
+    }
+    initial(defaultConfig)
+      .then(() => {
+        return resolve()
+      }).catch((error) => {
+        return reject()
+      })
+  })
 }
 
 // using ManagemetToken
-exports.withoutParameterMToken = async (managementTokens, moduleName, host) => {
-  const masterLocale = await cli.prompt(message.promptMessageList.promptMasterLocale)
-  // const stackUid = managementTokens.apiKey
-  const exporteddata = await cli.prompt(message.promptMessageList.promptPathStoredData)
-  var masterloc = {master_locale: {code: masterLocale}}
-  defaultConfig.management_token = managementTokens.token
-  defaultConfig.target_stack = managementTokens.apiKey
-  if (moduleName && moduleName !== undefined) {
-    defaultConfig.moduleName = moduleName
-  }
-  defaultConfig.data = exporteddata
-  defaultConfig.host = host.cma
-  defaultConfig.cdn = host.cda
-  defaultConfig = _.merge(defaultConfig, masterloc)
-  initial(defaultConfig)
+exports.withoutParameterMToken = async (managementTokens, moduleName, host, _authToken, backupdir) => {
+  return new Promise(async function (resolve, reject) {
+    const exporteddata = await cli.prompt(message.promptMessageList.promptPathStoredData)
+    defaultConfig.management_token = managementTokens.token
+    defaultConfig.target_stack = managementTokens.apiKey
+    defaultConfig.auth_token = _authToken
+    if (moduleName && moduleName !== undefined) {
+      defaultConfig.moduleName = moduleName
+    }
+    defaultConfig.data = exporteddata
+    defaultConfig.host = host
+    if (backupdir) {
+      defaultConfig.useBackedupDir = backupdir;
+    }
+    initial(defaultConfig)
+      .then(() => {
+        return resolve()
+      }).catch((error) => {
+        return reject()
+      })
+  })
 }
 
-exports.configWithAuthToken = function (config, _authToken, moduleName, host) {
-  let externalConfig = require(config)
-  defaultConfig.auth_token = _authToken
-  if (moduleName && moduleName !== undefined) {
-    defaultConfig.moduleName = moduleName
-  }
-  defaultConfig.host = host.cma
-  defaultConfig.cdn = host.cda
-  defaultConfig = _.merge(defaultConfig, externalConfig)
-  initial(defaultConfig)
+exports.configWithAuthToken = function (config, _authToken, moduleName, host, backupdir) {
+  return new Promise(async function (resolve, reject) {
+    let externalConfig = require(config)
+    defaultConfig.auth_token = _authToken
+    if (moduleName && moduleName !== undefined) {
+      defaultConfig.moduleName = moduleName
+    }
+    defaultConfig.host = host
+
+    if (externalConfig.modules) {
+      defaultConfig.modules.types = externalConfig.modules
+      delete externalConfig.modules
+    }
+
+    if (backupdir) {
+      defaultConfig.useBackedupDir = backupdir;
+    }
+    defaultConfig = _.merge(defaultConfig, externalConfig)
+    initial(defaultConfig)
+      .then(() => {
+        return resolve()
+      }).catch((error) => {
+        return reject()
+      })
+  })
 }
 
-exports.parametersWithAuthToken = function (masterLang, _authToken, targetStack, data, moduleName, host) {
-  var masterloc = {master_locale: {code: masterLang}}
-  defaultConfig.auth_token = _authToken
-  defaultConfig.target_stack = targetStack
-  if (moduleName && moduleName !== undefined) {
-    defaultConfig.moduleName = moduleName
-  }
-  defaultConfig.data = data
-  defaultConfig.host = host.cma
-  defaultConfig.cdn = host.cda
-  defaultConfig = _.merge(defaultConfig, masterloc)
-  initial(defaultConfig)
+exports.parametersWithAuthToken = function (_authToken, targetStack, data, moduleName, host, backupdir) {
+  return new Promise(async function (resolve, reject) {
+    defaultConfig.auth_token = _authToken
+    defaultConfig.target_stack = targetStack
+    if (moduleName && moduleName !== undefined && backupdir === undefined) {
+      defaultConfig.moduleName = moduleName
+    } else if (moduleName && moduleName !== undefined && backupdir !== undefined) {
+      defaultConfig.moduleName = moduleName
+      defaultConfig.useBackedupDir = backupdir
+    }
+    defaultConfig.data = data
+    defaultConfig.host = host
+
+    initial(defaultConfig)
+      .then(() => {
+        return resolve()
+      }).catch((error) => {
+        return reject()
+      })
+  })
 }
 
-exports.withoutParametersWithAuthToken = async (_authToken, moduleName, host) => {
+exports.withoutParametersWithAuthToken = async (_authToken, moduleName, host, backupdir) => {
+  return new Promise(async function (resolve, reject) {
+    const stackUid = await cli.prompt(message.promptMessageList.promptTargetStack)
+    const exporteddata = await cli.prompt(message.promptMessageList.promptPathStoredData)
+    defaultConfig.auth_token = _authToken
+    defaultConfig.target_stack = stackUid
+    defaultConfig.data = exporteddata
+    if (moduleName && moduleName !== undefined && backupdir === undefined) {
+      defaultConfig.moduleName = moduleName
+    } else if (moduleName && moduleName !== undefined && backupdir !== undefined) {
+      defaultConfig.moduleName = moduleName
+      defaultConfig.useBackedupDir = backupdir
+    }
+
+    defaultConfig.host = host
 
-  const masterLocale = await cli.prompt(message.promptMessageList.promptMasterLocale)
-  const stackUid = await cli.prompt(message.promptMessageList.promptTargetStack)
-  const exporteddata = await cli.prompt(message.promptMessageList.promptPathStoredData)
-  var masterloc = {master_locale: {code: masterLocale}}
-  defaultConfig.auth_token = _authToken
-  defaultConfig.target_stack = stackUid
-  defaultConfig.data = exporteddata
-  if (moduleName && moduleName !== undefined) {
-    defaultConfig.moduleName = moduleName
-  }
-  defaultConfig.host = host.cma
-  defaultConfig.cdn = host.cda  
-  defaultConfig = _.merge(defaultConfig, masterloc)
-  initial(defaultConfig)
+    initial(defaultConfig)
+      .then(() => {
+        return resolve()
+      }).catch((error) => {
+        return reject()
+      })
+  })
 }

package/src/lib/util/index.js

@@ -11,9 +11,10 @@ var path = require('path')
 var chalk = require('chalk')
 var {addlogs} = require('./log')
 var request = require('./request')
-// var config = require('../../config/');
 var defaultConfig = require('../../config/default')
+const stack = require('./contentstack-management-sdk')
 var config 
+
 exports.initialization = function(configData) {
   config = this.buildAppConfig(configData)
   var res = this.validateConfig(config)
@@ -37,10 +38,10 @@ exports.validateConfig = function (config) {
     addlogs(config, chalk.red('Kindly provide Email and password'), 'error')
     return 'error'
   }
-   if(!config.languagesCode.includes(config.master_locale.code)) {
-    addlogs(config, chalk.red('Kindly provide valid master_locale code'), 'error')
-    return 'error'
-  }
+  //  if(!config.languagesCode.includes(config.master_locale.code)) {
+  //   addlogs(config, chalk.red('Kindly provide valid master_locale code'), 'error')
+  //   return 'error'
+  // }
 }
 
 exports.buildAppConfig = function (config) {
@@ -106,6 +107,77 @@ exports.sanitizeStack = function (config) {
   }
 }
 
+exports.masterLocalDetails = function(credentialConfig) {
+  let client = stack.Client(credentialConfig)
+  return new Promise((resolve, reject) => {
+    var result =  client.stack({ api_key: credentialConfig.target_stack, management_token: credentialConfig.management_token }).locale().query()
+      result.find()
+      .then(response => {
+        var masterLocalObj = response.items.filter(obj => {
+            if (obj.fallback_locale === null) {
+              return obj
+            }
+            });
+        return resolve(masterLocalObj[0])
+      }).catch(error => {
+        return reject(error)
+      })
+  })
+};
+
+exports.field_rules_update = function(config, ctPath) {
+  return new Promise(function (resolve, reject) {
+    let client = stack.Client(config)
+    
+    fs.readFile(path.join(ctPath + '/field_rules_uid.json'), async (err, data) => {
+      if (err) {
+        throw err;
+      }
+      var ct_field_visibility_uid = JSON.parse(data)
+      let ct_files = fs.readdirSync(ctPath)
+      if (ct_field_visibility_uid && ct_field_visibility_uid != 'undefined') {
+        for (let index = 0; index < ct_field_visibility_uid.length; index++) {
+          if (ct_files.indexOf(ct_field_visibility_uid[index] + '.json') > -1) {
+            let schema = require(path.resolve(ctPath, ct_field_visibility_uid[index]))
+            // await field_rules_update(schema)
+            let fieldRuleLength = schema.field_rules.length
+            for (let k = 0; k < fieldRuleLength; k++) {
+              let fieldRuleConditionLength = schema.field_rules[k].conditions.length
+              for (let i = 0; i < fieldRuleConditionLength; i++) {
+                if (schema.field_rules[k].conditions[i].operand_field === 'reference') {
+                  let entryMapperPath = path.resolve(config.data, 'mapper', 'entries')
+                  let entryUidMapperPath = path.join(entryMapperPath, 'uid-mapping.json')
+                  let fieldRulesValue = schema.field_rules[k].conditions[i].value
+                  let fieldRulesArray = fieldRulesValue.split('.')
+                  let updatedValue = []
+                  for (let j = 0; j < fieldRulesArray.length; j++) {
+                    let splitedFieldRulesValue = fieldRulesArray[j]
+                    let oldUid = helper.readFile(path.join(entryUidMapperPath))
+                    if (oldUid.hasOwnProperty(splitedFieldRulesValue)) {
+                      updatedValue.push(oldUid[splitedFieldRulesValue])
+                    } else {
+                      updatedValue.push(fieldRulesArray[j])
+                    }
+                  }
+                  schema.field_rules[k].conditions[i].value = updatedValue.join('.')
+                }
+              }
+            }
+            let ctObj = client.stack({ api_key: config.target_stack, management_token: config.management_token }).contentType(schema.uid)
+            Object.assign(ctObj, _.cloneDeep(schema))
+            ctObj.update()
+              .then(() => {
+                return resolve()
+              }).catch(function (error) {
+                return reject(error)
+              })
+          }
+        }
+      }
+    })
+  })
+}
+
 exports.getConfig = function() {
   return config
 };

package/src/lib/util/log.js

@@ -91,9 +91,11 @@ function init (_logPath, logfileName) {
 }
 
 exports.addlogs = async (config, message, type) => {
+  var configLogPath
+  config.source_stack && config.target_stack ? configLogPath = config.data : configLogPath = config.oldPath
   if (type !== 'error') {
-    init(config.oldPath, type).log(message)
+    init(configLogPath, type).log(message)
   } else {
-    init(config.oldPath, type).error(message)
+    init(configLogPath, type).error(message)
   }
 }

package/src/lib/util/login.js

@@ -34,9 +34,9 @@ module.exports = function (config) {
       }).catch(reject);
     } else if (config.management_token) {
       return resolve()
-    } else if (config.auth_token) {                  
+    } else if (config.auth_token) {                 
       //  return resolve()
-      client.stack({api_key: config.target_stack, management_token: config.management_token}).users()
+      client.stack({api_key: config.target_stack, management_token: config.management_token}).fetch()
       .then(function () {
           return resolve()
       })

package/src/lib/util/lookupReplaceEntries.js

@@ -4,170 +4,168 @@
  * MIT Licensed
  */
 
-var path = require('path');
-var _ = require('lodash');
+// eslint-disable-next-line unicorn/filename-case
+var path = require('path')
+var _ = require('lodash')
 
-var util = require('./index');
-var helper = require('./fs');
-var config = util.getConfig();
+var util = require('.')
+var helper = require('./fs')
+var config = util.getConfig()
 // update references in entry object
 module.exports = function (data, mappedUids, uidMapperPath) {
-  var parent = [];
-  var uids = [];
-  var unmapped = [];
-  var mapped = [];
+  var parent = []
+  var uids = []
+  var unmapped = []
+  var mapped = []
 
-  var isNewRefFields = false;
-  var preserveStackVersion = config.preserveStackVersion;
+  var isNewRefFields = false
+  var preserveStackVersion = config.preserveStackVersion
 
   var update = function (parent, form_id, entry) {
-    var _entry = entry,
-      len = parent.length;
+    var _entry = entry
+    var len = parent.length
     for (var j = 0; j < len; j++) {
       if (_entry && parent[j]) {
-        if (j == (len - 1) && _entry[parent[j]]) {
+        if (j === (len - 1) && _entry[parent[j]]) {
           if (form_id !== '_assets') {
             if (_entry[parent[j]].length) {
               _entry[parent[j]].forEach((item, idx) => {
                 if (typeof item.uid === 'string' && item._content_type_uid) {
-                  uids.push(item.uid);
+                  uids.push(item.uid)
                 } else if (typeof item === 'string' && (preserveStackVersion === true)) {
-                  uids.push(item);
+                  uids.push(item)
                 } else {
-                  uids.push(item);
+                  uids.push(item)
                   _entry[parent[j]][idx] = {
                     uid: item,
-                    _content_type_uid: form_id
-                  };
+                    _content_type_uid: form_id,
+                  }
                 }
-              });
+              })
             }
-          } else {
-            if (_entry[parent[j]] instanceof Array) {
-              for (var k = 0; k < _entry[parent[j]].length; k++) {
-                if (_entry[parent[j]][k]['uid'].length) {
-                  uids.push(_entry[parent[j]][k]['uid']);
-                }
-              }
-            } else {
-              if (_entry[parent[j]]['uid'].length) {
-                uids.push(_entry[parent[j]]['uid']);
+          } else if (Array.isArray(_entry[parent[j]])) {
+            for (var k = 0; k < _entry[parent[j]].length; k++) {
+              if (_entry[parent[j]][k].uid.length) {
+                uids.push(_entry[parent[j]][k].uid)
               }
             }
+          } else if (_entry[parent[j]].uid.length) {
+            uids.push(_entry[parent[j]].uid)
           }
         } else {
-          _entry = _entry[parent[j]];
-          var _keys = _.clone(parent).splice(eval(j + 1), len);
-          if (_entry instanceof Array) {
+          _entry = _entry[parent[j]]
+          var _keys = _.clone(parent).splice(eval(j + 1), len)
+          if (Array.isArray(_entry)) {
             for (var i = 0, _i = _entry.length; i < _i; i++) {
-              update(_keys, form_id, _entry[i]);
+              update(_keys, form_id, _entry[i])
             }
           } else if (!(_entry instanceof Object)) {
-            break;
+            break
           }
         }
       }
     }
-  };
+  }
   var find = function (schema, entry) {
     for (var i = 0, _i = schema.length; i < _i; i++) {
       switch (schema[i].data_type) {
       case 'reference':
-        if (schema[i].reference_to instanceof Array) {
-          isNewRefFields = true;
-          schema[i].reference_to.forEach((reference) => {
-            parent.push(schema[i].uid);
-            update(parent, reference, entry);
-            parent.pop();            
-          });
+        if (Array.isArray(schema[i].reference_to)) {
+          isNewRefFields = true
+          schema[i].reference_to.forEach(reference => {
+            parent.push(schema[i].uid)
+            update(parent, reference, entry)
+            parent.pop()
+          })
         } else {
-          parent.push(schema[i].uid);
-          update(parent, schema[i].reference_to, entry);
-          parent.pop();
+          parent.push(schema[i].uid)
+          update(parent, schema[i].reference_to, entry)
+          parent.pop()
         }
-        break;
+        break
       case 'group':
-        parent.push(schema[i].uid);
-        find(schema[i].schema, entry);
-        parent.pop();
-        break;
+        parent.push(schema[i].uid)
+        find(schema[i].schema, entry)
+        parent.pop()
+        break
       case 'blocks':
         for (var j = 0, _j = schema[i].blocks.length; j < _j; j++) {
-          parent.push(schema[i].uid);
-          parent.push(schema[i].blocks[j].uid);
-          find(schema[i].blocks[j].schema, entry);
-          parent.pop();
-          parent.pop();
+          parent.push(schema[i].uid)
+          parent.push(schema[i].blocks[j].uid)
+          find(schema[i].blocks[j].schema, entry)
+          parent.pop()
+          parent.pop()
         }
-        break;
+        break
       }
     }
-  };
-  find(data.content_type.schema, data.entry);
+  }
+  find(data.content_type.schema, data.entry)
   if (isNewRefFields) {
-    findUidsInNewRefFields(data.entry, uids);
+    findUidsInNewRefFields(data.entry, uids)
   }
-  uids = _.flattenDeep(uids);
-  // if no references are found, return 
+  uids = _.flattenDeep(uids)
+  // if no references are found, return
   if (uids.length === 0) {
-    return data.entry;
+    return data.entry
   }
 
-  uids = _.uniq(uids);
-  var entry = JSON.stringify(data.entry);
-  uids.forEach(function (uid) {    
+  uids = _.uniq(uids)
+  var entry = JSON.stringify(data.entry)
+  uids.forEach(function (uid) {
     if (mappedUids.hasOwnProperty(uid)) {
-      entry = entry.replace(new RegExp(uid, 'img'), mappedUids[uid]);
-      mapped.push(uid);
+      entry = entry.replace(new RegExp(uid, 'img'), mappedUids[uid])
+      mapped.push(uid)
     } else {
-      unmapped.push(uid);
+      unmapped.push(uid)
     }
-  });
+  })
 
-  if (unmapped.length) {
-    var unmappedUids = helper.readFile(path.join(uidMapperPath, 'unmapped-uids.json'));
-    unmappedUids = unmappedUids || {};
+  if (unmapped.length > 0) {
+    var unmappedUids = helper.readFile(path.join(uidMapperPath, 'unmapped-uids.json'))
+    unmappedUids = unmappedUids || {}
     if (unmappedUids.hasOwnProperty(data.content_type.uid)) {
-      unmappedUids[data.content_type.uid][data.entry.uid] = unmapped;
+      unmappedUids[data.content_type.uid][data.entry.uid] = unmapped
     } else {
       unmappedUids[data.content_type.uid] = {
-        [data.entry.uid]: unmapped
-      };
+        [data.entry.uid]: unmapped,
+      }
     }
     // write the unmapped contents to ./mapper/language/unmapped-uids.json
-    helper.writeFile(path.join(uidMapperPath, 'unmapped-uids.json'), unmappedUids);
+    helper.writeFile(path.join(uidMapperPath, 'unmapped-uids.json'), unmappedUids)
   }
 
-  if (mapped.length) {
-    var _mappedUids = helper.readFile(path.join(uidMapperPath, 'mapped-uids.json'));
-    _mappedUids = _mappedUids || {};
+  if (mapped.length > 0) {
+    var _mappedUids = helper.readFile(path.join(uidMapperPath, 'mapped-uids.json'))
+    _mappedUids = _mappedUids || {}
     if (_mappedUids.hasOwnProperty(data.content_type.uid)) {
-      _mappedUids[data.content_type.uid][data.entry.uid] = mapped;
+      _mappedUids[data.content_type.uid][data.entry.uid] = mapped
     } else {
       _mappedUids[data.content_type.uid] = {
-        [data.entry.uid]: mapped
-      };
+        [data.entry.uid]: mapped,
+      }
     }
     // write the mapped contents to ./mapper/language/mapped-uids.json
-    helper.writeFile(path.join(uidMapperPath, 'mapped-uids.json'), _mappedUids);
+    helper.writeFile(path.join(uidMapperPath, 'mapped-uids.json'), _mappedUids)
   }
 
-  return JSON.parse(entry);
-};
+  return JSON.parse(entry)
+}
 
 function findUidsInNewRefFields(entry, uids) {
   if (entry && typeof entry === 'object') {
     if (entry.uid && entry._content_type_uid) {
-      uids.push(entry.uid);
-    } else if (entry instanceof Array && entry.length) {
-      entry.forEach(function(elem) {
-        findUidsInNewRefFields(elem, uids);
-      });
+      uids.push(entry.uid)
+    } else if (Array.isArray(entry) && entry.length) {
+      entry.forEach(function (elem) {
+        findUidsInNewRefFields(elem, uids)
+      })
     } else if (Object.keys(entry).length) {
       for (var key in entry) {
-        findUidsInNewRefFields(entry[key], uids);
+        if (key) {
+          findUidsInNewRefFields(entry[key], uids)
+        }
       }
     }
   }
-  return;
-}
+}

package/src/lib/util/supress-mandatory-fields.js

@@ -21,7 +21,7 @@ var supress = module.exports = function (schema, flag) {
       if(schema[i].uid !== 'title') {
         schema[i].unique = false;
         schema[i].mandatory = false;
-        flag.supressed = true;
+        flag.suppressed = true;
       }    
     }
   }