@contentstack/cli-cm-import 1.1.0 → 1.2.0

package/src/lib/import/labels.js

@@ -4,54 +4,55 @@
  * MIT Licensed
  */
 
-const mkdirp = require('mkdirp');
-const fs = require('fs');
 const path = require('path');
-const Promise = require('bluebird');
 const chalk = require('chalk');
-const {isEmpty} = require('lodash');
+const mkdirp = require('mkdirp');
+const Promise = require('bluebird');
+const { existsSync } = require('fs');
+const { isEmpty, merge } = require('lodash');
 
 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');
+const config = require('../../config/default');
+const stack = require('../util/contentstack-management-sdk');
 
-let reqConcurrency = config.concurrency;
-let labelConfig = config.modules.labels;
-let labelsFolderPath;
-let labelMapperPath;
-let labelUidMapperPath;
-let labelSuccessPath;
-let labelFailsPath;
-let client;
+module.exports = class ImportLabels {
+  config;
+  fails = [];
+  success = [];
+  labelUids = [];
+  labelsFolderPath;
+  labelUidMapper = {};
+  labelConfig = config.modules.labels;
+  reqConcurrency = config.concurrency || config.fetchConcurrency || 1;
 
-function importLabels() {
-  this.fails = [];
-  this.success = [];
-  this.labelUidMapper = {};
-  this.labelUids = [];
-  if (fs.existsSync(labelUidMapperPath)) {
-    this.labelUidMapper = helper.readFile(labelUidMapperPath);
-    this.labelUidMapper = this.labelUidMapper || {};
+  constructor(credentialConfig) {
+    this.config = merge(config, credentialConfig);
+    this.client = stack.Client(config);
   }
-}
 
-importLabels.prototype = {
-  start: function (credentialConfig) {
-    let self = this;
-    config = credentialConfig;
-    client = stack.Client(config);
-    addlogs(config, chalk.white('Migrating labels'), 'success');
-    labelsFolderPath = path.resolve(config.data, labelConfig.dirName);
-    self.labels = helper.readFile(path.resolve(labelsFolderPath, labelConfig.fileName));
-    labelMapperPath = path.resolve(config.data, 'mapper', 'labels');
-    labelUidMapperPath = path.resolve(config.data, 'mapper', 'labels', 'uid-mapping.json');
-    labelSuccessPath = path.resolve(config.data, 'labels', 'success.json');
-    labelFailsPath = path.resolve(config.data, 'labels', 'fails.json');
+  start() {
+    const self = this;
+    addlogs(this.config, chalk.white('Migrating labels'), 'success');
+    let labelMapperPath = path.resolve(this.config.data, 'mapper', 'labels');
+    let labelFailsPath = path.resolve(this.config.data, 'labels', 'fails.json');
+    let labelSuccessPath = path.resolve(this.config.data, 'labels', 'success.json');
+    this.labelsFolderPath = path.resolve(this.config.data, this.labelConfig.dirName);
+    let labelUidMapperPath = path.resolve(this.config.data, 'mapper', 'labels', 'uid-mapping.json');
+
+    if (existsSync(labelUidMapperPath)) {
+      this.labelUidMapper = helper.readFileSync(labelUidMapperPath);
+      this.labelUidMapper = this.labelUidMapper || {};
+    }
+
+    self.labels = helper.readFileSync(path.resolve(this.labelsFolderPath, this.labelConfig.fileName));
+
     mkdirp.sync(labelMapperPath);
+
     return new Promise(function (resolve, reject) {
       if (self.labels == undefined || isEmpty(self.labels)) {
-        addlogs(config, chalk.white('No Label Found'), 'success');
+        addlogs(self.config, chalk.white('No Label Found'), 'success');
         return resolve({ empty: true });
       }
       self.labelUids = Object.keys(self.labels);
@@ -59,72 +60,71 @@ importLabels.prototype = {
         self.labelUids,
         function (labelUid) {
           let label = self.labels[labelUid];
+
           if (label.parent.length != 0) {
             delete label['parent'];
           }
 
           if (!self.labelUidMapper.hasOwnProperty(labelUid)) {
-            let requestOption = {
-              label: label,
-            };
+            let requestOption = { label: label };
 
-            return client
-              .stack({ api_key: config.target_stack, management_token: config.management_token })
+            return self.client
+              .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
               .label()
               .create(requestOption)
               .then(function (response) {
                 self.labelUidMapper[labelUid] = response;
-                helper.writeFile(labelUidMapperPath, self.labelUidMapper);
               })
               .catch(function (error) {
                 self.fails.push(label);
                 if (error.errors.name) {
-                  addlogs(config, chalk.red("Label: '" + label.name + "'  already exist"), 'error');
+                  addlogs(self.config, chalk.red("Label: '" + label.name + "'  already exist"), 'error');
                 } else {
-                  addlogs(config, chalk.red("Label: '" + label.name + "' failed to be imported\n"), 'error');
+                  addlogs(self.config, chalk.red("Label: '" + label.name + "' failed to be imported\n"), 'error');
                 }
               });
           } else {
             // the label has already been created
             addlogs(
-              config,
+              self.config,
               chalk.white("The label: '" + label.name + "' already exists. Skipping it to avoid duplicates!"),
               'success',
             );
           }
           // import 1 labels at a time
         },
-        {
-          concurrency: reqConcurrency,
-        },
+        { concurrency: self.reqConcurrency },
       )
         .then(function () {
+          helper.writeFileSync(labelUidMapperPath, self.labelUidMapper);
           // eslint-disable-next-line no-undef
           return self
             .updateLabels()
             .then(function () {
-              helper.writeFile(labelSuccessPath, self.success);
-              addlogs(config, chalk.green('Labels have been imported successfully!'), 'success');
+              helper.writeFileSync(labelSuccessPath, self.success);
+              addlogs(self.config, chalk.green('Labels have been imported successfully!'), 'success');
               return resolve();
             })
             .catch(function (error) {
+              addlogs(self.config, chalk.red(`Failed to import label ${formatError(error)}`), 'error');
               // eslint-disable-next-line no-console
               return reject(error);
             });
         })
         .catch(function (error) {
           // error while importing labels
-          helper.writeFile(labelFailsPath, self.fails);
-          addlogs(config, chalk.red('Label import failed'), 'error');
+          helper.writeFileSync(labelUidMapperPath, self.labelUidMapper);
+          helper.writeFileSync(labelFailsPath, self.fails);
+          addlogs(self.config, chalk.red(`Failed to import label ${formatError(error)}`), 'error');
           return reject(error);
         });
     });
-  },
+  }
 
-  updateLabels: function () {
-    let self = this;
+  updateLabels() {
+    const self = this;
     return new Promise(function (resolve, reject) {
-      let labelsObj = helper.readFile(path.resolve(labelsFolderPath, labelConfig.fileName));
+      let labelsObj = helper.readFileSync(path.resolve(self.labelsFolderPath, self.labelConfig.fileName));
       return Promise.map(
         self.labelUids,
         function (labelUid) {
@@ -138,8 +138,8 @@ importLabels.prototype = {
                   label.parent[i] = self.labelUidMapper[parentUids[i]].uid;
                 }
               }
-              return client
-                .stack({ api_key: config.target_stack, management_token: config.management_token })
+              return self.client
+                .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
                 .label(newLabelUid.uid)
                 .fetch()
                 .then(function (response) {
@@ -151,17 +151,19 @@ importLabels.prototype = {
                       self.success.push(result);
                     })
                     .catch((error) => {
+                      addlogs(self.config, formatError(error), 'error');
                       return reject(error);
                     });
                 })
                 .catch(function (error) {
+                  addlogs(self.config, formatError(error), 'error');
                   return reject(error);
                 });
             }
           }
         },
         {
-          concurrency: reqConcurrency,
+          concurrency: self.reqConcurrency,
         },
       )
         .then(function () {
@@ -172,6 +174,5 @@ importLabels.prototype = {
           return reject(error);
         });
     });
-  },
+  }
 };
