@contentstack/cli-cm-export 1.5.9 → 1.6.1

package/src/lib/export/entries.js

@@ -1,200 +0,0 @@
-const path = require('path');
-const chalk = require('chalk');
-const { addlogs } = require('../util/log');
-const fileHelper = require('../util/helper');
-const { executeTask, formatError } = require('../util');
-
-class EntriesExport {
-  constructor(exportConfig, stackAPIClient) {
-    this.stackAPIClient = stackAPIClient;
-    this.exportConfig = exportConfig;
-    this.entriesConfig = exportConfig.modules.entries;
-    this.entriesRootPath = path.resolve(exportConfig.data, exportConfig.branchName || '', this.entriesConfig.dirName);
-    this.localesFilePath = path.resolve(
-      exportConfig.data,
-      exportConfig.branchName || '',
-      exportConfig.modules.locales.dirName,
-      exportConfig.modules.locales.fileName,
-    );
-    this.schemaFilePath = path.resolve(
-      exportConfig.data,
-      exportConfig.branchName || '',
-      exportConfig.modules.content_types.dirName,
-      'schema.json',
-    );
-    this.fetchConcurrency = this.entriesConfig.fetchConcurrency || exportConfig.fetchConcurrency;
-    this.writeConcurrency = this.entriesConfig.writeConcurrency || exportConfig.writeConcurrency;
-  }
-
-  async start() {
-    try {
-      addlogs(this.exportConfig, 'Starting entries export', 'info');
-      const locales = await fileHelper.readFile(this.localesFilePath);
-      const contentTypes = await fileHelper.readFile(this.schemaFilePath);
-      if (contentTypes.length === 0) {
-        addlogs(this.exportConfig, 'No content types found to export entries', 'info');
-        return;
-      }
-      const entryRequestOptions = this.createRequestObjects(locales, contentTypes);
-      for (let requestOption of entryRequestOptions) {
-        addlogs(
-          this.exportConfig,
-          `Starting export of entries of content_type - ${requestOption.content_type} locale - ${requestOption.locale}`,
-          'info',
-        );
-        await fileHelper.makeDirectory(path.join(this.entriesRootPath, requestOption.content_type));
-        const entries = await this.getEntries(requestOption);
-        let entriesFilePath = path.join(
-          this.entriesRootPath,
-          requestOption.content_type,
-          requestOption.locale + '.json',
-        );
-        await fileHelper.writeLargeFile(entriesFilePath, entries);
-        addlogs(
-          this.exportConfig,
-          `Exported entries of type '${requestOption.content_type}' locale '${requestOption.locale}'`,
-          'success',
-        );
-        if (this.exportConfig.versioning) {
-          addlogs(
-            this.exportConfig,
-            `Started export versioned entries of type '${requestOption.content_type}' locale '${requestOption.locale}'`,
-            'info',
-          );
-          for (let entry of entries) {
-            const versionedEntries = await this.getEntryByVersion(
-              {
-                ...requestOption,
-                uid: entry.uid,
-              },
-              entry._version,
-            );
-            let versionedEntryPath = path.join(
-              this.entriesRootPath,
-              requestOption.locale,
-              requestOption.content_type,
-              entry.uid,
-            );
-            await fileHelper.makeDirectory(versionedEntryPath);
-            if (versionedEntries.length > 0) {
-              const write = (versionedEntry) =>
-                fileHelper.writeFile(
-                  path.join(versionedEntryPath, 'version-' + versionedEntry._version + '.json'),
-                  versionedEntry,
-                );
-              await executeTask(versionedEntries, write.bind(this), { concurrency: this.writeConcurrency });
-              addlogs(
-                this.exportConfig,
-                `Exported versioned entries of type '${requestOption.content_type}' locale '${requestOption.locale}'`,
-                'success',
-              );
-            }
-          }
-        }
-      }
-      addlogs(this.exportConfig, chalk.green('Entries exported successfully'), 'success');
-    } catch (error) {
-      addlogs(this.exportConfig, `Failed to export entries ${formatError(error)}`, 'error');
-      throw new Error('Failed to export entries');
-    }
-  }
-
-  async getEntries(requestOptions, skip = 0, entries = {}) {
-    let requestObject = {
-      locale: requestOptions.locale,
-      skip,
-      limit: this.entriesConfig.limit,
-      include_count: true,
-      include_publish_details: true,
-      query: {
-        locale: requestOptions.locale,
-      },
-    };
-
-    const entriesSearchResponse = await this.stackAPIClient
-      .contentType(requestOptions.content_type)
-      .entry()
-      .query(requestObject)
-      .find();
-
-    if (Array.isArray(entriesSearchResponse.items) && entriesSearchResponse.items.length > 0) {
-      // clean up attribs and add to parent entry list
-      this.sanitizeAttribs(entriesSearchResponse.items, entries);
-      skip += this.entriesConfig.limit || 100;
-      if (skip > entriesSearchResponse.count) {
-        return entries;
-      }
-      return await this.getEntries(requestOptions, skip, entries);
-    }
-    return entries;
-  }
-
-  async getEntryByVersion(requestOptions, version, entries = []) {
-    const queryRequestObject = {
-      locale: requestOptions.locale,
-      except: {
-        BASE: this.entriesConfig.invalidKeys,
-      },
-      version,
-    };
-    const entryResponse = await this.stackAPIClient
-      .contentType(requestOptions.content_type)
-      .entry(requestOptions.uid)
-      .fetch(queryRequestObject);
-    entries.push(entryResponse);
-    if (--version > 0) {
-      return await this.getEntryByVersion(requestOptions, version, entries);
-    }
-    return entries;
-  }
-
-  async getEntriesCount(requestOptions) {
-    let requestObject = {
-      locale: requestOptions.locale,
-      limit: 1,
-      include_count: true,
-      include_publish_details: true,
-      query: {
-        locale: requestOptions.locale,
-      },
-    };
-
-    const entriesSearchResponse = await this.stackAPIClient
-      .contentType(requestOptions.content_type)
-      .entry()
-      .query(requestObject)
-      .find();
-
-    return entriesSearchResponse.count;
-  }
-
-  createRequestObjects(locales, contentTypes) {
-    let requestObjects = [];
-    contentTypes.forEach((contentType) => {
-      if (Object.keys(locales).length !== 0) {
-        for (let locale in locales) {
-          requestObjects.push({
-            content_type: contentType.uid,
-            locale: locales[locale].code,
-          });
-        }
-      }
-      requestObjects.push({
-        content_type: contentType.uid,
-        locale: this.exportConfig.master_locale.code,
-      });
-    });
-
-    return requestObjects;
-  }
-
-  sanitizeAttribs(entries, entriesList = {}) {
-    entries.forEach((entry) => {
-      this.entriesConfig.invalidKeys.forEach((key) => delete entry[key]);
-      entriesList[entry.uid] = entry;
-    });
-    return entriesList;
-  }
-}
-
-module.exports = EntriesExport;

