@contentstack/cli-cm-export 1.0.0 → 1.2.0

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

@@ -1,116 +1,87 @@
-/*!
- * Contentstack Export
- * Copyright (c) 2019 Contentstack LLC
- * MIT Licensed
- */
-
-const mkdirp = require('mkdirp');
 const path = require('path');
+const fileHelper = require('../util/helper');
 const chalk = require('chalk');
-const Promise = require('bluebird');
-
-const helper = require('../util/helper');
-const stack = require('../util/contentstack-management-sdk');
+const { executeTask, formatError } = require('../util');
 const { addlogs } = require('../util/log');
 
-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.requestOptions = {
-    qs: {
+class ContentTypesExport {
+  constructor(exportConfig, stackAPIClient) {
+    this.stackAPIClient = stackAPIClient;
+    this.exportConfig = exportConfig;
+    this.contentTypesConfig = exportConfig.modules.content_types;
+    this.qs = {
       include_count: true,
       asc: 'updated_at',
-      limit: config.modules.content_types.limit,
+      limit: this.contentTypesConfig.limit,
       include_global_field_schema: true,
-    },
-  };
-}
+    };
+    // If content type id is provided then use it as part of query
+    if (Array.isArray(this.exportConfig.contentTypes) && this.exportConfig.length > 0) {
+      this.qs.uid = { $in: this.exportConfig.contentTypes };
+    }
+    this.contentTypesPath = path.resolve(
+      exportConfig.data,
+      exportConfig.branchName || '',
+      this.contentTypesConfig.dirName,
+    );
+    this.contentTypes = [];
+    this.fetchConcurrency = this.contentTypesConfig.fetchConcurrency || this.exportConfig.fetchConcurrency;
+    this.writeConcurrency = this.contentTypesConfig.writeConcurrency || this.exportConfig.writeConcurrency;
+  }
 
-ExportContentTypes.prototype = {
-  start: function (credentialConfig) {
-    this.content_types = [];
-    let self = this;
-    config = credentialConfig;
-    contentTypesFolderPath = path.resolve(config.data, config.branchName || '', contentTypeConfig.dirName);
+  async start() {
+    try {
+      addlogs(this.exportConfig, 'Starting content type export', 'success');
+      await fileHelper.makeDirectory(this.contentTypesPath);
+      await this.getContentTypes();
+      await this.writeContentTypes(this.contentTypes);
+      addlogs(this.exportConfig, chalk.green('Content type(s) exported successfully'), 'success');
+    } catch (error) {
+      addlogs(this.exportConfig, chalk.red(`Failed to export content types ${formatError(error)}`), 'error');
+      throw new Error('Failed to export content types');
+    }
+  }
 
-    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 };
+  async getContentTypes(skip = 0) {
+    if (skip) {
+      this.qs.skip = skip;
     }
-    // Create folder for content types
-    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(() => {
-              return resolve();
-            })
-            .catch((error) => {
-              return reject(error);
-            });
-        })
-        .catch(reject);
-    });
-  },
-  getContentTypes: function (skip) {
-    let self = this;
-    if (typeof skip !== 'number') {
-      skip = 0;
-      self.requestOptions.qs.skip = skip;
+
+    const contentTypeSearchResponse = await this.stackAPIClient.contentType().query(this.qs).find();
+    if (Array.isArray(contentTypeSearchResponse.items) && contentTypeSearchResponse.items.length > 0) {
+      let updatedContentTypes = this.sanitizeAttribs(contentTypeSearchResponse.items);
+      this.contentTypes.push(...updatedContentTypes);
+
+      skip += this.contentTypesConfig.limit;
+      if (skip > contentTypeSearchResponse.count) {
+        return;
+      }
+      return await this.getContentTypes(skip);
     } else {
-      self.requestOptions.qs.skip = skip;
+      console.log('No content types returned for the given query');
     }
+  }
 
-    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];
-              }
-            }
-            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);
-        });
+  sanitizeAttribs(contentTypes) {
+    let updatedContentTypes = [];
+    contentTypes.forEach((contentType) => {
+      for (let key in contentType) {
+        if (this.contentTypesConfig.validKeys.indexOf(key) === -1) {
+          delete contentType[key];
+        }
+      }
+      updatedContentTypes.push(contentType);
     });
-  },
-  writeContentTypes: function () {
-    let self = this;
-    return new Promise(function (resolve) {
-      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();
-    });
-  },
-};
+    return updatedContentTypes;
+  }
+
+  async writeContentTypes(contentTypes) {
+    function write(contentType) {
+      return fileHelper.writeFile(path.join(this.contentTypesPath, contentType.uid + '.json'), contentType);
+    }
+    await executeTask(contentTypes, write.bind(this), { concurrency: this.writeConcurrency });
+    return fileHelper.writeFile(path.join(this.contentTypesPath, 'schema.json'), contentTypes);
+  }
+}
 
-module.exports = new ExportContentTypes();
+module.exports = ContentTypesExport;

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

@@ -0,0 +1,106 @@
+'use strict';
+
+const path = require('path');
+const chalk = require('chalk');
+const mkdirp = require('mkdirp');
+const { merge } = require('lodash');
+
+const helper = require('../util/helper');
+const { addlogs } = require('../util/log');
+const { formatError } = require('../util');
+const config = require('../../config/default');
+const stack = require('../util/contentstack-management-sdk');
+
+module.exports = class ExportCustomRoles {
+  roles = {};
+  client = null;
+  customRoles = {};
+  EXISTING_ROLES = {
+    Admin: 1,
+    Developer: 1,
+    'Content Manager': 1,
+  };
+  rolesConfig = config.modules.customRoles;
+
+  constructor(credentialConfig) {
+    this.config = merge(config, credentialConfig);
+    this.client = stack.Client(this.config);
+  }
+
+  async start() {
+    try {
+      const self = this;
+      addlogs(this.config, 'Starting roles export', 'success');
+
+      const rolesFolderPath = path.resolve(this.config.data, this.config.branchName || '', this.rolesConfig.dirName);
+      mkdirp.sync(rolesFolderPath);
+
+      const roles = await this.client
+        .stack({ api_key: self.config.source_stack, management_token: self.config.management_token })
+        .role()
+        .fetchAll({ include_rules: true, include_permissions: true });
+
+      const customRoles = roles.items.filter((role) => !self.EXISTING_ROLES[role.name]);
+
+      if (!customRoles.length) {
+        addlogs(self.config, 'No custom roles were found in the Stack', 'success');
+        return;
+      }
+
+      await getCustomRolesLocales(
+        customRoles,
+        path.join(rolesFolderPath, self.rolesConfig.customRolesLocalesFileName),
+        this.client,
+        self.config,
+      );
+      self.customRoles = {};
+      customRoles.forEach((role) => {
+        addlogs(self.config, role.name + ' role was exported successfully', 'success');
+        self.customRoles[role.uid] = role;
+      });
+      helper.writeFileSync(path.join(rolesFolderPath, self.rolesConfig.fileName), self.customRoles);
+      addlogs(self.config, chalk.green('All the custom roles have been exported successfully'), 'success');
+    } catch (error) {
+      if (error.statusCode === 401) {
+        addlogs(
+          self.config,
+          chalk.red('You are not allowed to export roles, Unless you provide email and password in config'),
+          'error',
+        );
+        return;
+      }
+      addlogs(self.config, 'Error occurred in exporting roles. ' + error && error.message, 'error');
+      addlogs(self.config, formatError(error), 'error');
+      throw error;
+    }
+  }
+
+  async 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.writeFileSync(customRolesLocalesFilepath, localesMap);
+    }
+  }
+};