@contentstack/cli-cm-import 1.2.4 → 1.4.0

package/src/lib/import/environments.js

@@ -9,13 +9,12 @@ const path = require('path');
 const chalk = require('chalk');
 const mkdirp = require('mkdirp');
 const Promise = require('bluebird');
-const { isEmpty } = require('lodash');
+const { isEmpty, merge } = require('lodash');
 
 const helper = require('../util/fs');
 let { addlogs } = require('../util/log');
 const { formatError } = require('../util');
 const config = require('../../config/default');
-const stack = require('../util/contentstack-management-sdk');
 
 module.exports = class ImportEnvironments {
   fails = [];
@@ -23,15 +22,15 @@ module.exports = class ImportEnvironments {
   envUidMapper = {};
   fetchConcurrency = config.modules.environments.concurrency || config.fetchConcurrency || 2;
 
-  constructor(credentialConfig) {
-    this.config = credentialConfig;
+  constructor(importConfig, stackAPIClient) {
+    this.config = merge(config, importConfig);
+    this.stackAPIClient = stackAPIClient;
   }
 
   start() {
     addlogs(this.config, 'Migrating environment', 'success');
 
     const self = this;
-    const client = stack.Client(this.config);
     let environmentConfig = config.modules.environments;
     let environmentsFolderPath = path.resolve(this.config.data, environmentConfig.dirName);
     let envMapperPath = path.resolve(this.config.data, 'mapper', 'environments');
@@ -60,8 +59,7 @@ module.exports = class ImportEnvironments {
           if (!self.envUidMapper.hasOwnProperty(envUid)) {
             let requestOption = { environment: env };
 
-            return client
-              .stack({ api_key: config.target_stack, management_token: config.management_token })
+            return self.stackAPIClient
               .environment()
               .create(requestOption)
               .then((environment) => {

package/src/lib/import/extensions.js

@@ -9,15 +9,13 @@ const fs = require('fs');
 const path = require('path');
 const Promise = require('bluebird');
 const chalk = require('chalk');
-const { isEmpty } = require('lodash');
+const { isEmpty, merge } = require('lodash');
 
 const util = require('../util');
 const helper = require('../util/fs');
 const { addlogs } = require('../util/log');
-const { formatError } = require('../util');
 
 let config = util.getConfig();
-const stack = require('../util/contentstack-management-sdk');
 
 module.exports = class ImportExtensions {
   fails = [];
@@ -26,15 +24,15 @@ module.exports = class ImportExtensions {
   extensionsConfig = config.modules.extensions;
   reqConcurrency = config.concurrency || config.fetchConcurrency || 1;
 
-  constructor(credential) {
-    this.config = credential;
+  constructor(importConfig, stackAPIClient) {
+    this.config = merge(config, importConfig);
+    this.stackAPIClient = stackAPIClient;
   }
 
   start() {
     addlogs(this.config, chalk.white('Migrating extensions'), 'success');
 
     const self = this;
-    const client = stack.Client(this.config);
     let extensionsFolderPath = path.resolve(this.config.data, this.extensionsConfig.dirName);
     let extMapperPath = path.resolve(this.config.data, 'mapper', 'extensions');
     let extUidMapperPath = path.resolve(this.config.data, 'mapper/extensions', 'uid-mapping.json');
@@ -59,8 +57,7 @@ module.exports = class ImportExtensions {
         function (extUid) {
           let ext = self.extensions[extUid];
           if (!self.extUidMapper.hasOwnProperty(extUid)) {
-            return client
-              .stack({ api_key: config.target_stack, management_token: config.management_token })
+            return self.stackAPIClient
               .extension()
               .create({ extension: ext })
               .then((response) => {
@@ -103,7 +100,7 @@ module.exports = class ImportExtensions {
         .catch(function (error) {
           // error while importing extensions
           helper.writeFileSync(extFailsPath, self.fails);
-          addlogs(self.config, chalk.red(`Extension import failed ${formatError(error)}`), 'error');
+          addlogs(self.config, chalk.red(`Extension import failed ${util.formatError(error)}`), 'error');
           reject(error);
         });
     });

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

@@ -9,16 +9,14 @@ let path = require('path');
 let chalk = require('chalk');
 let mkdirp = require('mkdirp');
 let Promise = require('bluebird');
-const { isEmpty } = require('lodash');
+const { isEmpty, merge } = require('lodash');
 
 let helper = require('../util/fs');
 let { addlogs } = require('../util/log');
 const { formatError } = require('../util');
 let config = require('../../config/default');
-const stack = require('../util/contentstack-management-sdk');
 let extension_supress = require('../util/extensionsUidReplace');
 let removeReferenceFields = require('../util/removeReferenceFields');
-const { getInstalledExtensions } = require('../util/marketplace-app-helper');
 
 global._globalField_pending = [];
 
@@ -29,8 +27,9 @@ module.exports = class ImportGlobalFields {
   installedExtensions = [];
   reqConcurrency = config.concurrency || config.fetchConcurrency || 1;
 
-  constructor(credential) {
-    this.config = credential;
+  constructor(importConfig, stackAPIClient) {
+    this.config = merge(config, importConfig);
+    this.stackAPIClient = stackAPIClient;
   }
 
   async start() {
@@ -39,13 +38,14 @@ module.exports = class ImportGlobalFields {
     let self = this;
     let globalfieldsConfig = config.modules.globalfields;
     let globalfieldsFolderPath = path.resolve(this.config.data, globalfieldsConfig.dirName);
-    let appMapperFolderPath = path.join(this.config.data, 'mapper', 'marketplace_apps');
     let globalfieldsMapperPath = path.resolve(this.config.data, 'mapper', 'global_fields');
     let globalfieldsUidMapperPath = path.resolve(this.config.data, 'mapper', 'global_fields', 'uid-mapping.json');
     let globalfieldsSuccessPath = path.resolve(this.config.data, 'mapper', 'global_fields', 'success.json');
     let globalFieldsPending = path.resolve(this.config.data, 'mapper', 'global_fields', 'pending_global_fields.js');
     let globalfieldsFailsPath = path.resolve(this.config.data, 'mapper', 'global_fields', 'fails.json');
     self.globalfields = helper.readFileSync(path.resolve(globalfieldsFolderPath, globalfieldsConfig.fileName));
+    const appMapperPath = path.join(this.config.data, 'mapper', 'marketplace_apps', 'uid-mapping.json');
+    this.installedExtensions = ((await helper.readFileSync(appMapperPath)) || { extension_uid: {} }).extension_uid;
 
     if (fs.existsSync(globalfieldsUidMapperPath)) {
       self.snipUidMapper = helper.readFileSync(globalfieldsUidMapperPath);
@@ -56,15 +56,6 @@ module.exports = class ImportGlobalFields {
       mkdirp.sync(globalfieldsMapperPath);
     }
 
-    if (fs.existsSync(path.join(appMapperFolderPath, 'marketplace-apps.json'))) {
-      self.installedExtensions = helper.readFileSync(path.join(appMapperFolderPath, 'marketplace-apps.json')) || {};
-    }
-
-    if (isEmpty(self.installedExtensions)) {
-      self.installedExtensions = await getInstalledExtensions(self.config);
-    }
-
-    const client = stack.Client(self.config);
     return new Promise(function (resolve, reject) {
       if (self.globalfields === undefined || isEmpty(self.globalfields)) {
         addlogs(self.config, chalk.white('No globalfields Found'), 'success');
@@ -87,8 +78,7 @@ module.exports = class ImportGlobalFields {
 
           if (!self.snipUidMapper.hasOwnProperty(snipUid)) {
             let requestOption = { global_field: snip };
-            return client
-              .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
+            return self.stackAPIClient
               .globalField()
               .create(requestOption)
               .then((globalField) => {

package/src/lib/import/labels.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 ImportLabels {
   config;
@@ -27,9 +26,9 @@ module.exports = class ImportLabels {
   labelConfig = config.modules.labels;
   reqConcurrency = config.concurrency || config.fetchConcurrency || 1;
 
-  constructor(credentialConfig) {
-    this.config = merge(config, credentialConfig);
-    this.client = stack.Client(config);
+  constructor(importConfig, stackAPIClient) {
+    this.config = merge(config, importConfig);
+    this.stackAPIClient = stackAPIClient;
   }
 
   start() {
@@ -68,8 +67,7 @@ module.exports = class ImportLabels {
           if (!self.labelUidMapper.hasOwnProperty(labelUid)) {
             let requestOption = { label: label };
 
-            return self.client
-              .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
+            return self.stackAPIClient
               .label()
               .create(requestOption)
               .then(function (response) {
@@ -138,8 +136,7 @@ module.exports = class ImportLabels {
                   label.parent[i] = self.labelUidMapper[parentUids[i]].uid;
                 }
               }
-              return self.client
-                .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
+              return self.stackAPIClient
                 .label(newLabelUid.uid)
                 .fetch()
                 .then(function (response) {

package/src/lib/import/locales.js

@@ -11,25 +11,25 @@ let chalk = require('chalk');
 let mkdirp = require('mkdirp');
 let Promise = require('bluebird');
 let { isEmpty, merge, cloneDeep } = require('lodash');
+const { cliux } = require('@contentstack/cli-utilities');
 
 let helper = require('../util/fs');
 let { addlogs } = require('../util/log');
 const { formatError } = require('../util');
 let config = require('../../config/default');
-let stack = require('../util/contentstack-management-sdk');
 
 module.exports = class ImportLanguages {
-  client;
   fails = [];
   success = [];
   langUidMapper = {};
   masterLanguage = config.master_locale;
   langConfig = config.modules.locales;
+  sourceMasterLangConfig = config.modules.masterLocale;
   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() {
@@ -39,9 +39,10 @@ module.exports = class ImportLanguages {
     let langMapperPath = path.resolve(this.config.data, 'mapper', 'languages');
     let langFolderPath = path.resolve(this.config.data, this.langConfig.dirName);
     let langFailsPath = path.resolve(this.config.data, 'mapper', 'languages', 'fails.json');
-    let langSuccessPath = path.resolve(this.config.data, 'mapper', 'languages', 'success.json');
     let langUidMapperPath = path.resolve(this.config.data, 'mapper', 'languages', 'uid-mapper.json');
+    self.langSuccessPath = path.resolve(this.config.data, 'mapper', 'languages', 'success.json');
     self.languages = helper.readFileSync(path.resolve(langFolderPath, this.langConfig.fileName));
+    self.sourceMasterLanguages = helper.readFileSync(path.resolve(langFolderPath, this.sourceMasterLangConfig.fileName));
 
     mkdirp.sync(langMapperPath);
 
@@ -50,11 +51,22 @@ module.exports = class ImportLanguages {
       self.langUidMapper = self.langUidMapper || {};
     }
 
-    return new Promise(function (resolve, reject) {
+    return new Promise(async function (resolve, reject) {
       if (self.languages === undefined || isEmpty(self.languages)) {
         addlogs(self.config, chalk.white('No Languages Found'), 'success');
         return resolve({ empty: true });
       }
+
+      let sourceMasterLangDetails = self.sourceMasterLanguages && Object.values(self.sourceMasterLanguages);
+      if (sourceMasterLangDetails &&
+        sourceMasterLangDetails[0] &&
+        sourceMasterLangDetails[0]["code"] &&
+        self.masterLanguage["code"] === sourceMasterLangDetails[0]["code"]) {
+        await self.checkAndUpdateMasterLocaleName(sourceMasterLangDetails).catch((error) => {
+          addlogs(self.config, formatError(error), 'warn');
+        })
+      }
+
       let langUids = Object.keys(self.languages);
       return Promise.map(
         langUids,
@@ -68,8 +80,7 @@ module.exports = class ImportLanguages {
               },
             };
 
-            return self.client
-              .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
+            return self.stackAPIClient
               .locale()
               .create(requestOption)
               .then((locale) => {
@@ -101,7 +112,7 @@ module.exports = class ImportLanguages {
           self
             .updateLocales(langUids)
             .then(() => {
-              helper.writeFileSync(langSuccessPath, self.success);
+              helper.writeFileSync(self.langSuccessPath, self.success);
               addlogs(self.config, chalk.green('Languages have been imported successfully!'), 'success');
               resolve();
             })
@@ -131,9 +142,7 @@ module.exports = class ImportLanguages {
           requireKeys.forEach((e) => {
             lang[e] = _lang[e];
           });
-          let langobj = self.client
-            .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
-            .locale(lang.code);
+          let langobj = self.stackAPIClient.locale(lang.code);
           Object.assign(langobj, cloneDeep(lang));
           langobj.update().then(() => {
             // empty function
@@ -147,4 +156,58 @@ module.exports = class ImportLanguages {
         });
     });
   }
+
+  checkAndUpdateMasterLocaleName(sourceMasterLangDetails) {
+    let self = this;
+    return new Promise(async function (resolve, reject) {
+      let masterLangDetails = await self.stackAPIClient.locale(self.masterLanguage["code"]).fetch()
+        .catch((error) => {
+          addlogs(self.config, formatError(error), 'warn');
+        })
+      if (masterLangDetails &&
+        masterLangDetails["name"] &&
+        sourceMasterLangDetails[0]["name"] &&
+        masterLangDetails["name"].toString().toUpperCase() !== sourceMasterLangDetails[0]["name"].toString().toUpperCase()
+      ) {
+        cliux.print(
+          'WARNING!!! The master language name for the source and destination is different.',
+          { color: 'yellow' },
+        );
+        cliux.print(
+          `Old Master language name: ${masterLangDetails["name"]}`,
+          { color: 'red' },
+        );
+        cliux.print(
+          `New Master language name: ${sourceMasterLangDetails[0]["name"]}`,
+          { color: 'green' },
+        );
+        let confirm = await cliux.inquire({
+          type: 'confirm',
+          message: 'Are you sure you want to update name of master language?',
+          name: 'confirmation',
+        })
+
+        if (confirm) {
+          let languid = sourceMasterLangDetails[0] && sourceMasterLangDetails[0]["uid"];
+          let lang = self.sourceMasterLanguages[languid];
+          if (!lang) return reject('Locale not found.!');
+          const langObj = self.stackAPIClient.locale(lang.code);
+          Object.assign(langObj, { name: lang.name });
+          langObj.update()
+            .then(() => {
+              helper.writeFileSync(self.langSuccessPath, self.success);
+              addlogs(self.config, chalk.green('Master Languages name have been updated successfully!'), 'success');
+              resolve();
+            })
+            .catch(function (error) {
+              reject(error);
+            });
+        } else {
+          resolve();
+        }
+      } else {
+        resolve();
+      }
+    });
+  }
 };