package/src/lib/export/environments.js

@@ -1,74 +0,0 @@
-/*!
- * Contentstack Export
- * Copyright (c) 2019 Contentstack LLC
- * MIT Licensed
- */
-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');
-
-module.exports = class ExportEnvironments {
-  config = {};
-  master = {};
-  environments = {};
-  requestOptions = {
-    json: true,
-    qs: {
-      asc: 'updated_at',
-      include_count: true,
-    },
-  };
-
-  constructor(exportConfig, stackAPIClient) {
-    this.config = merge(this.config, exportConfig);
-    this.stackAPIClient = stackAPIClient;
-  }
-
-  start() {
-    const self = this;
-    const environmentConfig = self.config.modules.environments;
-    const environmentsFolderPath = path.resolve(
-      self.config.data,
-      self.config.branchName || '',
-      environmentConfig.dirName,
-    );
-
-    // Create folder for environments
-    mkdirp.sync(environmentsFolderPath);
-    addlogs(self.config, 'Starting environment export', 'success');
-
-    return new Promise((resolve, reject) => {
-      self.stackAPIClient
-        .environment()
-        .query(self.requestOptions.qs)
-        .find()
-        .then((environmentResponse) => {
-          if (environmentResponse.items.length !== 0) {
-            for (let i = 0, total = environmentResponse.count; i < total; i++) {
-              const envUid = environmentResponse.items[i].uid;
-              self.master[envUid] = '';
-              self.environments[envUid] = environmentResponse.items[i];
-              delete self.environments[envUid].uid;
-              delete self.environments[envUid]['ACL'];
-            }
-            helper.writeFileSync(path.join(environmentsFolderPath, environmentConfig.fileName), self.environments);
-            addlogs(self.config, chalk.green('All the environments have been exported successfully'), 'success');
-            return resolve();
-          }
-          if (environmentResponse.items.length === 0) {
-            addlogs(self.config, 'No environments found', 'success');
-            resolve();
-          }
-        })
-        .catch((error) => {
-          addlogs(self.config, `Environments export failed. ${formatError(error)}`, 'error');
-          reject(error);
-        });
-    });
-  }
-};

