@contentstack/cli-cm-export 1.1.0 → 1.2.1

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

@@ -1,91 +1,106 @@
 'use strict';
 
-const mkdirp = require('mkdirp');
 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');
-let config = require('../../config/default');
-const rolesConfig = config.modules.customRoles;
 
-const EXISTING_ROLES = {
-  Admin: 1,
-  Developer: 1,
-  'Content Manager': 1,
-};
+module.exports = class ExportCustomRoles {
+  roles = {};
+  client = null;
+  customRoles = {};
+  EXISTING_ROLES = {
+    Admin: 1,
+    Developer: 1,
+    'Content Manager': 1,
+  };
+  rolesConfig = config.modules.customRoles;
 
-function ExportCustomRoles() {
-  this.client = null;
-  this.roles = {};
-}
+  constructor(credentialConfig) {
+    this.config = merge(config, credentialConfig);
+    this.client = stack.Client(this.config);
+  }
 
-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);
+  async start() {
+    const self = this;
+    try {
+      addlogs(this.config, 'Starting roles export', 'success');
 
-    const rolesFolderPath = path.resolve(config.data, config.branchName || '', rolesConfig.dirName);
-    mkdirp.sync(rolesFolderPath);
+      const rolesFolderPath = path.resolve(this.config.data, this.config.branchName || '', this.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 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 => !EXISTING_ROLES[role.name]);
+      const customRoles = roles.items.filter((role) => !self.EXISTING_ROLES[role.name]);
 
-    if (!customRoles.length) {
-      addlogs(config, 'No custom roles were found in the Stack', 'success');
-      return;
-    }
+      if (!customRoles.length) {
+        addlogs(self.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;
+      await self.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;
     }
   }
 
-  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;
+  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;
+        });
+      }
     }
-    for (const locale in localesMap) {
-      delete sourceLocalesMap[locale]['stackHeaders'];
-      localesMap[locale] = sourceLocalesMap[locale];
+
+    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);
     }
-    helper.writeFile(customRolesLocalesFilepath, localesMap);
   }
-}
-
-module.exports = new ExportCustomRoles();
+};