@contentstack/cli-cm-import 1.0.1 → 1.2.0

package/src/lib/util/lookupReplaceAssets.js

@@ -10,9 +10,12 @@ let _ = require('lodash');
 let { marked } = require('marked');
 
 let helper = require('./fs');
+const { getConfig } = require('./');
+let config = getConfig();
+const marketplaceAppPath = path.resolve(config.data, 'marketplace_apps', 'marketplace_apps.json');
 
 // get assets object
-module.exports = function (data, mappedAssetUids, mappedAssetUrls, assetUidMapperPath) {
+module.exports = function (data, mappedAssetUids, mappedAssetUrls, assetUidMapperPath, installedExtensions) {
   if (
     !_.has(data, 'entry') ||
     !_.has(data, 'content_type') ||
@@ -65,10 +68,77 @@ module.exports = function (data, mappedAssetUids, mappedAssetUrls, assetUidMappe
         findAssetIdsFromJsonRte(data.entry, data.content_type.schema);
         // maybe only one of these checks would be enough
         parent.pop();
+      } else if (
+        schema[i].data_type === 'json' &&
+        schema[i].field_metadata.extension &&
+        schema[i].field_metadata.is_asset
+      ) {
+        findAssetIdsFromJsonCustomFields(data.entry, data.content_type.schema);
+      } else if (schema[i].data_type === 'json' && schema[i].field_metadata.extension) {
+        if (installedExtensions) {
+          const marketplaceApps = helper.readFileSync(marketplaceAppPath);
+          const oldExt = _.find(marketplaceApps, { uid: schema[i].extension_uid });
+
+          if (oldExt) {
+            const ext = _.find(installedExtensions, {
+              type: oldExt.type,
+              title: oldExt.title,
+              app_uid: oldExt.app_uid,
+            });
+
+            if (ext) {
+              schema[i].extension_uid = ext.uid;
+            }
+          }
+        }
       }
     }
   };
 
+  function findAssetIdsFromJsonCustomFields(entryObj, ctSchema) {
+    ctSchema.map((row) => {
+      if (row.data_type === 'json') {
+        if (entryObj[row.uid] && row.field_metadata.extension && row.field_metadata.is_asset) {
+          if (installedExtensions) {
+            const marketplaceApps = helper.readFileSync(marketplaceAppPath);
+            const oldExt = _.find(marketplaceApps, { uid: row.extension_uid });
+
+            if (oldExt) {
+              const ext = _.find(installedExtensions, {
+                type: oldExt.type,
+                title: oldExt.title,
+                app_uid: oldExt.app_uid,
+              });
+
+              if (ext) {
+                row.extension_uid = ext.uid;
+              }
+            }
+          }
+
+          if (entryObj[row.uid].metadata && entryObj[row.uid].metadata.extension_uid) {
+            const marketplaceApps = helper.readFileSync(marketplaceAppPath);
+            const oldExt = _.find(marketplaceApps, { uid: entryObj[row.uid].metadata.extension_uid });
+
+            if (oldExt) {
+              const ext = _.find(installedExtensions, {
+                type: oldExt.type,
+                title: oldExt.title,
+                app_uid: oldExt.app_uid,
+              });
+
+              if (ext) {
+                entryObj[row.uid].metadata.extension_uid = ext.uid;
+              }
+            }
+          }
+        }
+      }
+
+      return row;
+    });
+  }
+
   function findAssetIdsFromJsonRte(entryObj, ctSchema) {
     for (const element of ctSchema) {
       switch (element.data_type) {
@@ -154,7 +224,7 @@ module.exports = function (data, mappedAssetUids, mappedAssetUrls, assetUidMappe
   }
 
   find(data.content_type.schema, data.entry);
-  updateFileFields(data.entry, data, null, mappedAssetUids, matchedUids, unmatchedUids);
+  updateFileFields(data.entry, data, null, mappedAssetUids, matchedUids, unmatchedUids, mappedAssetUrls);
   assetUids = _.uniq(assetUids);
   assetUrls = _.uniq(assetUrls);
   let entry = JSON.stringify(data.entry);
@@ -180,7 +250,7 @@ module.exports = function (data, mappedAssetUids, mappedAssetUrls, assetUidMappe
   });
 
   if (matchedUids.length) {
-    let matchedAssetUids = helper.readFile(path.join(assetUidMapperPath, 'matched-asset-uids.json'));
+    let matchedAssetUids = helper.readFileSync(path.join(assetUidMapperPath, 'matched-asset-uids.json'));
     matchedAssetUids = matchedAssetUids || {};
     if (matchedAssetUids.hasOwnProperty(data.content_type.uid)) {
       matchedAssetUids[data.content_type.uid][data.entry.uid] = matchedUids;
@@ -193,7 +263,7 @@ module.exports = function (data, mappedAssetUids, mappedAssetUrls, assetUidMappe
   }
 
   if (unmatchedUids.length) {
-    let unmatchedAssetUids = helper.readFile(path.join(assetUidMapperPath, 'unmatched-asset-uids.json'));
+    let unmatchedAssetUids = helper.readFileSync(path.join(assetUidMapperPath, 'unmatched-asset-uids.json'));
     unmatchedAssetUids = unmatchedAssetUids || {};
     if (unmatchedAssetUids.hasOwnProperty(data.content_type.uid)) {
       unmatchedAssetUids[data.content_type.uid][data.entry.uid] = unmatchedUids;
@@ -206,7 +276,7 @@ module.exports = function (data, mappedAssetUids, mappedAssetUrls, assetUidMappe
   }
 
   if (unmatchedUrls.length) {
-    let unmatchedAssetUrls = helper.readFile(path.join(assetUidMapperPath, 'unmatched-asset-urls.json'));
+    let unmatchedAssetUrls = helper.readFileSync(path.join(assetUidMapperPath, 'unmatched-asset-urls.json'));
     unmatchedAssetUrls = unmatchedAssetUrls || {};
     if (unmatchedAssetUrls.hasOwnProperty(data.content_type.uid)) {
       unmatchedAssetUrls[data.content_type.uid][data.entry.uid] = unmatchedUrls;
@@ -219,7 +289,7 @@ module.exports = function (data, mappedAssetUids, mappedAssetUrls, assetUidMappe
   }
 
   if (matchedUrls.length) {
-    let matchedAssetUrls = helper.readFile(path.join(assetUidMapperPath, 'matched-asset-urls.json'));
+    let matchedAssetUrls = helper.readFileSync(path.join(assetUidMapperPath, 'matched-asset-urls.json'));
     matchedAssetUrls = matchedAssetUrls || {};
     if (matchedAssetUrls.hasOwnProperty(data.content_type.uid)) {
       matchedAssetUrls[data.content_type.uid][data.entry.uid] = matchedUrls;
@@ -277,16 +347,49 @@ function findFileUrls(schema, _entry, assetUrls) {
   }
 }
 
-function updateFileFields(objekt, parent, pos, mappedAssetUids, matchedUids, unmatchedUids) {
+function updateFileFields(objekt, parent, pos, mappedAssetUids, matchedUids, unmatchedUids, mappedAssetUrls) {
   if (_.isPlainObject(objekt) && _.has(objekt, 'filename') && _.has(objekt, 'uid')) {
     if (typeof pos !== 'undefined') {
       if (typeof pos === 'number' || typeof pos === 'string') {
-        if (mappedAssetUids.hasOwnProperty(objekt.uid)) {
-          parent[pos] = mappedAssetUids[objekt.uid];
-          matchedUids.push(objekt.uid);
+        const replacer = () => {
+          if (mappedAssetUids.hasOwnProperty(objekt.uid)) {
+            parent[pos] = mappedAssetUids[objekt.uid];
+            matchedUids.push(objekt.uid);
+          } else {
+            parent[pos] = '';
+            unmatchedUids.push(objekt.uid);
+          }
+        };
+
+        if (parent.uid && mappedAssetUids[parent.uid]) {
+          parent.uid = mappedAssetUids[parent.uid];
+        }
+
+        if (
+          objekt &&
+          _.isObject(parent[pos]) &&
+          parent[pos].uid &&
+          parent[pos].url &&
+          _.has(parent, 'asset') &&
+          _.has(parent, '_content_type_uid') &&
+          parent._content_type_uid === 'sys_assets'
+        ) {
+          if (
+            _.has(parent, 'asset') &&
+            _.has(parent, '_content_type_uid') &&
+            parent._content_type_uid === 'sys_assets'
+          ) {
+            parent = _.omit(parent, ['asset']);
+          }
+
+          if (objekt.uid && mappedAssetUids && mappedAssetUids[objekt.uid]) {
+            objekt.uid = mappedAssetUids[objekt.uid];
+          }
+          if (objekt.url && mappedAssetUrls && mappedAssetUrls[objekt.url]) {
+            objekt.url = mappedAssetUrls[objekt.url];
+          }
         } else {
-          parent[pos] = '';
-          unmatchedUids.push(objekt.uid);
+          replacer();
         }
       }
     }

package/src/lib/util/lookupReplaceEntries.js

@@ -5,53 +5,54 @@
  */
 
 // eslint-disable-next-line unicorn/filename-case
-var path = require('path');
-var _ = require('lodash');
+const path = require('path');
+const _ = require('lodash');
 
-var util = require('.');
-var helper = require('./fs');
-var config = util.getConfig();
+const util = require('.');
+const helper = require('./fs');
+const config = util.getConfig();
 // update references in entry object
 module.exports = function (data, mappedUids, uidMapperPath) {
-  var parent = [];
-  var uids = [];
-  var unmapped = [];
-  var mapped = [];
+  let parent = [];
+  let uids = [];
+  let unmapped = [];
+  let mapped = [];
 
-  var isNewRefFields = false;
-  var preserveStackVersion = config.preserveStackVersion;
+  let isNewRefFields = false;
+  let preserveStackVersion = config.preserveStackVersion;
 
   function gatherJsonRteEntryIds(jsonRteData) {
-    jsonRteData.children.forEach(element => {
+    jsonRteData.children.forEach((element) => {
       if (element.type) {
         switch (element.type) {
           case 'a':
           case 'p': {
             if (element.children && element.children.length > 0) {
-              gatherJsonRteEntryIds(element)
+              gatherJsonRteEntryIds(element);
             }
             break;
           }
           case 'reference': {
-            if (Object.keys(element.attrs).length > 0 && element.attrs.type === "entry") {
+            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'])
+                uids.push(element.attrs['entry-uid']);
               }
             }
             if (element.children && element.children.length > 0) {
-              gatherJsonRteEntryIds(element)
+              gatherJsonRteEntryIds(element);
             }
             break;
           }
         }
       }
-    })
+    });
   }
 
-  var update = function (_parent, form_id, updateEntry) {
-    var _entry = updateEntry
-    var len = _parent.length
-    for (var j = 0; j < len; j++) {
+  const update = function (_parent, form_id, updateEntry) {
+    let _entry = updateEntry;
+    let len = _parent.length;
+
+    for (let j = 0; j < len; j++) {
       if (_entry && _parent[j]) {
         if (j === len - 1 && _entry[_parent[j]]) {
           if (form_id !== '_assets') {
@@ -71,9 +72,9 @@ module.exports = function (data, mappedUids, uidMapperPath) {
               });
             }
           } 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);
+            for (const element of _entry[_parent[j]]) {
+              if (element.uid.length) {
+                uids.push(element.uid);
               }
             }
           } else if (_entry[_parent[j]].uid.length) {
@@ -81,9 +82,9 @@ module.exports = function (data, mappedUids, uidMapperPath) {
           }
         } else {
           _entry = _entry[_parent[j]];
-          var _keys = _.clone(_parent).splice((j+1), len);
+          let _keys = _.clone(_parent).splice(j + 1, len);
           if (Array.isArray(_entry)) {
-            for (var i = 0, _i = _entry.length; i < _i; i++) {
+            for (let i = 0, _i = _entry.length; i < _i; i++) {
               update(_keys, form_id, _entry[i]);
             }
           } else if (!(_entry instanceof Object)) {
@@ -93,83 +94,83 @@ module.exports = function (data, mappedUids, uidMapperPath) {
       }
     }
   };
-  var find = function (schema, _entry) {
-    for (var i = 0, _i = schema.length; i < _i; i++) {
+  const find = function (schema, _entry) {
+    for (let i = 0, _i = schema.length; i < _i; i++) {
       switch (schema[i].data_type) {
-      case 'reference':
-        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()
-        }
-        break
-      case 'global_field':
-      case 'group':
-        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()
-        }
-        break
-      case 'json':
-        if (schema[i].field_metadata.rich_text_type) {
-          findEntryIdsFromJsonRte(data.entry, data.content_type.schema)
-        }
-        break
+        case 'reference':
+          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();
+          }
+          break;
+        case 'global_field':
+        case 'group':
+          parent.push(schema[i].uid);
+          find(schema[i].schema, _entry);
+          parent.pop();
+          break;
+        case 'blocks':
+          for (let 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();
+          }
+          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) {
+    for (const element of ctSchema) {
+      switch (element.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)
-              })
+          if (entry[element.uid]) {
+            if (element.multiple) {
+              entry[element.uid].forEach((e) => {
+                let key = Object.keys(e).pop();
+                let subBlock = element.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)
-              })
+          if (entry[element.uid]) {
+            if (element.multiple) {
+              entry[element.uid].forEach((e) => {
+                findEntryIdsFromJsonRte(e, element.schema);
+              });
             } else {
-              findEntryIdsFromJsonRte(entry[ctSchema[i].uid], ctSchema[i].schema)
+              findEntryIdsFromJsonRte(entry[element.uid], element.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)
-              })
+          if (entry[element.uid] && element.field_metadata.rich_text_type) {
+            if (element.multiple) {
+              entry[element.uid].forEach((jsonRteData) => {
+                gatherJsonRteEntryIds(jsonRteData);
+              });
             } else {
-              gatherJsonRteEntryIds(entry[ctSchema[i].uid])
+              gatherJsonRteEntryIds(entry[element.uid]);
             }
           }
           break;
@@ -178,7 +179,7 @@ module.exports = function (data, mappedUids, uidMapperPath) {
     }
   }
 
-  find(data.content_type.schema, data.entry)
+  find(data.content_type.schema, data.entry);
   if (isNewRefFields) {
     findUidsInNewRefFields(data.entry, uids);
   }
@@ -189,7 +190,7 @@ module.exports = function (data, mappedUids, uidMapperPath) {
   }
 
   uids = _.uniq(uids);
-  var entry = JSON.stringify(data.entry);
+  let entry = JSON.stringify(data.entry);
   uids.forEach(function (uid) {
     if (mappedUids.hasOwnProperty(uid)) {
       entry = entry.replace(new RegExp(uid, 'img'), mappedUids[uid]);
@@ -200,7 +201,7 @@ module.exports = function (data, mappedUids, uidMapperPath) {
   });
 
   if (unmapped.length > 0) {
-    var unmappedUids = helper.readFile(path.join(uidMapperPath, 'unmapped-uids.json'));
+    let unmappedUids = helper.readFileSync(path.join(uidMapperPath, 'unmapped-uids.json'));
     unmappedUids = unmappedUids || {};
     if (unmappedUids.hasOwnProperty(data.content_type.uid)) {
       unmappedUids[data.content_type.uid][data.entry.uid] = unmapped;
@@ -214,7 +215,7 @@ module.exports = function (data, mappedUids, uidMapperPath) {
   }
 
   if (mapped.length > 0) {
-    var _mappedUids = helper.readFile(path.join(uidMapperPath, 'mapped-uids.json'));
+    let _mappedUids = helper.readFileSync(path.join(uidMapperPath, 'mapped-uids.json'));
     _mappedUids = _mappedUids || {};
     if (_mappedUids.hasOwnProperty(data.content_type.uid)) {
       _mappedUids[data.content_type.uid][data.entry.uid] = mapped;
@@ -239,7 +240,7 @@ function findUidsInNewRefFields(entry, uids) {
         findUidsInNewRefFields(elem, uids);
       });
     } else if (Object.keys(entry).length) {
-      for (var key in entry) {
+      for (let key in entry) {
         if (key) {
           findUidsInNewRefFields(entry[key], uids);
         }

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

@@ -0,0 +1,57 @@
+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 { target_stack: api_key, management_token, auth_token } = config || {}
+
+    if (api_key && management_token) {
+      return 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))
+    } else {
+      resolve([])
+    }
+  })
+}
+
+const getDeveloperHubUrl = async () => {
+  const { cma, name } = configHandler.get('region') || {};
+  let developerHubBaseUrl = config.developerHubUrls[cma];
+
+  if (!developerHubBaseUrl) {
+    developerHubBaseUrl = await cliux.inquire({
+      type: 'input',
+      name: 'name',
+      validate: (url) => {
+        if (!url) return "Developer-hub URL can't be empty.";
+
+        return true;
+      },
+      message: `Enter the developer-hub base URL for the ${name} region - `,
+    });
+  }
+
+  return developerHubBaseUrl.startsWith('http') ? developerHubBaseUrl : `https://${developerHubBaseUrl}`;
+}
+
+module.exports = { getInstalledExtensions, getDeveloperHubUrl }