package/src/lib/export/extensions.js

@@ -1,69 +0,0 @@
-/*!
- * Contentstack Export
- * Copyright (c) 2019 Contentstack LLC
- * MIT Licensed
- */
-
-const mkdirp = require('mkdirp');
-const path = require('path');
-const chalk = require('chalk');
-const { merge } = require('lodash');
-
-const helper = require('../util/helper');
-const { addlogs } = require('../util/log');
-const { formatError } = require('../util');
-let config = require('../../config/default');
-
-module.exports = class ExportExtensions {
-  master = {};
-  extensions = {};
-  extensionConfig = config.modules.extensions;
-  queryRequestOptions = {
-    asc: 'updated_at',
-    include_count: true,
-  };
-
-  constructor(exportConfig, stackAPIClient) {
-    this.config = merge(config, exportConfig);
-    this.stackAPIClient = stackAPIClient;
-  }
-
-  start() {
-    addlogs(this.config, 'Starting extension export', 'success');
-
-    const self = this;
-    const extensionsFolderPath = path.resolve(
-      this.config.data,
-      this.config.branchName || '',
-      this.extensionConfig.dirName,
-    );
-    // Create folder for extensions
-    mkdirp.sync(extensionsFolderPath);
-    return new Promise(function (resolve, reject) {
-      self.stackAPIClient
-        .extension()
-        .query(self.queryRequestOptions)
-        .find()
-        .then((extension) => {
-          if (extension.items.length !== 0) {
-            for (let i = 0, total = extension.count; i < total; i++) {
-              const extUid = extension.items[i].uid;
-              self.master[extUid] = '';
-              self.extensions[extUid] = extension.items[i];
-              delete self.extensions[extUid].uid;
-              delete self.extensions[extUid].SYS_ACL;
-            }
-            helper.writeFileSync(path.join(extensionsFolderPath, self.extensionConfig.fileName), self.extensions);
-            addlogs(self.config, chalk.green('All the extensions have been exported successfully'), 'success');
-            return resolve();
-          }
-          addlogs(self.config, 'No extensions found', 'success');
-          resolve();
-        })
-        .catch((error) => {
-          addlogs(self.config, `Failed to export extensions. ${formatError(error)}`, 'error');
-          reject();
-        });
-    });
-  }
-};

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

