@contentstack/cli-cm-import 1.5.11 → 1.6.0

package/src/lib/import/environments.js

@@ -1,106 +0,0 @@
-/*!
- * Contentstack Import
- * Copyright (c) 2019 Contentstack LLC
- * MIT Licensed
- */
-
-const fs = require('fs');
-const path = require('path');
-const chalk = require('chalk');
-const mkdirp = require('mkdirp');
-const Promise = require('bluebird');
-const { isEmpty, merge } = require('lodash');
-
-const helper = require('../util/fs');
-let { addlogs } = require('../util/log');
-const { formatError } = require('../util');
-const config = require('../../config/default');
-
-module.exports = class ImportEnvironments {
-  fails = [];
-  success = [];
-  envUidMapper = {};
-  fetchConcurrency = config.modules.environments.concurrency || config.fetchConcurrency || 2;
-
-  constructor(importConfig, stackAPIClient) {
-    this.config = merge(config, importConfig);
-    this.stackAPIClient = stackAPIClient;
-  }
-
-  start() {
-    addlogs(this.config, 'Migrating environment', 'success');
-
-    const self = this;
-    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));
-
-    if (fs.existsSync(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(self.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 = { environment: env };
-
-            return self.stackAPIClient
-              .environment()
-              .create(requestOption)
-              .then((environment) => {
-                self.success.push(environment.items);
-                self.envUidMapper[envUid] = environment.uid;
-                helper.writeFileSync(envUidMapperPath, self.envUidMapper);
-              })
-              .catch(function (err) {
-                let error = JSON.parse(err.message);
-
-                if (error.errors.name) {
-                  addlogs(self.config, `Environment '${env.name}' already exists`, 'error');
-                } else {
-                  addlogs(
-                    config,
-                    `Environment '${env.name}' failed to be import\n ${JSON.stringify(error.errors)}`,
-                    'error',
-                  );
-                }
-              });
-          } else {
-            // the environment has already been created
-            addlogs(
-              config,
-              `The environment ${env.name} already exists. Skipping it to avoid duplicates!`,
-              'success',
-            );
-          }
-        },
-        { concurrency: self.fetchConcurrency },
-      )
-        .then(function () {
-          helper.writeFileSync(envSuccessPath, self.success);
-          addlogs(self.config, chalk.green('Environments have been imported successfully!'), 'success');
-          resolve();
-        })
-        .catch(function (error) {
-          helper.writeFileSync(envFailsPath, self.fails);
-          addlogs(self.config, `Failed to import environment, ${formatError(error)}`, 'error');
-          reject(error);
-        });
-    });
-  }
-};

package/src/lib/import/extensions.js

