@contentstack/cli-cm-import 1.2.4 → 1.4.0

package/src/lib/import/webhooks.js

@@ -15,7 +15,6 @@ const helper = require('../util/fs');
 const { formatError } = require('../util');
 const { addlogs } = require('../util/log');
 const config = require('../../config/default');
-const stack = require('../util/contentstack-management-sdk');
 
 module.exports = class ImportWebhooks {
   config;
@@ -25,15 +24,15 @@ module.exports = class ImportWebhooks {
   webhooksConfig = config.modules.webhooks;
   reqConcurrency = config.concurrency || config.fetchConcurrency;
 
-  constructor(credentialConfig) {
-    this.config = merge(config, credentialConfig);
+  constructor(importConfig, stackAPIClient) {
+    this.config = merge(config, importConfig);
+    this.stackAPIClient = stackAPIClient;
   }
 
   start() {
     addlogs(this.config, chalk.white('Migrating webhooks'), 'success');
 
     const self = this;
-    const client = stack.Client(this.config);
 
     let webMapperPath = path.resolve(this.config.data, 'mapper', 'webhooks');
     let webFailsPath = path.resolve(this.config.data, 'mapper', 'webhooks', 'fails.json');
@@ -68,8 +67,7 @@ module.exports = class ImportWebhooks {
           if (!self.webUidMapper.hasOwnProperty(webUid)) {
             let requestOption = { json: { webhook: web } };
 
-            return client
-              .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
+            return self.stackAPIClient
               .webhook()
               .create(requestOption.json)
               .then(function (response) {

package/src/lib/import/workflows.js

@@ -15,19 +15,17 @@ const helper = require('../util/fs');
 const { formatError } = require('../util');
 const { addlogs } = require('../util/log');
 let config = require('../../config/default');
-let stack = require('../util/contentstack-management-sdk');
 
 module.exports = class importWorkflows {
-  client;
   fails = [];
   success = [];
   workflowUidMapper = {};
   workflowConfig = config.modules.workflows;
   reqConcurrency = config.concurrency || config.fetchConcurrency || 1;
 
-  constructor(credentialConfig) {
-    this.config = merge(config, credentialConfig);
-    this.client = stack.Client(this.config);
+  constructor(importConfig, stackAPIClient) {
+    this.config = merge(config, importConfig);
+    this.stackAPIClient = stackAPIClient;
   }
 
   start() {
@@ -63,10 +61,7 @@ module.exports = class importWorkflows {
           if (!self.workflowUidMapper.hasOwnProperty(workflowUid)) {
             const roleNameMap = {};
             const workflowStages = workflow.workflow_stages;
-            const roles = await self.client
-              .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
-              .role()
-              .fetchAll();
+            const roles = await self.stackAPIClient.role().fetchAll();
 
             for (const role of roles.items) {
               roleNameMap[role.name] = role.uid;
@@ -92,10 +87,7 @@ module.exports = class importWorkflows {
                         });
                       }
 
-                      const role = await self.client
-                        .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
-                        .role()
-                        .create({ role: roleData });
+                      const role = await self.stackAPIClient.role().create({ role: roleData });
                       stage.SYS_ACL.roles.uids[i] = role.uid;
                       roleNameMap[roleData.name] = role.uid;
                     } else {
@@ -126,8 +118,7 @@ module.exports = class importWorkflows {
               workflow.branches = ['main'];
             }
 
-            return self.client
-              .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
+            return self.stackAPIClient
               .workflow()
               .create({ workflow })
               .then(function (response) {

package/src/lib/util/extensionsUidReplace.js

@@ -12,7 +12,6 @@ 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');
-const marketplaceAppPath = path.resolve(config.data, 'marketplace_apps', 'marketplace_apps.json');
 
 // eslint-disable-next-line camelcase
 let extension_uid_Replace = (module.exports = function (schema, preserveStackVersion, installedExtensions) {
@@ -50,38 +49,8 @@ let extension_uid_Replace = (module.exports = function (schema, preserveStackVer
         // eslint-disable-next-line camelcase
         schema[i].extension_uid = data[extension_key_value];
       } else if (schema[i].field_metadata && schema[i].field_metadata.extension) {
-        if (installedExtensions) {
-          const marketplaceApps = helper.readFileSync(marketplaceAppPath);
-          const oldExt = _.find(marketplaceApps, { uid: schema[i].extension_uid });
-
-          if (oldExt) {
-            let ext = _.find(installedExtensions, (ext) => {
-              const { type, title, app_uid } = ext;
-
-              if (type === 'field' && app_uid === oldExt.app_uid) {
-                const titles = [
-                  ...(oldExt.manifest
-                    ? _.map(
-                        _.map(
-                          oldExt.manifest && oldExt.manifest.ui_location && oldExt.manifest.ui_location.locations,
-                          'meta',
-                        ).flat(),
-                        'name',
-                      )
-                    : []),
-                  oldExt.title,
-                ];
-
-                return _.includes(titles, title);
-              }
-
-              return false;
-            });
-
-            if (ext) {
-              schema[i].extension_uid = ext.uid;
-            }
-          }
+        if (installedExtensions && installedExtensions[schema[i].extension_uid]) {
+          schema[i].extension_uid = installedExtensions[schema[i].extension_uid];
         }
       }
     } else if (schema[i].data_type === 'json' && schema[i].hasOwnProperty('plugins') && schema[i].plugins.length > 0) {

package/src/lib/util/fs.js

@@ -118,3 +118,7 @@ exports.readdirSync = function (dirPath) {
     return [];
   }
 };
+
+exports.fileExistsSync = function (path) {
+  return fs.existsSync(path);
+};

package/src/lib/util/index.js

@@ -5,27 +5,26 @@
  * MIT Licensed
  */
 
-var _ = require('lodash');
-const { HttpClient } = require('@contentstack/cli-utilities');
-var fs = require('./fs');
-var path = require('path');
-var chalk = require('chalk');
-var { addlogs } = require('./log');
-var defaultConfig = require('../../config/default');
-const stack = require('./contentstack-management-sdk');
+const _ = require('lodash');
+const { HttpClient, managementSDKClient } = require('@contentstack/cli-utilities');
+const fs = require('./fs');
+const path = require('path');
+const chalk = require('chalk');
+const { addlogs } = require('./log');
+const defaultConfig = require('../../config/default');
 const promiseLimit = require('promise-limit');
-var config;
+let config;
 
-exports.initialization = function (configData) {
+exports.initialization = (configData) => {
   config = this.buildAppConfig(configData);
-  var res = this.validateConfig(config);
+  const res = this.validateConfig(config);
 
   if ((res && res !== 'error') || res === undefined) {
     return config;
   }
 };
 
-exports.validateConfig = function (importConfig) {
+exports.validateConfig = (importConfig) => {
   if (importConfig.email && importConfig.password && !importConfig.target_stack) {
     addlogs(importConfig, chalk.red('Kindly provide api_token'), 'error');
     return 'error';
@@ -47,12 +46,12 @@ exports.validateConfig = function (importConfig) {
   }
 };
 
-exports.buildAppConfig = function (importConfig) {
+exports.buildAppConfig = (importConfig) => {
   importConfig = _.merge(defaultConfig, importConfig);
   return importConfig;
 };
 
-exports.sanitizeStack = function (importConfig) {
+exports.sanitizeStack = (importConfig) => {
   if (typeof importConfig.preserveStackVersion !== 'boolean' || !importConfig.preserveStackVersion) {
     return Promise.resolve();
   }
@@ -103,17 +102,13 @@ exports.sanitizeStack = function (importConfig) {
   }
 };
 
-exports.masterLocalDetails = function (credentialConfig) {
-  let client = stack.Client(credentialConfig);
+exports.masterLocalDetails = (stackAPIClient) => {
   return new Promise((resolve, reject) => {
-    var result = client
-      .stack({ api_key: credentialConfig.target_stack, management_token: credentialConfig.management_token })
-      .locale()
-      .query();
+    const result = stackAPIClient.locale().query();
     result
       .find()
       .then((response) => {
-        var masterLocalObj = response.items.filter((obj) => {
+        const masterLocalObj = response.items.filter((obj) => {
           if (obj.fallback_locale === null) {
             return obj;
           }
@@ -126,68 +121,72 @@ exports.masterLocalDetails = function (credentialConfig) {
   });
 };
 
-exports.field_rules_update = function (importConfig, ctPath) {
-  return new Promise(function (resolve, reject) {
-    let client = stack.Client(importConfig);
-
-    fs.readFileSync(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(importConfig.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.readFileSync(path.join(entryUidMapperPath));
-                    if (oldUid.hasOwnProperty(splitedFieldRulesValue)) {
-                      updatedValue.push(oldUid[splitedFieldRulesValue]);
-                    } else {
-                      updatedValue.push(fieldRulesArray[j]);
+exports.field_rules_update = (importConfig, ctPath) => {
+  return new Promise((resolve, reject) => {
+    managementSDKClient(config)
+      .then((APIClient) => {
+        fs.readFileSync(path.join(ctPath + '/field_rules_uid.json'), async (err, data) => {
+          if (err) {
+            throw err;
+          }
+          const ct_field_visibility_uid = JSON.parse(data);
+          let ct_files = fs.readdirSync(ctPath);
+          if (ct_field_visibility_uid && ct_field_visibility_uid != 'undefined') {
+            for (const ele of ct_field_visibility_uid) {
+              if (ct_files.indexOf(ele + '.json') > -1) {
+                let schema = require(path.resolve(ctPath, ele));
+                // 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(importConfig.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 (const element of fieldRulesArray) {
+                        let splitedFieldRulesValue = element;
+                        let oldUid = helper.readFileSync(path.join(entryUidMapperPath));
+                        if (oldUid.hasOwnProperty(splitedFieldRulesValue)) {
+                          updatedValue.push(oldUid[splitedFieldRulesValue]);
+                        } else {
+                          updatedValue.push(element);
+                        }
+                      }
+                      schema.field_rules[k].conditions[i].value = updatedValue.join('.');
                     }
                   }
-                  schema.field_rules[k].conditions[i].value = updatedValue.join('.');
                 }
+                const stackAPIClient = APIClient.stack({
+                  api_key: importConfig.target_stack,
+                  management_token: importConfig.management_token,
+                });
+                let ctObj = stackAPIClient.contentType(schema.uid);
+                Object.assign(ctObj, _.cloneDeep(schema));
+                ctObj
+                  .update()
+                  .then(() => {
+                    return resolve();
+                  })
+                  .catch((error) => {
+                    return reject(error);
+                  });
               }
             }
-            let ctObj = client
-              .stack({ api_key: importConfig.target_stack, management_token: importConfig.management_token })
-              .contentType(schema.uid);
-            Object.assign(ctObj, _.cloneDeep(schema));
-            ctObj
-              .update()
-              .then(() => {
-                return resolve();
-              })
-              .catch(function (error) {
-                return reject(error);
-              });
           }
-        }
-      }
-    });
+        });
+      })
+      .catch(reject);
   });
 };
 
-exports.getConfig = function () {
+exports.getConfig = () => {
   return config;
 };
 
-exports.formatError = function (error) {
+exports.formatError = (error) => {
   try {
     if (typeof error === 'string') {
       error = JSON.parse(error);
@@ -209,7 +208,7 @@ exports.formatError = function (error) {
   return message;
 };
 
-exports.executeTask = function (tasks = [], handler, options) {
+exports.executeTask = (handler, options, tasks = []) => {
   if (typeof handler !== 'function') {
     throw new Error('Invalid handler');
   }

package/src/lib/util/login.js

@@ -8,49 +8,52 @@
 const chalk = require('chalk');
 
 const { addlogs } = require('../util/log');
-let stack = require('../util/contentstack-management-sdk');
-let client;
+const { managementSDKClient } = require('@contentstack/cli-utilities');
 
-module.exports = function (config) {
-  client = stack.Client(config);
-
-  return new Promise(function (resolve, reject) {
-    // eslint-disable-next-line no-console
-    if (config.email && config.password) {
-      console.log('Logging into Contentstack');
-      return client
-        .login({ email: config.email, password: config.password })
-        .then(function (response) {
-          // eslint-disable-next-line no-console
-          console.log(chalk.green('Contentstack account authenticated successfully!'));
-          config.authtoken = response.user.authtoken;
-          config.headers = {
-            api_key: config.target_stack,
-            authtoken: config.authtoken,
-            'X-User-Agent': 'contentstack-import/v',
-          };
-          return resolve(config);
-        })
-        .catch(reject);
-    } else if (config.management_token) {
-      return resolve();
-    } else if (config.auth_token) {
-      client
-        .stack({ api_key: config.target_stack, management_token: config.management_token })
-        .fetch()
-        .then(function (stack) {
-          config.destinationStackName = stack.name
+module.exports = (config) => {
+  return new Promise((resolve, reject) => {
+    managementSDKClient(config)
+      .then((APIClient) => {
+        // eslint-disable-next-line no-console
+        if (config.email && config.password) {
+          console.log('Logging into Contentstack');
+          return APIClient.login({ email: config.email, password: config.password })
+            .then((response) => {
+              // eslint-disable-next-line no-console
+              console.log(chalk.green('Contentstack account authenticated successfully!'));
+              config.authtoken = response.user.authtoken;
+              config.headers = {
+                api_key: config.target_stack,
+                authtoken: config.authtoken,
+                'X-User-Agent': 'contentstack-import/v',
+              };
+              return resolve(config);
+            })
+            .catch(reject);
+        } else if (config.management_token) {
           return resolve();
-        })
-        .catch((error) => {
-          let errorstack_key = error.errors.api_key;
-          if (error.errors.api_key) {
-            addlogs(config, chalk.red('Stack Api key ' + errorstack_key[0], 'Please enter valid Key'), 'error');
-            return reject(error);
-          }
-          addlogs(config, error.errorMessage, 'error');
-          return reject(error);
-        });
-    }
+        } else if (config.auth_token) {
+          const stackAPIClient = APIClient.stack({
+            api_key: config.target_stack,
+            management_token: config.management_token,
+          });
+          stackAPIClient
+            .fetch()
+            .then((stack) => {
+              config.destinationStackName = stack.name;
+              return resolve();
+            })
+            .catch((error) => {
+              let errorstack_key = error.errors.api_key;
+              if (error.errors.api_key) {
+                addlogs(config, chalk.red('Stack Api key ' + errorstack_key[0], 'Please enter valid Key'), 'error');
+                return reject(error);
+              }
+              addlogs(config, error.errorMessage, 'error');
+              return reject(error);
+            });
+        }
+      })
+      .catch((error) => reject(error));
   });
 };

package/src/lib/util/lookupReplaceAssets.js

@@ -10,9 +10,6 @@ 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, installedExtensions) {
@@ -75,38 +72,8 @@ module.exports = function (data, mappedAssetUids, mappedAssetUrls, assetUidMappe
       ) {
         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) {
-            let ext = _.find(installedExtensions, (ext) => {
-              const { type, title, app_uid } = ext;
-
-              if (type === 'field' && app_uid === oldExt.app_uid) {
-                const titles = [
-                  ...(oldExt.manifest
-                    ? _.map(
-                        _.map(
-                          oldExt.manifest && oldExt.manifest.ui_location && oldExt.manifest.ui_location.locations,
-                          'meta',
-                        ).flat(),
-                        'name',
-                      )
-                    : []),
-                  oldExt.title,
-                ];
-
-                return _.includes(titles, title);
-              }
-
-              return false;
-            });
-
-            if (ext) {
-              schema[i].extension_uid = ext.uid;
-            }
-          }
+        if (installedExtensions && installedExtensions[schema[i].extension_uid]) {
+          schema[i].extension_uid = installedExtensions[schema[i].extension_uid];
         }
       }
     }
@@ -116,71 +83,13 @@ module.exports = function (data, mappedAssetUids, mappedAssetUrls, assetUidMappe
     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) {
-              let ext = _.find(installedExtensions, (ext) => {
-                const { type, title, app_uid } = ext;
-
-                if (type === 'field' && app_uid === oldExt.app_uid) {
-                  const titles = [
-                    ...(oldExt.manifest
-                      ? _.map(
-                          _.map(
-                            oldExt.manifest && oldExt.manifest.ui_location && oldExt.manifest.ui_location.locations,
-                            'meta',
-                          ).flat(),
-                          'name',
-                        )
-                      : []),
-                    oldExt.title,
-                  ];
-
-                  return _.includes(titles, title);
-                }
-
-                return false;
-              });
-
-              if (ext) {
-                row.extension_uid = ext.uid;
-              }
-            }
+          if (installedExtensions && installedExtensions[row.extension_uid]) {
+            row.extension_uid = installedExtensions[row.extension_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) {
-              let ext = _.find(installedExtensions, (ext) => {
-                const { type, title, app_uid } = ext;
-
-                if (type === 'field' && app_uid === oldExt.app_uid) {
-                  const titles = [
-                    ...(oldExt.manifest
-                      ? _.map(
-                          _.map(
-                            oldExt.manifest && oldExt.manifest.ui_location && oldExt.manifest.ui_location.locations,
-                            'meta',
-                          ).flat(),
-                          'name',
-                        )
-                      : []),
-                    oldExt.title,
-                  ];
-
-                  return _.includes(titles, title);
-                }
-
-                return false;
-              });
-
-              if (ext) {
-                entryObj[row.uid].metadata.extension_uid = ext.uid;
-              }
+            if (installedExtensions && installedExtensions[entryObj[row.uid].metadata.extension_uid]) {
+              entryObj[row.uid].metadata.extension_uid = installedExtensions[entryObj[row.uid].metadata.extension_uid];
             }
           }
         }
@@ -310,7 +219,9 @@ module.exports = function (data, mappedAssetUids, mappedAssetUrls, assetUidMappe
         [data.entry.uid]: matchedUids,
       };
     }
-    helper.writeFile(path.join(assetUidMapperPath, 'matched-asset-uids.json'));
+    if (!helper.fileExistsSync(path.join(assetUidMapperPath, 'matched-asset-uids.json'))) {
+      helper.writeFile(path.join(assetUidMapperPath, 'matched-asset-uids.json'));
+    }
   }
 
   if (unmatchedUids.length) {

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

@@ -1,41 +1,14 @@
-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 { formatError } = require('.');
+const { cliux, configHandler } = require('@contentstack/cli-utilities');
+
+const getAllStackSpecificApps = (developerHubBaseUrl, httpClient, config) => {
+  return httpClient
+    .get(`${developerHubBaseUrl}/installations?target_uids=${config.target_stack}`)
+    .then(({ data }) => data.data)
+    .catch((error) => log(config, `Failed to export marketplace-apps ${formatError(error)}`, 'error'));
 };
 
-const getDeveloperHubUrl = async () => {
+const getDeveloperHubUrl = async (config) => {
   const { cma, name } = configHandler.get('region') || {};
   let developerHubBaseUrl = config.developerHubUrls[cma];
 
@@ -55,4 +28,4 @@ const getDeveloperHubUrl = async () => {
   return developerHubBaseUrl.startsWith('http') ? developerHubBaseUrl : `https://${developerHubBaseUrl}`;
 };
 
-module.exports = { getInstalledExtensions, getDeveloperHubUrl };
+module.exports = { getAllStackSpecificApps, getDeveloperHubUrl };