@@ -1,122 +0,0 @@
-/*!
- * Contentstack Export
- * Copyright (c) 2019 Contentstack LLC
- * MIT Licensed
- */
-
-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');
-let config = require('../../config/default');
-
-module.exports = class ExportGlobalFields {
-  limit = 100;
-  config = {};
-  global_fields = [];
-  master = {};
-  globalfields = {};
-  requestOptions = {};
-  globalfieldsFolderPath;
-  globalfieldsConfig = config.modules.globalfields;
-  validKeys = config.modules.globalfields.validKeys;
-
-  constructor(exportConfig, stackAPIClient) {
-    this.requestOptions = {
-      qs: {
-        skip: 0,
-        limit: this.limit,
-        asc: 'updated_at',
-        include_count: true,
-      },
-    };
-    this.config = merge(config, exportConfig);
-    this.stackAPIClient = stackAPIClient;
-    this.globalfieldsFolderPath = path.resolve(
-      this.config.data,
-      this.config.branchName || '',
-      this.globalfieldsConfig.dirName,
-    );
-  }
-
-  start() {
-    const self = this;
-    // Create folder for Global Fields
-    mkdirp.sync(self.globalfieldsFolderPath);
-    addlogs(self.config, 'Starting Global Fields export', 'success');
-
-    return new Promise(function (resolve, reject) {
-      try {
-        return self
-          .getGlobalFields(0, self.config)
-          .then(function (result) {
-            if (!result) {
-              return self.writeGlobalFields().then(resolve).catch(reject);
-            }
-            return resolve();
-          })
-          .catch(reject);
-      } catch (error) {
-        addlogs(self.config, error, 'error');
-        return reject(error);
-      }
-    });
-  }
-
-  getGlobalFields(skip, globalFieldConfig) {
-    const self = this;
-    self.requestOptions.qs.skip = skip;
-    return new Promise(function (resolve, reject) {
-      self.stackAPIClient
-        .globalField()
-        .query(self.requestOptions.qs)
-        .find()
-        .then((globalFieldResponse) => {
-          try {
-            if (globalFieldResponse.items.length === 0) {
-              addlogs(globalFieldConfig, 'No global fields found', 'success');
-              return resolve('No Global Fields');
-            }
-            globalFieldResponse.items.forEach(function (globalField) {
-              for (const key in globalField) {
-                if (self.validKeys.indexOf(key) === -1) {
-                  delete globalField[key];
-                }
-              }
-              self.global_fields.push(globalField);
-            });
-            skip += self.limit;
-            if (skip >= globalFieldResponse.count) {
-              return resolve();
-            }
-            return self.getGlobalFields(skip, globalFieldConfig).then(resolve).catch(reject);
-          } catch (error) {
-            addlogs(globalFieldConfig, `Failed to export global-fields. ${formatError(error)}`, 'error');
-            reject(error);
-          }
-        })
-        .catch(reject);
-    });
-  }
-
-  writeGlobalFields() {
-    const self = this;
-    return new Promise(function (resolve, reject) {
-      try {
-        helper.writeFileSync(
-          path.join(self.globalfieldsFolderPath, self.globalfieldsConfig.fileName),
-          self.global_fields,
-        );
-        addlogs(self.config, chalk.green('Global Fields export completed successfully'), 'success');
-        resolve();
-      } catch (error) {
-        addlogs(self.config, error, 'error');
-        reject(error);
-      }
-    });
-  }
-};

package/src/lib/export/labels.js