@@ -1,108 +0,0 @@
-/*!
- * Contentstack Import
- * Copyright (c) 2019 Contentstack LLC
- * MIT Licensed
- */
-
-const mkdirp = require('mkdirp');
-const fs = require('fs');
-const path = require('path');
-const Promise = require('bluebird');
-const chalk = require('chalk');
-const { isEmpty, merge } = require('lodash');
-
-const util = require('../util');
-const helper = require('../util/fs');
-const { addlogs } = require('../util/log');
-
-let config = util.getConfig();
-
-module.exports = class ImportExtensions {
-  fails = [];
-  success = [];
-  extUidMapper = {};
-  extensionsConfig = config.modules.extensions;
-  reqConcurrency = config.concurrency || config.fetchConcurrency || 1;
-
-  constructor(importConfig, stackAPIClient) {
-    this.config = merge(config, importConfig);
-    this.stackAPIClient = stackAPIClient;
-  }
-
-  start() {
-    addlogs(this.config, chalk.white('Migrating extensions'), 'success');
-
-    const self = this;
-    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.readFileSync(extUidMapperPath);
-      self.extUidMapper = self.extUidMapper || {};
-    }
-
-    mkdirp.sync(extMapperPath);
-
-    return new Promise(function (resolve, reject) {
-      if (self.extensions === undefined || isEmpty(self.extensions)) {
-        addlogs(self.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 self.stackAPIClient
-              .extension()
-              .create({ extension: ext })
-              .then((response) => {
-                self.success.push(response);
-                self.extUidMapper[extUid] = response.uid;
-                helper.writeFileSync(extUidMapperPath, self.extUidMapper);
-              })
-              .catch(function (err) {
-                let error = JSON.parse(err.message);
-                self.fails.push(ext);
-                if (error.errors.title) {
-                  addlogs(self.config, `Extension '${ext.title}' already exists`, 'error');
-                } 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: self.reqConcurrency,
-        },
-      )
-        .then(function () {
-          // extensions have imported successfully
-          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.writeFileSync(extFailsPath, self.fails);
-          addlogs(self.config, `Extension import failed ${util.formatError(error)}`, 'error');
-          reject(error);
-        });
-    });
-  }
-};

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

@@ -1,135 +0,0 @@
-/*!
- * Contentstack Import
- * Copyright (c) 2019 Contentstack LLC
- * MIT Licensed
- */
-
-let fs = require('fs');
-let path = require('path');
-let chalk = require('chalk');
-let mkdirp = require('mkdirp');
-let Promise = require('bluebird');
-const { isEmpty, merge } = require('lodash');
-
-let helper = require('../util/fs');
-let { addlogs } = require('../util/log');
-const { formatError } = require('../util');
-let config = require('../../config/default');
-let extension_supress = require('../util/extensionsUidReplace');
-let removeReferenceFields = require('../util/removeReferenceFields');
-
-global._globalField_pending = [];
-
-module.exports = class ImportGlobalFields {
-  fails = [];
-  success = [];
-  snipUidMapper = {};
-  installedExtensions = [];
-  reqConcurrency = config.concurrency || config.fetchConcurrency || 1;
-
-  constructor(importConfig, stackAPIClient) {
-    this.config = merge(config, importConfig);
-    this.stackAPIClient = stackAPIClient;
-  }
-
-  async start() {
-    addlogs(this.config, chalk.white('Migrating global-fields'), 'success');
-
-    let self = this;
-    let globalfieldsConfig = config.modules.globalfields;
-    let globalfieldsFolderPath = path.resolve(this.config.data, globalfieldsConfig.dirName);
-    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);
-      self.snipUidMapper = self.snipUidMapper || {};
-    }
-
-    if (!fs.existsSync(globalfieldsMapperPath)) {
-      mkdirp.sync(globalfieldsMapperPath);
-    }
-
-    return new Promise(function (resolve, reject) {
-      if (self.globalfields === undefined || isEmpty(self.globalfields)) {
-        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,
-        async function (snipUid) {
-          let flag = { supressed: false };
-          let snip = self.globalfields[snipUid];
-          extension_supress(snip.schema, self.config.preserveStackVersion, self.installedExtensions);
-          await removeReferenceFields(snip.schema, flag, self.stackAPIClient);
-
-          if (flag.supressed) {
-            // eslint-disable-next-line no-undef
-            _globalField_pending.push(snip.uid);
-          }
-
-          if (!self.snipUidMapper.hasOwnProperty(snipUid)) {
-            let requestOption = { global_field: snip };
-            return self.stackAPIClient
-              .globalField()
-              .create(requestOption)
-              .then((globalField) => {
-                self.success.push(globalField.items);
-                let global_field_uid = globalField.uid;
-                self.snipUidMapper[snipUid] = globalField.items;
-                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(self.config, `Globalfield '${snip.uid} already exists'`, 'error');
-                } else {
-                  addlogs(self.config, `Globalfield failed to import ${formatError(error)}`, 'error');
-                }
-
-                self.fails.push(snip);
-              });
-          } else {
-            // globalfields has already been created
-            addlogs(
-              self.config,
-              chalk.white('The globalfields already exists. Skipping it to avoid duplicates!'),
-              'success',
-            );
-          }
-          // import 2 globalfields at a time
-        },
-        { concurrency: self.reqConcurrency },
-      )
-        .then(function () {
-          // globalfields have imported successfully
-          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
-          addlogs(self.config, err, 'error');
-          helper.writeFileSync(globalfieldsFailsPath, self.fails);
-          addlogs(self.config, `Globalfields import failed. ${formatError(err)}`, 'error');
-          return reject(error);
-        });
-    });
-  }
-};

