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

package/src/lib/util/lookupReplaceEntries.js

@@ -5,68 +5,95 @@
  */
 
 // eslint-disable-next-line unicorn/filename-case
-var path = require('path')
-var _ = require('lodash')
+var path = require('path');
+var _ = require('lodash');
 
-var util = require('.')
-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
-    var len = parent.length
+  function gatherJsonRteEntryIds(jsonRteData) {
+    jsonRteData.children.forEach(element => {
+      if (element.type) {
+        switch (element.type) {
+          case 'a':
+          case 'p': {
+            if (element.children && element.children.length > 0) {
+              gatherJsonRteEntryIds(element)
+            }
+            break;
+          }
+          case 'reference': {
+            if (Object.keys(element.attrs).length > 0 && element.attrs.type === "entry") {
+              if (uids.indexOf(element.attrs['entry-uid']) === -1) {
+                uids.push(element.attrs['entry-uid'])
+              }
+            }
+            if (element.children && element.children.length > 0) {
+              gatherJsonRteEntryIds(element)
+            }
+            break;
+          }
+        }
+      }
+    })
+  }
+
+  var update = function (_parent, form_id, updateEntry) {
+    var _entry = updateEntry
+    var len = _parent.length
     for (var j = 0; j < len; j++) {
-      if (_entry && parent[j]) {
-        if (j === (len - 1) && _entry[parent[j]]) {
+      if (_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 (_entry[_parent[j]].length) {
+              _entry[_parent[j]].forEach((item, idx) => {
                 if (typeof item.uid === 'string' && item._content_type_uid) {
-                  uids.push(item.uid)
-                } else if (typeof item === 'string' && (preserveStackVersion === true)) {
-                  uids.push(item)
+                  uids.push(item.uid);
+                } else if (typeof item === 'string' && preserveStackVersion === true) {
+                  uids.push(item);
                 } else {
-                  uids.push(item)
-                  _entry[parent[j]][idx] = {
+                  uids.push(item);
+                  _entry[_parent[j]][idx] = {
                     uid: item,
                     _content_type_uid: form_id,
-                  }
+                  };
                 }
-              })
+              });
             }
-          } 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 (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 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)
+          _entry = _entry[_parent[j]];
+          var _keys = _.clone(_parent).splice((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) {
+  };
+  var find = function (schema, _entry) {
     for (var i = 0, _i = schema.length; i < _i; i++) {
       switch (schema[i].data_type) {
       case 'reference':
@@ -74,96 +101,147 @@ module.exports = function (data, mappedUids, uidMapperPath) {
           isNewRefFields = true
           schema[i].reference_to.forEach(reference => {
             parent.push(schema[i].uid)
-            update(parent, reference, entry)
+            update(parent, reference, _entry)
             parent.pop()
           })
         } else {
           parent.push(schema[i].uid)
-          update(parent, schema[i].reference_to, entry)
+          update(parent, schema[i].reference_to, _entry)
           parent.pop()
         }
         break
+      case 'global_field':
       case 'group':
         parent.push(schema[i].uid)
-        find(schema[i].schema, entry)
+        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)
+          find(schema[i].blocks[j].schema, _entry)
           parent.pop()
           parent.pop()
         }
         break
+      case 'json':
+        if (schema[i].field_metadata.rich_text_type) {
+          findEntryIdsFromJsonRte(data.entry, data.content_type.schema)
+        }
+        break
+      }
+    }
+  }
+
+  function findEntryIdsFromJsonRte(entry, ctSchema) {
+    for (let i = 0; i < ctSchema.length; i++) {
+      switch (ctSchema[i].data_type) {
+        case 'blocks': {
+          if (entry[ctSchema[i].uid]) {
+            if (ctSchema[i].multiple) {
+              entry[ctSchema[i].uid].forEach(e => {
+                let key = Object.keys(e).pop()
+                let subBlock = ctSchema[i].blocks.filter(e => e.uid === key).pop()
+                findEntryIdsFromJsonRte(e[key], subBlock.schema)
+              })
+            }
+          }
+          break;
+        }
+        case 'global_field':
+        case 'group': {
+          if (entry[ctSchema[i].uid]) {
+            if (ctSchema[i].multiple) {
+              entry[ctSchema[i].uid].forEach(e => {
+                findEntryIdsFromJsonRte(e, ctSchema[i].schema)
+              })
+            } else {
+              findEntryIdsFromJsonRte(entry[ctSchema[i].uid], ctSchema[i].schema)
+            }
+          }
+          break;
+        }
+        case 'json': {
+          if (entry[ctSchema[i].uid] && ctSchema[i].field_metadata.rich_text_type) {
+            if (ctSchema[i].multiple) {
+              entry[ctSchema[i].uid].forEach(jsonRteData => {
+                gatherJsonRteEntryIds(jsonRteData)
+              })
+            } else {
+              gatherJsonRteEntryIds(entry[ctSchema[i].uid])
+            }
+          }
+          break;
+        }
       }
     }
   }
+
   find(data.content_type.schema, data.entry)
   if (isNewRefFields) {
-    findUidsInNewRefFields(data.entry, uids)
+    findUidsInNewRefFields(data.entry, uids);
   }
-  uids = _.flattenDeep(uids)
+  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 = _.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 > 0) {
-    var unmappedUids = helper.readFile(path.join(uidMapperPath, 'unmapped-uids.json'))
-    unmappedUids = unmappedUids || {}
+    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,
-      }
+      };
     }
     // 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 > 0) {
