@contentstack/cli-cm-export 0.1.1-beta.9 → 1.1.0

package/src/lib/export/content-types.js

@@ -4,24 +4,23 @@
  * MIT Licensed
  */
 
-const mkdirp = require('mkdirp')
-const path = require('path')
-const chalk = require('chalk')
-const Promise = require('bluebird')
+const mkdirp = require('mkdirp');
+const path = require('path');
+const chalk = require('chalk');
+const Promise = require('bluebird');
 
-const helper = require('../util/helper')
-// const log = require('../util/log')
-const stack = require('../util/contentstack-management-sdk')
-const {addlogs} = require('../util/log')
+const helper = require('../util/helper');
+const stack = require('../util/contentstack-management-sdk');
+const { addlogs } = require('../util/log');
 
-let config = require('../../config/default')
-const contentTypeConfig = config.modules.content_types
-const validKeys = contentTypeConfig.validKeys
-let client
-let contentTypesFolderPath
+let config = require('../../config/default');
+const contentTypeConfig = config.modules.content_types;
+const validKeys = contentTypeConfig.validKeys;
+let client;
+let contentTypesFolderPath;
 
 function ExportContentTypes() {
-  this.content_types = []
+  this.content_types = [];
 
   this.requestOptions = {
     qs: {
@@ -30,83 +29,88 @@ function ExportContentTypes() {
       limit: config.modules.content_types.limit,
       include_global_field_schema: true,
     },
-  }
+  };
 }
 
 ExportContentTypes.prototype = {
   start: function (credentialConfig) {
-    this.content_types = []
-    let self = this
-    config = credentialConfig
-    contentTypesFolderPath = path.resolve(config.data, (config.branchName || ""), contentTypeConfig.dirName)
+    this.content_types = [];
+    let self = this;
+    config = credentialConfig;
+    contentTypesFolderPath = path.resolve(config.data, config.branchName || '', contentTypeConfig.dirName);
 
-    client = stack.Client(config)
+    client = stack.Client(config);
     // If content type id is provided then use it as part of query
     if (Array.isArray(config.contentTypes) && config.contentTypes.length > 0) {
-      self.requestOptions.qs.uid = {'$in': config.contentTypes}
+      self.requestOptions.qs.uid = { $in: config.contentTypes };
     }
     // Create folder for content types
-    mkdirp.sync(contentTypesFolderPath)
-    addlogs(config, 'Starting content type export', 'success')
+    mkdirp.sync(contentTypesFolderPath);
+    addlogs(config, 'Starting content type export', 'success');
     return new Promise(function (resolve, reject) {
-      return self.getContentTypes().then(function () {
-        return self.writeContentTypes()
-        .then(result => {
-          return resolve()
+      return self
+        .getContentTypes()
+        .then(function () {
+          return self
+            .writeContentTypes()
+            .then(() => {
+              return resolve();
+            })
+            .catch((error) => {
+              return reject(error);
+            });
         })
-        .catch(error => {
-          return reject(error)
-        })
-      }).catch(reject)
-    })
+        .catch(reject);
+    });
   },
   getContentTypes: function (skip) {
-    let self = this
+    let self = this;
     if (typeof skip !== 'number') {
-      skip = 0
-      self.requestOptions.qs.skip = skip
+      skip = 0;
+      self.requestOptions.qs.skip = skip;
     } else {
-      self.requestOptions.qs.skip = skip
+      self.requestOptions.qs.skip = skip;
     }
 
     return new Promise(function (resolve, reject) {
-      client.stack({api_key: config.source_stack, management_token: config.management_token}).contentType().query(self.requestOptions.qs).find()
-      .then(contenttypeResponse => {
-        if (contenttypeResponse.items.length === 0) {
-          addlogs(config, 'No content types were found in the Stack', 'success')
-          return resolve()
-        }
-        contenttypeResponse.items.forEach(function (content_type) {
-          for (let key in content_type) {
-            if (validKeys.indexOf(key) === -1) {
-              delete content_type[key]
-            }
+      client
+        .stack({ api_key: config.source_stack, management_token: config.management_token })
+        .contentType()
+        .query(self.requestOptions.qs)
+        .find()
+        .then((contenttypeResponse) => {
+          if (contenttypeResponse.items.length === 0) {
+            addlogs(config, 'No content types were found in the Stack', 'success');
+            return resolve();
           }
-          self.content_types.push(content_type)
-        })
+          contenttypeResponse.items.forEach(function (content_type) {
+            for (let key in content_type) {
+              if (validKeys.indexOf(key) === -1) {
+                delete content_type[key];
+              }
+            }
+            self.content_types.push(content_type);
+          });
 
-        skip += config.modules.content_types.limit
-        if (skip > contenttypeResponse.count) {
-          return resolve()
-        }
-        return self.getContentTypes(skip)
-        .then(resolve)
-        .catch(reject)
-      })
-    })
+          skip += config.modules.content_types.limit;
+          if (skip > contenttypeResponse.count) {
+            return resolve();
+          }
+          return self.getContentTypes(skip).then(resolve).catch(reject);
+        });
+    });
   },
   writeContentTypes: function () {
-    let self = this
+    let self = this;
     return new Promise(function (resolve) {
-      helper.writeFile(path.join(contentTypesFolderPath, 'schema.json'), self.content_types)
+      helper.writeFile(path.join(contentTypesFolderPath, 'schema.json'), self.content_types);
       self.content_types.forEach(function (content_type) {
-        helper.writeFile(path.join(contentTypesFolderPath, content_type.uid + '.json'),
-          content_type)
-      })
-      addlogs(config, chalk.green('Content type(s) exported successfully'), 'success')
-      return resolve()
-    })
+        helper.writeFile(path.join(contentTypesFolderPath, content_type.uid + '.json'), content_type);
+      });
+      addlogs(config, chalk.green('Content type(s) exported successfully'), 'success');
+      return resolve();
+    });
   },