package/src/lib/import/labels.js

@@ -1,175 +0,0 @@
-/*!
- * Contentstack Import
- * Copyright (c) 2019 Contentstack LLC
- * MIT Licensed
- */
-
-const path = require('path');
-const chalk = require('chalk');
-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');
-const config = require('../../config/default');
-
-module.exports = class ImportLabels {
-  config;
-  fails = [];
-  success = [];
-  labelUids = [];
-  labelsFolderPath;
-  labelUidMapper = {};
-  labelConfig = config.modules.labels;
-  reqConcurrency = config.concurrency || config.fetchConcurrency || 1;
-
-  constructor(importConfig, stackAPIClient) {
-    this.config = merge(config, importConfig);
-    this.stackAPIClient = stackAPIClient;
-  }
-
-  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(self.config, chalk.white('No Label Found'), 'success');
-        return resolve({ empty: true });
-      }
-      self.labelUids = Object.keys(self.labels);
-      return Promise.map(
-        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 };
-
-            return self.stackAPIClient
-              .label()
-              .create(requestOption)
-              .then(function (response) {
-                self.labelUidMapper[labelUid] = response;
-              })
-              .catch(function (error) {
-                self.fails.push(label);
-                if (error.errors.name) {
-                  addlogs(self.config,`Label '${label.name}' already exist`, 'error');
-                } else {
-                  addlogs(self.config,`Label '${label.name}' failed to be imported\n`, 'error');
-                }
-              });
-          } else {
-            // the label has already been created
-            addlogs(
-              self.config,
-              chalk.white(`The label '${label.name}' already exists. Skipping it to avoid duplicates!'`),
-              'success',
-            );
-          }
-          // import 1 labels at a time
-        },
-        { concurrency: self.reqConcurrency },
-      )
-        .then(function () {
-          helper.writeFileSync(labelUidMapperPath, self.labelUidMapper);
-          // eslint-disable-next-line no-undef
-          return self
-            .updateLabels()
-            .then(function () {
-              helper.writeFileSync(labelSuccessPath, self.success);
-              addlogs(self.config, chalk.green('Labels have been imported successfully!'), 'success');
-              return resolve();
-            })
-            .catch(function (error) {
-              addlogs(self.config, `Failed to import label, ${formatError(error)}`, 'error');
-              // eslint-disable-next-line no-console
-              return reject(error);
-            });
-        })
-        .catch(function (error) {
-          // error while importing labels
-          helper.writeFileSync(labelUidMapperPath, self.labelUidMapper);
-          helper.writeFileSync(labelFailsPath, self.fails);
-          addlogs(self.config, `Failed to import label, ${formatError(error)}`, 'error');
-          return reject(error);
-        });
-    });
-  }
-
-  updateLabels() {
-    const self = this;
-    return new Promise(function (resolve, reject) {
-      let labelsObj = helper.readFileSync(path.resolve(self.labelsFolderPath, self.labelConfig.fileName));
-      return Promise.map(
-        self.labelUids,
-        function (labelUid) {
-          let label = labelsObj[labelUid];
-          if (self.labelUidMapper.hasOwnProperty(labelUid)) {
-            let newLabelUid = self.labelUidMapper[labelUid];
-            if (label.parent.length > 0) {
-              let parentUids = label.parent;
-              for (let i = 0; i < parentUids.length; i++) {
-                if (self.labelUidMapper.hasOwnProperty(parentUids[i])) {
-                  label.parent[i] = self.labelUidMapper[parentUids[i]].uid;
-                }
-              }
-              return self.stackAPIClient
-                .label(newLabelUid.uid)
-                .fetch()
-                .then(function (response) {
-                  //Object.assign(response, _.cloneDeep(label))
-                  response.parent = label.parent;
-                  response
-                    .update()
-                    .then((result) => {
-                      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: self.reqConcurrency,
-        },
-      )
-        .then(function () {
-          return resolve();
-        })
-        .catch(function (error) {
-          // eslint-disable-next-line no-console
-          return reject(error);
-        });
-    });
-  }
-};