@contentstack/cli-cm-import 0.1.1-beta.7 → 1.0.0

package/src/lib/import/environments.js

@@ -4,102 +4,117 @@
  * MIT Licensed
  */
 
-const mkdirp = require('mkdirp')
-const fs = require('fs')
-const path = require('path')
-const Promise = require('bluebird')
+const mkdirp = require('mkdirp');
+const fs = require('fs');
+const path = require('path');
+const Promise = require('bluebird');
+const { isEmpty } = require('lodash');
 
-const request = require('../util/request')
-const helper = require('../util/fs')
-let {addlogs} = require('../util/log')
-let util = require('../util/')
-const chalk = require('chalk')
-let stack = require('../util/contentstack-management-sdk')
+const helper = require('../util/fs');
+let { addlogs } = require('../util/log');
+const chalk = require('chalk');
+let stack = require('../util/contentstack-management-sdk');
 
-let config = require('../../config/default')
-let environmentConfig = config.modules.environments
-let environmentsFolderPath
-let envMapperPath
-let envUidMapperPath
-let envSuccessPath
-let envFailsPath
-let client
+let config = require('../../config/default');
+let environmentConfig = config.modules.environments;
+let environmentsFolderPath;
+let envMapperPath;
+let envUidMapperPath;
+let envSuccessPath;
+let envFailsPath;
+let client;
 
-function importEnvironments () {
-  this.fails = []
-  this.success = []
-  this.envUidMapper = {}
+function importEnvironments() {
+  this.fails = [];
+  this.success = [];
+  this.envUidMapper = {};
 }
 
 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)
+    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 = self.envUidMapper || {}
+      self.envUidMapper = helper.readFile(envUidMapperPath);
+      self.envUidMapper = self.envUidMapper || {};
     }
 
-    mkdirp.sync(envMapperPath)
+    mkdirp.sync(envMapperPath);
     return new Promise(function (resolve, reject) {
-      if (self.environments === undefined) {
-        addlogs(config, chalk.yellow('No Environment Found'), 'success')
-        return resolve()
+      if (self.environments === undefined || isEmpty(self.environments)) {
+        addlogs(config, chalk.yellow('No Environment Found'), 'success');
+        return resolve({ empty: true });
       }
 
-      let envUids = Object.keys(self.environments)
-      return Promise.map(envUids, function (envUid) {
-        let env = self.environments[envUid]
-        if (!self.envUidMapper.hasOwnProperty(envUid)) {
-          let requestOption = {
+      let envUids = Object.keys(self.environments);
+      return Promise.map(
+        envUids,
+        function (envUid) {
+          let env = self.environments[envUid];
+          if (!self.envUidMapper.hasOwnProperty(envUid)) {
+            let requestOption = {
               environment: env,
-          }
+            };
 
-      return client.stack({api_key: config.target_stack, management_token: config.management_token}).environment().create(requestOption)
-           .then(environment => {
-            self.success.push(environment.items)
-            self.envUidMapper[envUid] = environment.uid
-            helper.writeFile(envUidMapperPath, self.envUidMapper)
-            return
-          }).catch(function (err) {
-            let error = JSON.parse(err.message)
-            if (error.errors.name) {
-              addlogs(config, chalk.white('Environment: \'' + env.name + '\' already exists'), 'error')
-            } else {
-              addlogs(config, chalk.white('Environment: \'' + env.name + '\' failed to be import\n ' + JSON.stringify(error.errors)), 'error')
-            }
-            return
-          })
-        } else {
-          // the environment has already been created
-          addlogs(config, chalk.white('The environment: \'' + env.name +
-            '\' already exists. Skipping it to avoid duplicates!'), 'success')
-          return
-        }
-        // import 2 environments at a time
-      }, {
-        concurrency: 2,
-      }).then(function () {
-        // environments have imported successfully
-        helper.writeFile(envSuccessPath, self.success)
-        addlogs(config, chalk.green('Environments have been imported successfully!'), 'success')
-        return resolve()
-      }).catch(function (error) {
-        // error while importing environments
-        helper.writeFile(envFailsPath, self.fails)
-        addlogs(config, chalk.red('Environment import failed'), 'error')
-        return reject(error)
-      })
-    })
+            return client
+              .stack({ api_key: config.target_stack, management_token: config.management_token })
+              .environment()
+              .create(requestOption)
+              .then((environment) => {
+                self.success.push(environment.items);
+                self.envUidMapper[envUid] = environment.uid;
+                helper.writeFile(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');
+                } else {
+                  addlogs(
+                    config,
+                    chalk.white(
+                      "Environment: '" + env.name + "' failed to be import\n " + JSON.stringify(error.errors),
+                    ),
+                    'error',
+                  );
+                }
+              });
+          } else {
+            // the environment has already been created
+            addlogs(
+              config,
+              chalk.white("The environment: '" + env.name + "' already exists. Skipping it to avoid duplicates!"),
+              'success',
+            );
+          }
+          // import 2 environments at a time
+        },
+        {
+          concurrency: 2,
+        },
+      )
+        .then(function () {
+          // environments have imported successfully
+          helper.writeFile(envSuccessPath, self.success);
+          addlogs(config, chalk.green('Environments have been imported successfully!'), 'success');
+          return resolve();
+        })
+        .catch(function (error) {
+          // error while importing environments
+          helper.writeFile(envFailsPath, self.fails);
+          addlogs(config, chalk.red('Environment import failed'), 'error');
+          return reject(error);
+        });
+    });
   },