-    var _mappedUids = helper.readFile(path.join(uidMapperPath, 'mapped-uids.json'))
-    _mappedUids = _mappedUids || {}
+    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,
-      }
+      };
     }
     // 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)
+      uids.push(entry.uid);
     } else if (Array.isArray(entry) && entry.length) {
       entry.forEach(function (elem) {
-        findUidsInNewRefFields(elem, uids)
-      })
+        findUidsInNewRefFields(elem, uids);
+      });
     } else if (Object.keys(entry).length) {
       for (var key in entry) {
         if (key) {
-          findUidsInNewRefFields(entry[key], uids)
+          findUidsInNewRefFields(entry[key], uids);
         }
       }
     }

package/src/lib/util/removeReferenceFields.js

@@ -1,42 +1,45 @@
-//var pending_reference_fields = [];
 var _ = require('lodash');
 
-
 /* eslint-disable no-empty */
-var removeReferenceFields = module.exports = function (schema, flag) {
-  for (var i in schema) {
+var removeReferenceFields = (module.exports = function (schema, flag) {
+  for (let i = 0; i < schema.length; i++) {
     if (schema[i].data_type === 'group') {
       removeReferenceFields(schema[i].schema, flag);
     } else if (schema[i].data_type === 'blocks') {
       for (var block in schema[i].blocks) {
         removeReferenceFields(schema[i].blocks[block].schema, flag);
       }
-    } else if(schema[i].data_type === 'reference') {
+    } else if (schema[i].data_type === 'reference') {
       flag.supressed = true;
-      _.remove(schema, function(c) {
-        return c.data_type === 'reference';
-      });
-      
-      if(schema.length < 1) {
+      schema.splice(i, 1);
+      --i;
+      if (schema.length < 1) {
         schema.push({
-          'data_type': 'text',
-          'display_name': 'dummyTest',
-          'uid': 'dummy_test',
-          'field_metadata': {
-            'description': '',
-            'default_value': '',
-            'version': 3
+          data_type: 'text',
+          display_name: 'dummyTest',
+          uid: 'dummy_test',
+          field_metadata: {
+            description: '',
+            default_value: '',
+            version: 3,
           },
-          'format': '',
-          'error_messages': {
-            'format': ''
+          format: '',
+          error_messages: {
+            format: '',
           },
-          'multiple': false,
-          'mandatory': false,
-          'unique': false,
-          'non_localizable': false
+          multiple: false,
+          mandatory: false,
+          unique: false,
+          non_localizable: false,
         });
       }
-    }
+    } else if( // handling entry references in json rte
+      schema[i].data_type === 'json' 
+      && schema[i].field_metadata.rich_text_type
+      && schema[i].field_metadata.embed_entry
+      && schema[i].reference_to.length > 1) {
+        flag.supressed = true;
+        schema[i].reference_to = ["sys_assets"]
+      }
   }
-};
+});

package/src/lib/util/schemaTemplate.js

@@ -1,40 +1,38 @@
 module.exports = {
-  'content_type': {
-    'title': 'Seed',
-    'uid': '',
-    'schema': [
+  content_type: {
+    title: 'Seed',
+    uid: '',
+    schema: [
       {
-        'display_name': 'Title',
-        'uid': 'title',
-        'data_type': 'text',
-        'field_metadata': {
-          '_default': true
+        display_name: 'Title',
+        uid: 'title',
+        data_type: 'text',
+        field_metadata: {
+          _default: true,
         },
-        'unique': false,
-        'mandatory': true,
-        'multiple': false
+        unique: false,
+        mandatory: true,
+        multiple: false,
       },
       {
-        'display_name': 'URL',
-        'uid': 'url',
-        'data_type': 'text',
-        'field_metadata': {
-          '_default': true
+        display_name: 'URL',
+        uid: 'url',
+        data_type: 'text',
+        field_metadata: {
+          _default: true,
         },
-        'unique': false,
-        'multiple': false
-      }
+        unique: false,
+        multiple: false,
+      },
     ],
-    'options': {
-      'title': 'title',
-      'publishable': true,
-      'is_page': true,
-      'singleton': false,
-      'sub_title': [
-        'url'
-      ],
-      'url_pattern': '/:title',
-      'url_prefix': '/'
-    }
-  }
-};
+    options: {
+      title: 'title',
+      publishable: true,
+      is_page: true,
+      singleton: false,
+      sub_title: ['url'],
+      url_pattern: '/:title',
+      url_prefix: '/',
+    },
+  },
+};

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

@@ -4,9 +4,9 @@
  * MIT Licensed
  */
 
-var supress = module.exports = function (schema, flag) {
+var supress = (module.exports = function (schema, flag) {
   for (var i in schema) {
-    if (schema[i].data_type === 'group') {
+    if (schema[i].data_type === 'group' || schema[i].data_type === 'global_field') {
       supress(schema[i].schema, flag);
     } else if (schema[i].data_type === 'blocks') {
       for (var block in schema[i].blocks) {
@@ -14,15 +14,21 @@ var supress = module.exports = function (schema, flag) {
       }
     } else if (schema[i].data_type === 'reference') {
       flag.references = true;
+    } else if (schema[i].data_type === 'json' && schema[i].field_metadata.rich_text_type) {
+      flag.jsonRte = true
+      if (schema[i].field_metadata.embed_entry === true)
+        flag.jsonRteEmbeddedEntries = true;
     }
 
-    if ((schema[i].hasOwnProperty('mandatory') && schema[i].mandatory) || (schema[i].hasOwnProperty('unique') &&
-        schema[i].unique)) {
-      if(schema[i].uid !== 'title') {
+    if (
+      (schema[i].hasOwnProperty('mandatory') && schema[i].mandatory) ||
+      (schema[i].hasOwnProperty('unique') && schema[i].unique)
+    ) {
+      if (schema[i].uid !== 'title') {
         schema[i].unique = false;
         schema[i].mandatory = false;
-        flag.supressed = true;
-      }    
+        flag.suppressed = true;
+      }
     }
   }
-};
+});

package/src/lib/util/upload.js

@@ -4,45 +4,46 @@
  * MIT Licensed
  */
 
-'use strict'
+'use strict';
 
-var fs = require('fs')
-var Bluebird = require('bluebird')
-var request = Bluebird.promisify(require('request'))
-var debug = require('debug')('util:requests')
-var MAX_RETRY_LIMIT = 5
+var debug = require('debug')('util:requests');
+var MAX_RETRY_LIMIT = 5;
+var Bluebird = require('bluebird');
 
-var util = require('./index')
-var config = util.getConfig()
-const client = require('../util/contentstack-management-sdk').Client(config)
+var util = require('./index');
+var config = util.getConfig();
+const client = require('../util/contentstack-management-sdk').Client(config);
 
-function validate (req) {
+function validate(req) {
   if (typeof req !== 'object') {
-    throw new Error(`Invalid params passed for request\n${JSON.stringify(arguments)}`)
+    throw new Error(`Invalid params passed for request\n${JSON.stringify(arguments)}`);
   }
 }
 
-var upload = module.exports = function (req, fsPath, RETRY) {
+var upload = (module.exports = function (req, fsPath, RETRY) {
   return new Bluebird(function (resolve, reject) {
     try {
-      validate(req)
+      validate(req);
       if (typeof RETRY !== 'number') {
-        RETRY = 1
+        RETRY = 1;
       } else if (RETRY > MAX_RETRY_LIMIT) {
-        return reject(new Error('Max retry limit exceeded!'))
+        return reject(new Error('Max retry limit exceeded!'));
       }
-      // var uploadStream = fs.createReadStream(fsPath)
-      
-    req.upload = fsPath
-    client.stack({api_key: config.target_stack, management_token: config.management_token}).asset().create(req)
-      .then(response => {
-           return resolve(response)
-      }).catch(error => {
-        return reject(error)
-      })
+
+      req.upload = fsPath;
+      client
+        .stack({ api_key: config.target_stack, management_token: config.management_token })
+        .asset()
+        .create(req)
+        .then((response) => {
+          return resolve(response);
+        })
+        .catch((error) => {
+          return reject(error);
+        });
     } catch (error) {
-      debug(error)
-      return reject(error)
+      debug(error);
+      return reject(error);
     }
-  })
-};
+  });
+});