@@ -1,67 +0,0 @@
-/*!
- * Contentstack Export
- * Copyright (c) 2019 Contentstack LLC
- * MIT Licensed
- */
-
-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');
-
-module.exports = class ExportLabels {
-  labels = {};
-  labelConfig = config.modules.labels;
-
-  constructor(exportConfig, stackAPIClient) {
-    this.config = merge(config, exportConfig);
-    this.stackAPIClient = stackAPIClient;
-  }
-
-  start() {
-    addlogs(this.config, 'Starting labels export', 'success');
-    const self = this;
-    const labelsFolderPath = path.resolve(config.data, this.config.branchName || '', self.labelConfig.dirName);
-    // Create locale folder
-    mkdirp.sync(labelsFolderPath);
-    return new Promise(function (resolve, reject) {
-      return self.stackAPIClient
-        .label()
-        .query()
-        .find()
-        .then((response) => {
-          if (response.items.length !== 0) {
-            response.items.forEach(function (label) {
-              addlogs(self.config, `'${label.name}' label was exported successfully`, 'success');
-              self.labels[label.uid] = label;
-              const deleteItems = self.config.modules.labels.invalidKeys;
-              deleteItems.forEach((e) => delete label[e]);
-            });
-            addlogs(self.config, chalk.green('All the labels have been exported successfully'), 'success');
-          } else {
-            addlogs(self.config, 'No labels found', 'success');
-          }
-          helper.writeFileSync(path.join(labelsFolderPath, self.labelConfig.fileName), self.labels);
-          resolve();
-        })
-        .catch(function (error) {
-          if (error.statusCode === 401) {
-            addlogs(
-              self.config,
-              'You are not allowed to export label, Unless you provide email and password in config',
-              'error'
-            );
-            return resolve();
-          }
-
-          addlogs(self.config,  `Failed to export labels. ${formatError(error)}`, 'error');
-          reject();
-        });
-    });
-  }
-};

package/src/lib/export/locales.js

@@ -1,72 +0,0 @@
-const path = require('path');
-const chalk = require('chalk');
-const fileHelper = require('../util/helper');
-const { addlogs } = require('../util/log');
-const { formatError } = require('../util');
-class LocaleExport {
-  constructor(exportConfig, stackAPIClient) {
-    this.stackAPIClient = stackAPIClient;
-    this.exportConfig = exportConfig;
-    this.localeConfig = exportConfig.modules.locales;
-    this.masterLocaleConfig = exportConfig.modules.masterLocale;
-    this.qs = {
-      include_count: true,
-      asc: 'updated_at',
-      only: {
-        BASE: this.localeConfig.requiredKeys,
-      },
-    };
-
-    this.localesPath = path.resolve(exportConfig.data, exportConfig.branchName || '', this.localeConfig.dirName);
-    this.locales = {};
-    this.masterLocale = {};
-    this.fetchConcurrency = this.localeConfig.fetchConcurrency || this.exportConfig.fetchConcurrency;
-    this.writeConcurrency = this.localeConfig.writeConcurrency || this.exportConfig.writeConcurrency;
-  }
-
-  async start() {
-    try {
-      addlogs(this.exportConfig, 'Starting locale export', 'success');
-      await fileHelper.makeDirectory(this.localesPath);
-      await this.getLocales();
-      await fileHelper.writeFile(path.join(this.localesPath, this.localeConfig.fileName), this.locales);
-      await fileHelper.writeFile(path.join(this.localesPath, this.masterLocaleConfig.fileName), this.masterLocale);
-      addlogs(this.exportConfig, 'Completed locale export', 'success');
-    } catch (error) {
-      addlogs(this.exportConfig, `Failed to export locales. ${formatError(error)}`, 'error');
-      throw new Error('Failed to export locales');
-    }
-  }
-
-  async getLocales(skip = 0) {
-    if (skip) {
-      this.qs.skip = skip;
-    }
-    let localesFetchResponse = await this.stackAPIClient.locale().query(this.qs).find();
-    if (Array.isArray(localesFetchResponse.items) && localesFetchResponse.items.length > 0) {
-      this.sanitizeAttribs(localesFetchResponse.items);
-      skip += this.localeConfig.limit || 100;
-      if (skip > localesFetchResponse.count) {
-        return;
-      }
-      return await this.getLocales(skip);
-    }
-  }
-
-  sanitizeAttribs(locales) {
-    locales.forEach((locale) => {
-      for (let key in locale) {
-        if (this.localeConfig.requiredKeys.indexOf(key) === -1) {
-          delete locale[key];
-        }
-      }
-      if(locale.code === this.exportConfig.master_locale.code){
-        this.masterLocale[locale.uid] = locale;
-      }else{
-        this.locales[locale.uid] = locale;
-      }
-    });
-  }
-}
-
-module.exports = LocaleExport;