-}
+};
 
-module.exports = new importEnvironments()
+module.exports = new importEnvironments();

package/src/lib/import/extensions.js

@@ -4,96 +4,114 @@
  * MIT Licensed
  */
 
-const mkdirp = require('mkdirp')
-const fs = require('fs')
-const path = require('path')
-const Promise = require('bluebird')
-const chalk = require('chalk')
+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 helper = require('../util/fs')
-const {addlogs} = require('../util/log')
-const util = require('../util')
+const helper = require('../util/fs');
+const { addlogs } = require('../util/log');
+const util = 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
+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 = {}
+function importExtensions() {
+  this.fails = [];
+  this.success = [];
+  this.extUidMapper = {};
 }
 
 importExtensions.prototype = {
   start: function (credential) {
-    addlogs(config, chalk.white('Migrating extensions'), 'success')
-    let self = this
-    config = credential
-    client = stack.Client(config)
+    addlogs(config, chalk.white('Migrating extensions'), 'success');
+    let self = this;
+    config = credential;
+    client = stack.Client(config);
 
-    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))
+    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));
     if (fs.existsSync(extUidMapperPath)) {
-      self.extUidMapper = helper.readFile(extUidMapperPath)
-      self.extUidMapper = self.extUidMapper || {}
+      self.extUidMapper = helper.readFile(extUidMapperPath);
+      self.extUidMapper = self.extUidMapper || {};
     }
 
-    mkdirp.sync(extMapperPath)
+    mkdirp.sync(extMapperPath);
 
     return new Promise(function (resolve, reject) {
-      if (self.extensions === undefined) {
-        addlogs(config, chalk.white('No Extensions Found'), 'success')
-        return resolve()
+      if (self.extensions === undefined || isEmpty(self.extensions)) {
+        addlogs(config, chalk.white('No Extensions Found'), 'success');
+        return resolve({ empty: true });
       }
-      let extUids = Object.keys(self.extensions)
-      return Promise.map(extUids, 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}).extension().create({extension: ext})
-          .then(response => {
-            self.success.push(response)
-            self.extUidMapper[extUid] = response.uid
-            helper.writeFile(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')
-            } else {
-              addlogs(config, chalk.white('Extension: \'' + ext.title + '\' failed to be import\n ' + JSON.stringify(error.errors)), 'error')
-            }
-          })
-        }
-        // the extensions has already been created
-        addlogs(config, chalk.white('The extension: \'' + ext.name +
-            '\' already exists. Skipping it to avoid duplicates!'), 'success')
-        // import 2 extensions at a time
-      }, {
-        concurrency: reqConcurrency,
-      }).then(function () {
-        // extensions have imported successfully
-        helper.writeFile(extSuccessPath, self.success)
-        addlogs(config, chalk.green('Extensions have been imported successfully!'), 'success')
-        return resolve()
-      }).catch(function (error) {
-        // error while importing extensions
-        helper.writeFile(extFailsPath, self.fails)
-        addlogs(config, chalk.red('Extension import failed'), 'error')
-        return reject(error)
-      })
-    })
+      let extUids = Object.keys(self.extensions);
+      return Promise.map(
+        extUids,
+        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 })
+              .extension()
+              .create({ extension: ext })
+              .then((response) => {
+                self.success.push(response);
+                self.extUidMapper[extUid] = response.uid;
+                helper.writeFile(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');
+                } else {
+                  addlogs(
+                    config,
+                    chalk.white("Extension: '" + ext.title + "' failed to be import\n " + JSON.stringify(error.errors)),
+                    'error',
+                  );
+                }
+              });
+          }
+          // the extensions has already been created
+          addlogs(
+            config,
+            chalk.white("The extension: '" + ext.title + "' already exists. Skipping it to avoid duplicates!"),
+            'success',
+          );
+          // import 2 extensions at a time
+        },
+        {
+          concurrency: reqConcurrency,
+        },
+      )
+        .then(function () {
+          // extensions have imported successfully
+          helper.writeFile(extSuccessPath, self.success);
+          addlogs(config, chalk.green('Extensions have been imported successfully!'), 'success');
+          return resolve();
+        })
+        .catch(function (error) {
+          // error while importing extensions
+          helper.writeFile(extFailsPath, self.fails);
+          addlogs(config, chalk.red('Extension import failed'), 'error');
+          return reject(error);
+        });
+    });
   },
-}
+};
 
-module.exports = new importExtensions()
+module.exports = new importExtensions();

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

