@contentstack/cli-cm-import 1.1.0 → 1.2.1

package/src/lib/import/environments.js

@@ -4,53 +4,51 @@
  * MIT Licensed
  */
 
-const mkdirp = require('mkdirp');
 const fs = require('fs');
 const path = require('path');
+const chalk = require('chalk');
+const mkdirp = require('mkdirp');
 const Promise = require('bluebird');
 const { isEmpty } = require('lodash');
 
 const helper = require('../util/fs');
 let { addlogs } = require('../util/log');
-const chalk = require('chalk');
-let stack = require('../util/contentstack-management-sdk');
+const { formatError } = require('../util');
+const config = require('../../config/default');
+const stack = require('../util/contentstack-management-sdk');
+
+module.exports = class ImportEnvironments {
+  fails = [];
+  success = [];
+  envUidMapper = {};
+  fetchConcurrency = config.modules.environments.concurrency || config.fetchConcurrency || 2;
 
-let config = require('../../config/default');
-let environmentConfig = config.modules.environments;
-let environmentsFolderPath;
-let envMapperPath;
-let envUidMapperPath;
-let envSuccessPath;
-let envFailsPath;
-let client;
+  constructor(credentialConfig) {
+    this.config = credentialConfig;
+  }
 
-function importEnvironments() {
-  this.fails = [];
-  this.success = [];
-  this.envUidMapper = {};
-}
+  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');
+    let envUidMapperPath = path.resolve(this.config.data, 'mapper', 'environments', 'uid-mapping.json');
+    let envSuccessPath = path.resolve(this.config.data, 'environments', 'success.json');
+    let envFailsPath = path.resolve(this.config.data, 'environments', 'fails.json');
+    self.environments = helper.readFileSync(path.resolve(environmentsFolderPath, environmentConfig.fileName));
 
-importEnvironments.prototype = {
-  start: function (credentialConfig) {
-    let self = this;
-    config = credentialConfig;
-    addlogs(config, 'Migrating environment', 'success');
-    environmentsFolderPath = path.resolve(config.data, environmentConfig.dirName);
-    envMapperPath = path.resolve(config.data, 'mapper', 'environments');
-    envUidMapperPath = path.resolve(config.data, 'mapper', 'environments', 'uid-mapping.json');
-    envSuccessPath = path.resolve(config.data, 'environments', 'success.json');
-    envFailsPath = path.resolve(config.data, 'environments', 'fails.json');
-    self.environments = helper.readFile(path.resolve(environmentsFolderPath, environmentConfig.fileName));
-    client = stack.Client(config);
     if (fs.existsSync(envUidMapperPath)) {
-      self.envUidMapper = helper.readFile(envUidMapperPath);
+      self.envUidMapper = helper.readFileSync(envUidMapperPath);
       self.envUidMapper = self.envUidMapper || {};
     }
 
     mkdirp.sync(envMapperPath);
     return new Promise(function (resolve, reject) {
       if (self.environments === undefined || isEmpty(self.environments)) {
-        addlogs(config, chalk.yellow('No Environment Found'), 'success');
+        addlogs(self.config, chalk.yellow('No Environment Found'), 'success');
         return resolve({ empty: true });
       }
 
@@ -60,9 +58,7 @@ importEnvironments.prototype = {
         function (envUid) {
           let env = self.environments[envUid];
           if (!self.envUidMapper.hasOwnProperty(envUid)) {
-            let requestOption = {
-              environment: env,
-            };
+            let requestOption = { environment: env };
 
             return client
               .stack({ api_key: config.target_stack, management_token: config.management_token })
@@ -71,12 +67,13 @@ importEnvironments.prototype = {
               .then((environment) => {
                 self.success.push(environment.items);
                 self.envUidMapper[envUid] = environment.uid;
-                helper.writeFile(envUidMapperPath, self.envUidMapper);
+                helper.writeFileSync(envUidMapperPath, self.envUidMapper);
               })
               .catch(function (err) {
                 let error = JSON.parse(err.message);
+
                 if (error.errors.name) {
-                  addlogs(config, chalk.white("Environment: '" + env.name + "' already exists"), 'error');
+                  addlogs(self.config, chalk.white("Environment: '" + env.name + "' already exists"), 'error');
                 } else {
                   addlogs(
                     config,
@@ -95,26 +92,19 @@ importEnvironments.prototype = {
               'success',
             );
           }
-          // import 2 environments at a time
-        },
-        {
-          concurrency: 2,
         },
+        { concurrency: self.fetchConcurrency },
       )
         .then(function () {
-          // environments have imported successfully
-          helper.writeFile(envSuccessPath, self.success);
-          addlogs(config, chalk.green('Environments have been imported successfully!'), 'success');
-          return resolve();
+          helper.writeFileSync(envSuccessPath, self.success);
+          addlogs(self.config, chalk.green('Environments have been imported successfully!'), 'success');
+          resolve();
         })
         .catch(function (error) {
-          // error while importing environments
-          helper.writeFile(envFailsPath, self.fails);
-          addlogs(config, chalk.red('Environment import failed'), 'error');
-          return reject(error);
+          helper.writeFileSync(envFailsPath, self.fails);
+          addlogs(self.config, chalk.red(`Failed to import environment ${formatError(error)}`), 'error');
+          reject(error);
         });
     });
-  },
+  }
 };
-
-module.exports = new importEnvironments();

package/src/lib/import/extensions.js

@@ -9,44 +9,40 @@ const fs = require('fs');
 const path = require('path');
 const Promise = require('bluebird');
 const chalk = require('chalk');
-const {isEmpty} = require('lodash');
+const { isEmpty } = require('lodash');
 
+const util = require('../util');
 const helper = require('../util/fs');
 const { addlogs } = require('../util/log');
-const util = require('../util');
+const { formatError } = require('../util');
 
 let config = util.getConfig();
-const reqConcurrency = config.concurrency;
-const extensionsConfig = config.modules.extensions;
 const stack = require('../util/contentstack-management-sdk');
-let extensionsFolderPath;
-let extMapperPath;
-let extUidMapperPath;
-let extSuccessPath;
-let extFailsPath;
-let client;
 
-function importExtensions() {
-  this.fails = [];
-  this.success = [];
-  this.extUidMapper = {};
-}
+module.exports = class ImportExtensions {
+  fails = [];
+  success = [];
+  extUidMapper = {};
+  extensionsConfig = config.modules.extensions;
+  reqConcurrency = config.concurrency || config.fetchConcurrency || 1;
 
-importExtensions.prototype = {
-  start: function (credential) {
-    addlogs(config, chalk.white('Migrating extensions'), 'success');
-    let self = this;
-    config = credential;
-    client = stack.Client(config);
+  constructor(credential) {
+    this.config = credential;
+  }
 
-    extensionsFolderPath = path.resolve(config.data, extensionsConfig.dirName);
-    extMapperPath = path.resolve(config.data, 'mapper', 'extensions');
-    extUidMapperPath = path.resolve(config.data, 'mapper/extensions', 'uid-mapping.json');
-    extSuccessPath = path.resolve(config.data, 'extensions', 'success.json');
-    extFailsPath = path.resolve(config.data, 'extensions', 'fails.json');
-    self.extensions = helper.readFile(path.resolve(extensionsFolderPath, extensionsConfig.fileName));
+  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');
+    let extSuccessPath = path.resolve(this.config.data, 'extensions', 'success.json');
+    let extFailsPath = path.resolve(this.config.data, 'extensions', 'fails.json');
+    this.extensions = helper.readFileSync(path.resolve(extensionsFolderPath, this.extensionsConfig.fileName));
     if (fs.existsSync(extUidMapperPath)) {
-      self.extUidMapper = helper.readFile(extUidMapperPath);
+      self.extUidMapper = helper.readFileSync(extUidMapperPath);
       self.extUidMapper = self.extUidMapper || {};
     }
 
@@ -54,7 +50,7 @@ importExtensions.prototype = {
 
     return new Promise(function (resolve, reject) {
       if (self.extensions === undefined || isEmpty(self.extensions)) {
-        addlogs(config, chalk.white('No Extensions Found'), 'success');
+        addlogs(self.config, chalk.white('No Extensions Found'), 'success');
         return resolve({ empty: true });
       }
       let extUids = Object.keys(self.extensions);
@@ -70,13 +66,13 @@ importExtensions.prototype = {
               .then((response) => {
                 self.success.push(response);
                 self.extUidMapper[extUid] = response.uid;
-                helper.writeFile(extUidMapperPath, self.extUidMapper);
+                helper.writeFileSync(extUidMapperPath, self.extUidMapper);
               })
               .catch(function (err) {
                 let error = JSON.parse(err.message);
                 self.fails.push(ext);
                 if (error.errors.title) {
-                  addlogs(config, chalk.white("Extension: '" + ext.title + "' already exists"), 'success');
+                  addlogs(self.config, chalk.white("Extension: '" + ext.title + "' already exists"), 'success');
                 } else {
                   addlogs(
                     config,
@@ -95,23 +91,21 @@ importExtensions.prototype = {
           // import 2 extensions at a time
         },
         {
-          concurrency: reqConcurrency,
+          concurrency: self.reqConcurrency,
         },
       )
         .then(function () {
           // extensions have imported successfully
-          helper.writeFile(extSuccessPath, self.success);
-          addlogs(config, chalk.green('Extensions have been imported successfully!'), 'success');
-          return resolve();
+          helper.writeFileSync(extSuccessPath, self.success);
+          addlogs(self.config, chalk.green('Extensions have been imported successfully!'), 'success');
+          resolve();
         })
         .catch(function (error) {
           // error while importing extensions
-          helper.writeFile(extFailsPath, self.fails);
-          addlogs(config, chalk.red('Extension import failed'), 'error');
-          return reject(error);
+          helper.writeFileSync(extFailsPath, self.fails);
+          addlogs(self.config, chalk.red(`Extension import failed ${formatError(error)}`), 'error');
+          reject(error);
         });
     });
-  },
+  }
 };
-
-module.exports = new importExtensions();

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

@@ -4,62 +4,52 @@
  * 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');
 const { isEmpty } = 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 stack = require('../util/contentstack-management-sdk');
 const { getInstalledExtensions } = require('../util/marketplace-app-helper');
 
-let config = require('../../config/default');
-let reqConcurrency = config.concurrency;
-let globalfieldsConfig = config.modules.globalfields;
-let globalfieldsFolderPath;
-let globalfieldsMapperPath;
-let globalfieldsUidMapperPath;
-let globalfieldsSuccessPath;
-let globalfieldsFailsPath;
-let client;
-let globalFieldsPending;
-
 global._globalField_pending = [];
 
-function importGlobalFields() {
-  this.fails = [];
-  this.success = [];
-  this.snipUidMapper = {};
-  this.requestOptions = {
-    uri: config.host + config.apis.globalfields,
-    headers: config.headers,
-    method: 'POST',
-  };
-  this.installedExtensions = [];
-}
+module.exports = class ImportGlobalFields {
+  fails = [];
+  success = [];
+  snipUidMapper = {};
+  installedExtensions = [];
+  reqConcurrency = config.concurrency || config.fetchConcurrency || 1;
+
+  constructor(credential) {
+    this.config = credential;
+  }
+
+  async start() {
+    addlogs(this.config, chalk.white('Migrating global-fields'), 'success');
 
-importGlobalFields.prototype = {
-  start: async function (credential) {
-    addlogs(config, chalk.white('Migrating global-fields'), 'success');
     let self = this;
-    config = credential;
-    globalfieldsFolderPath = path.resolve(config.data, globalfieldsConfig.dirName);
-    globalfieldsMapperPath = path.resolve(config.data, 'mapper', 'global_fields');
-    globalfieldsUidMapperPath = path.resolve(config.data, 'mapper', 'global_fields', 'uid-mapping.json');
-    globalfieldsSuccessPath = path.resolve(config.data, 'mapper', 'global_fields', 'success.json');
-    globalFieldsPending = path.resolve(config.data, 'mapper', 'global_fields', 'pending_global_fields.js');
-    globalfieldsFailsPath = path.resolve(config.data, 'mapper', 'global_fields', 'fails.json');
-    self.globalfields = helper.readFile(path.resolve(globalfieldsFolderPath, globalfieldsConfig.fileName));
-    const appMapperFolderPath = path.join(config.data, 'mapper', 'marketplace_apps');
+    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));
 
     if (fs.existsSync(globalfieldsUidMapperPath)) {
-      self.snipUidMapper = helper.readFile(globalfieldsUidMapperPath);
-      self.snipUidMapper = this.snipUidMapper || {};
+      self.snipUidMapper = helper.readFileSync(globalfieldsUidMapperPath);
+      self.snipUidMapper = self.snipUidMapper || {};
     }
 
     if (!fs.existsSync(globalfieldsMapperPath)) {
@@ -67,29 +57,27 @@ importGlobalFields.prototype = {
     }
 
     if (fs.existsSync(path.join(appMapperFolderPath, 'marketplace-apps.json'))) {
-      self.installedExtensions = helper.readFile(path.join(appMapperFolderPath, 'marketplace-apps.json')) || {};
+      self.installedExtensions = helper.readFileSync(path.join(appMapperFolderPath, 'marketplace-apps.json')) || {};
     }
 
     if (isEmpty(self.installedExtensions)) {
-      self.installedExtensions = await getInstalledExtensions(config);
+      self.installedExtensions = await getInstalledExtensions(self.config);
     }
 
-    client = stack.Client(config);
+    const client = stack.Client(self.config);
     return new Promise(function (resolve, reject) {
       if (self.globalfields === undefined || isEmpty(self.globalfields)) {
-        addlogs(config, chalk.white('No globalfields Found'), 'success');
-        helper.writeFile(globalFieldsPending, _globalField_pending);
+        addlogs(self.config, chalk.white('No globalfields Found'), 'success');
+        helper.writeFileSync(globalFieldsPending, _globalField_pending);
         return resolve({ empty: true });
       }
       let snipUids = Object.keys(self.globalfields);
       return Promise.map(
         snipUids,
         function (snipUid) {
-          let flag = {
-            supressed: false,
-          };
+          let flag = { supressed: false };
           let snip = self.globalfields[snipUid];
-          extension_supress(snip.schema, config.preserveStackVersion, self.installedExtensions);
+          extension_supress(snip.schema, self.config.preserveStackVersion, self.installedExtensions);
           removeReferenceFields(snip.schema, flag);
 
           if (flag.supressed) {
@@ -98,60 +86,60 @@ importGlobalFields.prototype = {
           }
 
           if (!self.snipUidMapper.hasOwnProperty(snipUid)) {
-            let requestOption = {
-              global_field: snip,
-            };
+            let requestOption = { global_field: snip };
             return client
-              .stack({ api_key: config.target_stack, management_token: config.management_token })
+              .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
               .globalField()
               .create(requestOption)
               .then((globalField) => {
                 self.success.push(globalField.items);
                 let global_field_uid = globalField.uid;
                 self.snipUidMapper[snipUid] = globalField.items;
-                helper.writeFile(globalfieldsUidMapperPath, self.snipUidMapper);
-                addlogs(config, chalk.green('Global field ' + global_field_uid + ' created successfully'), 'success');
+                helper.writeFileSync(globalfieldsUidMapperPath, self.snipUidMapper);
+                addlogs(
+                  self.config,
+                  chalk.green('Global field ' + global_field_uid + ' created successfully'),
+                  'success',
+                );
               })
               .catch(function (err) {
                 let error = JSON.parse(err.message);
                 if (error.errors.title) {
                   // eslint-disable-next-line no-undef
-                  addlogs(config, chalk.white(snip.uid + ' globalfield already exists'), 'error');
+                  addlogs(self.config, chalk.white(snip.uid + ' globalfield already exists'), 'error');
                 } else {
-                  addlogs(config, chalk.red('Globalfield failed to import ' + JSON.stringify(error.errors)), 'error');
+                  addlogs(self.config, chalk.red(`Globalfield failed to import ${formatError(error)}`), 'error');
                 }
+
                 self.fails.push(snip);
               });
           } else {
             // globalfields has already been created
             addlogs(
-              config,
+              self.config,
               chalk.white('The globalfields already exists. Skipping it to avoid duplicates!'),
               'success',
             );
           }
           // import 2 globalfields at a time
         },
-        {
-          concurrency: reqConcurrency,
-        },
+        { concurrency: self.reqConcurrency },
       )
         .then(function () {
           // globalfields have imported successfully
-          helper.writeFile(globalfieldsSuccessPath, self.success);
-          helper.writeFile(globalFieldsPending, _globalField_pending);
-          addlogs(config, chalk.green('globalfields have been imported successfully!'), 'success');
+          helper.writeFileSync(globalfieldsSuccessPath, self.success);
+          helper.writeFileSync(globalFieldsPending, _globalField_pending);
+          addlogs(self.config, chalk.green('globalfields have been imported successfully!'), 'success');
           return resolve();
         })
         .catch(function (err) {
           let error = JSON.parse(err);
           // error while importing globalfields
-          helper.writeFile(globalfieldsFailsPath, self.fails);
-          addlogs(config, chalk.red('globalfields import failed'), 'error');
+          addlogs(self.config, err, 'error');
+          helper.writeFileSync(globalfieldsFailsPath, self.fails);
+          addlogs(self.config, chalk.red('globalfields import failed'), 'error');
           return reject(error);
         });
     });
-  },
+  }
 };
-
-module.exports = new importGlobalFields();