-module.exports = new importLabels();

package/src/lib/import/locales.js

@@ -5,56 +5,54 @@
  * MIT Licensed
  */
 
-let mkdirp = require('mkdirp');
 let fs = require('fs');
 let path = require('path');
-let Promise = require('bluebird');
 let chalk = require('chalk');
+let mkdirp = require('mkdirp');
+let Promise = require('bluebird');
+let { isEmpty, merge, cloneDeep } = require('lodash');
 
 let helper = require('../util/fs');
 let { addlogs } = require('../util/log');
-let stack = require('../util/contentstack-management-sdk');
+const { formatError } = require('../util');
 let config = require('../../config/default');
-let {isEmpty, cloneDeep} = require('lodash');
-let reqConcurrency = config.concurrency;
-let langConfig = config.modules.locales;
-let langFolderPath;
-let langMapperPath;
-let langUidMapperPath;
-let langSuccessPath;
-let langFailsPath;
-let client;
+let stack = require('../util/contentstack-management-sdk');
 
-let masterLanguage = config.master_locale;
+module.exports = class ImportLanguages {
+  client;
+  fails = [];
+  success = [];
+  langUidMapper = {};
+  masterLanguage = config.master_locale;
+  langConfig = config.modules.locales;
+  reqConcurrency = config.concurrency || config.fetchConcurrency || 1;
 
-function importLanguages() {
-  this.fails = [];
-  this.success = [];
-  this.langUidMapper = {};
-}
+  constructor(credentialConfig) {
+    this.config = merge(config, credentialConfig);
+    this.client = stack.Client(this.config);
+  }
+
+  start() {
+    addlogs(this.config, 'Migrating languages', 'success');
+
+    const self = this;
+    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.languages = helper.readFileSync(path.resolve(langFolderPath, this.langConfig.fileName));
 
-importLanguages.prototype = {
-  start: function (credentialConfig) {
-    addlogs(config, 'Migrating languages', 'success');
-    let self = this;
-    config = credentialConfig;
-    client = stack.Client(config);
-    langFolderPath = path.resolve(config.data, langConfig.dirName);
-    langMapperPath = path.resolve(config.data, 'mapper', 'languages');
-    langUidMapperPath = path.resolve(config.data, 'mapper', 'languages', 'uid-mapper.json');
-    langSuccessPath = path.resolve(config.data, 'mapper', 'languages', 'success.json');
-    langFailsPath = path.resolve(config.data, 'mapper', 'languages', 'fails.json');
     mkdirp.sync(langMapperPath);
-    self.languages = helper.readFile(path.resolve(langFolderPath, langConfig.fileName));
-    
+
     if (fs.existsSync(langUidMapperPath)) {
-      self.langUidMapper = helper.readFile(langUidMapperPath);
+      self.langUidMapper = helper.readFileSync(langUidMapperPath);
       self.langUidMapper = self.langUidMapper || {};
     }
 
     return new Promise(function (resolve, reject) {
       if (self.languages === undefined || isEmpty(self.languages)) {
-        addlogs(config, chalk.white('No Languages Found'), 'success');
+        addlogs(self.config, chalk.white('No Languages Found'), 'success');
         return resolve({ empty: true });
       }
       let langUids = Object.keys(self.languages);
@@ -62,7 +60,7 @@ importLanguages.prototype = {
         langUids,
         function (langUid) {
           let lang = self.languages[langUid];
-          if (!self.langUidMapper.hasOwnProperty(langUid) && lang.code !== masterLanguage) {
+          if (!self.langUidMapper.hasOwnProperty(langUid) && lang.code !== self.masterLanguage) {
             let requestOption = {
               locale: {
                 code: lang.code,
@@ -70,69 +68,71 @@ importLanguages.prototype = {
               },
             };
 
-            return client
-              .stack({ api_key: config.target_stack, management_token: config.management_token })
+            return self.client
+              .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
               .locale()
               .create(requestOption)
               .then((locale) => {
                 self.success.push(locale.items);
                 self.langUidMapper[langUid] = locale.uid;
-                helper.writeFile(langUidMapperPath, self.langUidMapper);
+                helper.writeFileSync(langUidMapperPath, self.langUidMapper);
               })
               .catch(function (err) {
                 let error = JSON.parse(err.message);
                 if (error.hasOwnProperty('errorCode') && error.errorCode === 247) {
-                  addlogs(config, error.errors.code[0], 'success');
-                  return;
+                  addlogs(self.config, error.errors.code[0], 'success');
+                  return err;
                 }
                 self.fails.push(lang);
-                addlogs(config, chalk.red("Language: '" + lang.code + "' failed to be import\n"), 'error');
+                addlogs(self.config, chalk.red("Language: '" + lang.code + "' failed to be import\n"), 'error');
+                addlogs(self.config, formatError(err), 'error');
               });
           } else {
             // the language has already been created
-            addlogs(config, chalk.yellow("The language: '" + lang.code + "' already exists."), 'error');
+            addlogs(self.config, chalk.yellow("The language: '" + lang.code + "' already exists."), 'error');
           }
 
           // import 2 languages at a time
         },
-        {
-          concurrency: reqConcurrency,
-        },
+        { concurrency: self.reqConcurrency },
       )
         .then(function () {
           // languages have imported successfully
           self
-            .update_locales(langUids)
+            .updateLocales(langUids)
             .then(() => {
-              helper.writeFile(langSuccessPath, self.success);
-              addlogs(config, chalk.green('Languages have been imported successfully!'), 'success');
-              return resolve();
+              helper.writeFileSync(langSuccessPath, self.success);
+              addlogs(self.config, chalk.green('Languages have been imported successfully!'), 'success');
+              resolve();
             })
             .catch(function (error) {
-              return reject(error);
+              addlogs(self.config, formatError(error), 'error');
+              reject(error);
             });
         })
         .catch(function (error) {
           // error while importing languages
-          helper.writeFile(langFailsPath, self.fails);
-          addlogs(config, chalk.red('Language import failed'), 'error');
-          return reject(error);
+          helper.writeFileSync(langFailsPath, self.fails);
+          addlogs(self.config, chalk.red('Language import failed'), 'error');
+          addlogs(self.config, formatError(error), 'error');
+          reject('failed to import Languages');
         });
     });
-  },
-  update_locales: function (langUids) {
+  }
+
+  updateLocales(langUids) {
     let self = this;
     return new Promise(function (resolve, reject) {
       Promise.all(
         langUids.map(async (langUid) => {
           let lang = {};
-          let requireKeys = config.modules.locales.requiredKeys;
+          let requireKeys = self.config.modules.locales.requiredKeys;
           let _lang = self.languages[langUid];
           requireKeys.forEach((e) => {
             lang[e] = _lang[e];
           });
-          let langobj = client
-            .stack({ api_key: config.target_stack, management_token: config.management_token })
+          let langobj = self.client
+            .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
             .locale(lang.code);
           Object.assign(langobj, cloneDeep(lang));
           langobj.update().then(() => {
@@ -140,14 +140,11 @@ importLanguages.prototype = {
           });
         }),
       )
-        .then(() => {
-          return resolve();
-        })
+        .then(resolve)
         .catch((error) => {
-          return reject(error);
+          addlogs(self.config, formatError(error), 'error');
+          reject(error);
         });
     });
-  },
+  }
 };
-
-module.exports = new importLanguages();