@@ -4,130 +4,141 @@
  * 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 fs = require('fs');
+let path = require('path');
+let Promise = require('bluebird');
+let chalk = require('chalk');
+const {isEmpty} = require('lodash');
 
-let helper = require('../util/fs')
-let {addlogs} = require('../util/log')
-let util = require('../util')
-let extension_supress = require('../util/extensionsUidReplace')
-let removeReferenceFields = require('../util/removeReferenceFields')
-const stack = require('../util/contentstack-management-sdk')
+let helper = require('../util/fs');
+let { addlogs } = require('../util/log');
+let extension_supress = require('../util/extensionsUidReplace');
+let removeReferenceFields = require('../util/removeReferenceFields');
+const stack = require('../util/contentstack-management-sdk');
 
-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 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 = [];
 
-global._globalField_pending = []
-
-function importGlobalFields () {
-  this.fails = []
-  this.success = []
-  this.snipUidMapper = {}
+function importGlobalFields() {
+  this.fails = [];
+  this.success = [];
+  this.snipUidMapper = {};
   this.requestOptions = {
     uri: config.host + config.apis.globalfields,
     headers: config.headers,
     method: 'POST',
-  }
+  };
 }
 
 importGlobalFields.prototype = {
   start: 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))
+    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));
     if (fs.existsSync(globalfieldsUidMapperPath)) {
-      self.snipUidMapper = helper.readFile(globalfieldsUidMapperPath)
-      self.snipUidMapper = this.snipUidMapper || {}
+      self.snipUidMapper = helper.readFile(globalfieldsUidMapperPath);
+      self.snipUidMapper = this.snipUidMapper || {};
     }
 
     if (!fs.existsSync(globalfieldsMapperPath)) {
-      mkdirp.sync(globalfieldsMapperPath)
+      mkdirp.sync(globalfieldsMapperPath);
     }
-    client = stack.Client(config)
+    client = stack.Client(config);
     return new Promise(function (resolve, reject) {
-      if (self.globalfields === undefined) {
-        addlogs(config, chalk.white('No globalfields Found'), 'success')
-        helper.writeFile(globalFieldsPending, _globalField_pending)
-        return resolve()
+      if (self.globalfields === undefined || isEmpty(self.globalfields)) {
+        addlogs(config, chalk.white('No globalfields Found'), 'success');
+        helper.writeFile(globalFieldsPending, _globalField_pending);
+        return resolve({ empty: true });
       }
-      let snipUids = Object.keys(self.globalfields)
-      return Promise.map(snipUids, function (snipUid) {
-        let flag = {
-          supressed: false,
-        }
-        let snip = self.globalfields[snipUid]
-        extension_supress(snip.schema)
-        removeReferenceFields(snip.schema, flag)
+      let snipUids = Object.keys(self.globalfields);
+      return Promise.map(
+        snipUids,
+        function (snipUid) {
+          let flag = {
+            supressed: false,
+          };
+          let snip = self.globalfields[snipUid];
+          extension_supress(snip.schema);
+          removeReferenceFields(snip.schema, flag);
 
-        if (flag.supressed) {
-          // eslint-disable-next-line no-undef
-          _globalField_pending.push(snip.uid)
-        }
+          if (flag.supressed) {
+            // eslint-disable-next-line no-undef
+            _globalField_pending.push(snip.uid);
+          }
 
-        if (!self.snipUidMapper.hasOwnProperty(snipUid)) {
-          let requestOption = {
-            global_field: snip,
+          if (!self.snipUidMapper.hasOwnProperty(snipUid)) {
+            let requestOption = {
+              global_field: snip,
+            };
+            return client
+              .stack({ api_key: config.target_stack, management_token: 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');
+              })
+              .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');
+                } else {
+                  addlogs(config, chalk.red('Globalfield failed to import ' + JSON.stringify(error.errors)), 'error');
+                }
+                self.fails.push(snip);
+              });
+          } else {
+            // globalfields has already been created
+            addlogs(
+              config,
+              chalk.white('The globalfields already exists. Skipping it to avoid duplicates!'),
+              'success',
+            );
           }
-        return client.stack({api_key: config.target_stack, management_token: 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')
-            return
-          }).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')
-            } else {
-              addlogs(config, chalk.red('Globalfield failed to import ' + JSON.stringify(error.errors)), 'error')
-            }
-            self.fails.push(snip)
-            return
-          })
-        } else {
-          // globalfields has already been created
-          addlogs(config, chalk.white('The globalfields already exists. Skipping it to avoid duplicates!'), 'success')
-          return
-        }
-        // import 2 globalfields at a time
-      }, {
-        concurrency: 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')
-        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')
-        return reject(error)
-      })
-    })
+          // import 2 globalfields at a time
+        },
+        {
+          concurrency: 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');
+          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');
+          return reject(error);
+        });
+    });
   },
-}
+};
 
-module.exports = new importGlobalFields()
+module.exports = new importGlobalFields();