-}
+};
 
-module.exports = new ExportContentTypes()
+module.exports = new ExportContentTypes();

package/src/lib/export/custom-roles.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const mkdirp = require('mkdirp');
+const path = require('path');
+const chalk = require('chalk');
+
+const helper = require('../util/helper');
+const { addlogs } = require('../util/log');
+
+const stack = require('../util/contentstack-management-sdk');
+let config = require('../../config/default');
+const rolesConfig = config.modules.customRoles;
+
+const EXISTING_ROLES = {
+  Admin: 1,
+  Developer: 1,
+  'Content Manager': 1,
+};
+
+function ExportCustomRoles() {
+  this.client = null;
+  this.roles = {};
+}
+
+ExportCustomRoles.prototype.start = async function (credentialConfig) {
+  try {
+    addlogs(config, 'Starting roles export', 'success');
+    let self = this;
+    this.roles = {};
+    config = credentialConfig;
+    this.client = stack.Client(config);
+
+    const rolesFolderPath = path.resolve(config.data, config.branchName || '', rolesConfig.dirName);
+    mkdirp.sync(rolesFolderPath);
+
+    const roles = await this.client
+      .stack({ api_key: config.source_stack, management_token: config.management_token })
+      .role()
+      .fetchAll({ include_rules: true, include_permissions: true });
+
+    const customRoles = roles.items.filter(role => !EXISTING_ROLES[role.name]);
+
+    if (!customRoles.length) {
+      addlogs(config, 'No custom roles were found in the Stack', 'success');
+      return;
+    }
+
+    await getCustomRolesLocales(customRoles, path.join(rolesFolderPath, rolesConfig.customRolesLocalesFileName), this.client, config);
+    self.customRoles = {};
+    customRoles.forEach(role => {
+      addlogs(config, role.name + ' role was exported successfully', 'success');
+      self.customRoles[role.uid] = role;
+    });
+    helper.writeFile(path.join(rolesFolderPath, rolesConfig.fileName), self.customRoles);
+    addlogs(config, chalk.green('All the custom roles have been exported successfully'), 'success');
+  } catch (error) {
+    if (error.statusCode === 401) {
+      addlogs(config, chalk.red('You are not allowed to export roles, Unless you provide email and password in config'), 'error');
+      return;
+    }
+    addlogs(config, 'Error occurred in exporting roles. ' + error && error.message, 'error');
+    throw error;
+  }
+};
+
+async function getCustomRolesLocales(customRoles, customRolesLocalesFilepath, client, config) {
+  const localesMap = {};
+  for (const role of customRoles) {
+    const rulesLocales = role.rules.find(rule => rule.module === 'locale');
+    if (rulesLocales.locales && rulesLocales.locales.length) {
+      rulesLocales.locales.forEach(locale => {
+        localesMap[locale] = 1;
+      });
+    }
+  }
+
+  if (Object.keys(localesMap).length) {
+    const locales = await client.stack({ api_key: config.source_stack, management_token: config.management_token }).locale().query({}).find();
+    const sourceLocalesMap = {};
+    for (const locale of locales.items) {
+      sourceLocalesMap[locale.uid] = locale;
+    }
+    for (const locale in localesMap) {
+      delete sourceLocalesMap[locale]['stackHeaders'];
+      localesMap[locale] = sourceLocalesMap[locale];
+    }
+    helper.writeFile(customRolesLocalesFilepath, localesMap);
+  }
+}
+
+module.exports = new ExportCustomRoles();

package/src/lib/export/entries.js

@@ -4,28 +4,28 @@
  * MIT Licensed
  */
 
-const fs = require('fs')
-const path = require('path')
-const _ = require('lodash')
-const Promise = require('bluebird')
-const chalk = require('chalk')
-const mkdirp = require('mkdirp')
-const {addlogs} = require('../util/log')
+const fs = require('fs');
+const path = require('path');
+const _ = require('lodash');
+const Promise = require('bluebird');
+const chalk = require('chalk');
+const mkdirp = require('mkdirp');
+const { addlogs } = require('../util/log');
 
-const helper = require('../util/helper')
-const log = require('../util/log')
-const stack = require('../util/contentstack-management-sdk')
+const helper = require('../util/helper');
+const log = require('../util/log');
+const stack = require('../util/contentstack-management-sdk');
 
-let config = require('../../config/default')
-let entriesConfig = config.modules.entries
-let invalidKeys = entriesConfig.invalidKeys
-let limit = entriesConfig.limit
-let content_types
-let locales
-let entryFolderPath
-let localesFilePath
-let schemaFilePath
-let client
+let config = require('../../config/default');
+let entriesConfig = config.modules.entries;
+let invalidKeys = entriesConfig.invalidKeys;
+let limit = entriesConfig.limit;
+let content_types;
+let locales;
+let entryFolderPath;
+let localesFilePath;
+let schemaFilePath;
+let client;
 
 function exportEntries() {
   this.requestOptions = {
@@ -36,52 +36,70 @@ function exportEntries() {
       limit: limit,
     },
     json: true,
-  }
+  };
 }
 
 exportEntries.prototype.start = function (credentialConfig) {
-  let self = this
-  config = credentialConfig
-  entryFolderPath = path.resolve(config.data, (config.branchName || ""), config.modules.entries.dirName)
-  localesFilePath = path.resolve(config.data, (config.branchName || ""), config.modules.locales.dirName, config.modules.locales.fileName)
-  schemaFilePath = path.resolve(config.data, (config.branchName || ""), config.modules.content_types.dirName, 'schema.json')
-  client = stack.Client(config)
-  addlogs(config, 'Starting entry migration', 'success')
-  return new Promise(function (resolve, reject) {
-    locales = helper.readFile(localesFilePath)
-    let apiBucket = []
-    content_types = helper.readFile(schemaFilePath)
+  let self = this;
+  config = credentialConfig;
+  entryFolderPath = path.resolve(config.data, config.branchName || '', config.modules.entries.dirName);
+  localesFilePath = path.resolve(
+    config.data,
+    config.branchName || '',
+    config.modules.locales.dirName,
+    config.modules.locales.fileName,
+  );
+  schemaFilePath = path.resolve(
+    config.data,
+    config.branchName || '',
+    config.modules.content_types.dirName,
+    'schema.json',
+  );
+  client = stack.Client(config);
+  addlogs(config, 'Starting entry migration', 'success');
+  return new Promise(function (resolve) {
+    locales = helper.readFile(localesFilePath);
+    let apiBucket = [];
+    content_types = helper.readFile(schemaFilePath);
     if (content_types.length !== 0) {
-      content_types.forEach(content_type => {
+      content_types.forEach((content_type) => {
         if (Object.keys(locales).length !== 0) {
           for (let _locale in locales) {
             apiBucket.push({
               content_type: content_type.uid,
               locale: locales[_locale].code,
-            })
+            });
           }
         }
         apiBucket.push({
           content_type: content_type.uid,
           locale: config.master_locale.code,
+        });
+      });
+      return Promise.map(
+        apiBucket,
+        function (apiDetails) {
+          return self.getEntries(apiDetails);
+        },
+        {
+          concurrency: 1,
+        },
+      )
+        .then(function () {
+          addlogs(config, 'Entry migration completed successfully', 'success');
+          return resolve();
         })
-      })
-      return Promise.map(apiBucket, function (apiDetails) {
-        return self.getEntries(apiDetails)
-      }, {
-        concurrency: 1,
-      }).then(function () {
-        addlogs(config, 'Entry migration completed successfully', 'success')
-        return resolve()
-      }).catch(reject)
+        .catch((error) => {
+          console.log('Error getting entries', error && error.message);
+        });
     }
-    addlogs(config, 'No content_types were found in the Stack', 'success')
-    return resolve()
-  })
-}
+    addlogs(config, 'No content_types were found in the Stack', 'success');
+    return resolve();
+  });
+};
 
 exportEntries.prototype.getEntry = function (apiDetails) {
-  let self = this
+  let self = this;
   return new Promise(function (resolve, reject) {
     let queryRequestObject = {
       locale: apiDetails.locale,
@@ -89,34 +107,42 @@ exportEntries.prototype.getEntry = function (apiDetails) {
         BASE: invalidKeys,
       },
       version: apiDetails.version,
-
-    }
-    client.stack({api_key: config.source_stack, management_token: config.management_token}).contentType(apiDetails.content_type).entry(apiDetails.uid).fetch(queryRequestObject)
-    .then(singleEntry => {
-      let entryPath = path.join(entryFolderPath, apiDetails.locale, apiDetails.content_type,
-        singleEntry.uid)
-      mkdirp.sync(entryPath)
-      helper.writeFile(path.join(entryPath, 'version-' + singleEntry._version +
-        '.json'), singleEntry)
-      addlogs(config, 'Completed version backup of entry: ' + singleEntry.uid +
-        ', version: ' + singleEntry._version + ', content type: ' + apiDetails.content_type, 'success')
-      if (--apiDetails.version !== 0) {
-        return self.getEntry(apiDetails)
-        .then(resolve)
-        .catch(reject)
-      }
-      return resolve()
-    }).catch(error => {
-      addlogs(config, error, 'error')
-    })
-  })
-}
+    };
+    client
+      .stack({ api_key: config.source_stack, management_token: config.management_token })
+      .contentType(apiDetails.content_type)
+      .entry(apiDetails.uid)
+      .fetch(queryRequestObject)
+      .then((singleEntry) => {
+        let entryPath = path.join(entryFolderPath, apiDetails.locale, apiDetails.content_type, singleEntry.uid);
+        mkdirp.sync(entryPath);
+        helper.writeFile(path.join(entryPath, 'version-' + singleEntry._version + '.json'), singleEntry);
+        addlogs(
+          config,
+          'Completed version backup of entry: ' +
+            singleEntry.uid +
+            ', version: ' +
+            singleEntry._version +
+            ', content type: ' +
+            apiDetails.content_type,
+          'success',
+        );
+        if (--apiDetails.version !== 0) {
+          return self.getEntry(apiDetails).then(resolve).catch(reject);
+        }
+        return resolve();
+      })
+      .catch((error) => {
+        addlogs(config, error, 'error');
+      });
+  });
+};
 
 exportEntries.prototype.getEntries = function (apiDetails) {
-  let self = this
+  let self = this;
   return new Promise(function (resolve, reject) {
     if (typeof apiDetails.skip !== 'number') {
-      apiDetails.skip = 0
+      apiDetails.skip = 0;
     }
 
     let queryrequestObject = {
@@ -128,70 +154,99 @@ exportEntries.prototype.getEntries = function (apiDetails) {
       query: {
         locale: apiDetails.locale,
       },
-    }
-    client.stack({api_key: config.source_stack, management_token: config.management_token}).contentType(apiDetails.content_type).entry().query(queryrequestObject).find()
-      .then(entriesList => {
-      // /entries/content_type_uid/locale.json
-      if (!fs.existsSync(path.join(entryFolderPath, apiDetails.content_type))) {
-        mkdirp.sync(path.join(entryFolderPath, apiDetails.content_type))
-      }
-      let entriesFilePath = path.join(entryFolderPath, apiDetails.content_type, apiDetails.locale + '.json')
-      let entries = helper.readFile(entriesFilePath)
-      entries = entries || {}
-      entriesList.items.forEach(function (entry) {
-        invalidKeys.forEach(e => delete entry[e])
-        entries[entry.uid] = entry
-      })
-      helper.writeFile(entriesFilePath, entries)
-
-      if (typeof config.versioning === 'boolean' && config.versioning) {
-        for (let locale in locales) {
-          // make folders for each language
-          content_types.forEach(function (content_type) {
-            // make folder for each content type
-            let versionedEntryFolderPath = path.join(entryFolderPath, locales[locale].code,content_type.uid)
-            mkdirp.sync(versionedEntryFolderPath)
-          })
+    };
+    client
+      .stack({ api_key: config.source_stack, management_token: config.management_token })
+      .contentType(apiDetails.content_type)
+      .entry()
+      .query(queryrequestObject)
+      .find()
+      .then((entriesList) => {
+        // /entries/content_type_uid/locale.json
+        if (!fs.existsSync(path.join(entryFolderPath, apiDetails.content_type))) {
+          mkdirp.sync(path.join(entryFolderPath, apiDetails.content_type));
         }
-        return Promise.map(entriesList.items, function (entry) {
-          let entryDetails = {
-            content_type: apiDetails.content_type,
-            uid: entry.uid,
-            version: entry._version,
-            locale: apiDetails.locale,
-          }
-          return self.getEntry(entryDetails).then(function () {
+        let entriesFilePath = path.join(entryFolderPath, apiDetails.content_type, apiDetails.locale + '.json');
+        let entries = helper.readFile(entriesFilePath);
+        entries = entries || {};
+        entriesList.items.forEach(function (entry) {
+          invalidKeys.forEach((e) => delete entry[e]);
+          entries[entry.uid] = entry;
+        });
+        helper.writeFile(entriesFilePath, entries);
 
-          }).catch(reject)
-        }, {
-          concurrency: 1,
-        }).then(function () {
-          if (apiDetails.skip > entriesList.items.length) {
-            addlogs(config, 'Completed fetching ' + apiDetails.content_type +
-              ' content type\'s entries in ' + apiDetails.locale + ' locale', 'success')
-            return resolve()
+        if (typeof config.versioning === 'boolean' && config.versioning) {
+          for (let locale in locales) {
+            // make folders for each language
+            content_types.forEach(function (content_type) {
+              // make folder for each content type
+              let versionedEntryFolderPath = path.join(entryFolderPath, locales[locale].code, content_type.uid);
+              mkdirp.sync(versionedEntryFolderPath);
+            });
           }
-          apiDetails.skip += limit
-          return self.getEntries(apiDetails).then(function () {
-            return resolve()
-          }).catch(function (error) {
-            return reject(error)
-          })
-        })
-      }
-      if (apiDetails.skip > entriesList.count) {
-        addlogs(config, 'Exported entries of ' + apiDetails.content_type +
-            ' to the ' + apiDetails.locale + ' language successfully', 'success')
-        return resolve()
-      }
-      apiDetails.skip += limit
-      return self.getEntries(apiDetails)
-      .then(resolve)
-      .catch(reject)
-    }).catch(error => {
-      addlogs(config, error, 'error')
-    })
-  })
-}
+          return Promise.map(
+            entriesList.items,
+            function (entry) {
+              let entryDetails = {
+                content_type: apiDetails.content_type,
+                uid: entry.uid,
+                version: entry._version,
+                locale: apiDetails.locale,
+              };
+              return self.getEntry(entryDetails).catch(reject);
+            },
+            {
+              concurrency: 1,
+            },
+          ).then(function () {
+            if (apiDetails.skip > entriesList.items.length) {
+              addlogs(
+                config,
+                'Completed fetching ' +
+                  apiDetails.content_type +
+                  " content type's entries in " +
+                  apiDetails.locale +
+                  ' locale',
+                'success',
+              );
+              return resolve();
+            }
+            apiDetails.skip += limit;
+            return self
+              .getEntries(apiDetails)
+              .then(function () {
+                return resolve();
+              })
+              .catch(function (error) {
+                return reject(error);
+              });
+          });
+        }
+        if (apiDetails.skip > entriesList.count) {
+          addlogs(
+            config,
+            'Exported entries of ' +
+              apiDetails.content_type +
+              ' to the ' +
+              apiDetails.locale +
+              ' language successfully',
+            'success',
+          );
+          return resolve();
+        }
+        apiDetails.skip += limit;
+        return self
+          .getEntries(apiDetails)
+          .then(resolve)
+          .catch((error) => {
+            console.log('Get Entries errror', error && error.message);
+          });
+      })
+      .catch((error) => {
+        console.log('Entries fetch errror', error && error.message);
+        addlogs(config, error, 'error');
+      });
+  });
+};
 
-module.exports = new exportEntries()
+module.exports = new exportEntries();