@contentstack/cli-cm-export 0.1.0-beta → 0.1.1-beta.11

package/src/lib/export/assets.js

@@ -37,9 +37,13 @@ function ExportAssets() {
 
 ExportAssets.prototype = {
   start: function (credentialConfig) {
+    this.assetContents = {}
+    this.folderData = []
+    this.assetDownloadRetry = {};
+    this.assetDownloadRetryLimit = 3;
     let  self = this
     config = credentialConfig
-    assetsFolderPath = path.resolve(config.data, assetConfig.dirName)
+    assetsFolderPath = path.resolve(config.data, (config.branchName || ""), assetConfig.dirName)
     assetContentsFile = path.resolve(assetsFolderPath, 'assets.json')
     folderJSONPath = path.resolve(assetsFolderPath, 'folders.json')
     client = stack.Client(config)
@@ -48,9 +52,10 @@ ExportAssets.prototype = {
     // Create asset folder
     mkdirp.sync(assetsFolderPath)
     return new Promise(function (resolve, reject) {
+      //TBD: getting all the assets should have optimized
       return self.getAssetCount().then(function (count) {
         if (typeof count !== 'number' || count === 0) {
-          addlogs(config, 'There were no assets to be download', 'success')
+          addlogs(config, 'No assets found', 'success')
           return resolve()
         }
         const assetBatches = []
@@ -66,9 +71,9 @@ ExportAssets.prototype = {
                   // log.success(chalk.white('The following asset has been downloaded successfully: ' +
                   //     assetJSON.uid))
                 }).catch(function (error) {
-                addlogs(self.configchalk.red('The following asset failed to download\n' + JSON.stringify(
+                  addlogs(config, chalk.red('The following asset failed to download\n' + JSON.stringify(
                   assetJSON)))
-                addlogs(config, error, 'error')
+                  addlogs(config, error, 'error')
               })
             }, {
               concurrency: vLimit,
@@ -157,7 +162,6 @@ ExportAssets.prototype = {
     })
   },
   getAssetCount: function (folder) {
-    let self = this
     return new Promise(function (resolve, reject) {
       if (folder && typeof folder === 'boolean') {
         let queryOptions = {include_folders: true, query: {'is_dir': true}, include_count: true}
@@ -182,7 +186,6 @@ ExportAssets.prototype = {
     })
   },
   getAssetJSON: function (skip) {
-    let  self = this
     return new Promise(function (resolve, reject) {
       if (typeof skip !== 'number') {
         skip = 0
@@ -209,6 +212,10 @@ ExportAssets.prototype = {
     let self = this
     let assetVersionInfo = bucket || []
     return new Promise(function (resolve, reject) {
+      if (self.assetDownloadRetry[uid + version] > self.assetDownloadRetryLimit) {
+        return reject(new Error('Asset Max download retry limit exceeded! ' + uid));
+      }
+
       if (version <= 0) {
         const assetVersionInfoFile = path.resolve(assetsFolderPath, uid, '_contentstack_' + uid + '.json')
         helper.writeFile(assetVersionInfoFile, assetVersionInfo)
@@ -230,8 +237,17 @@ ExportAssets.prototype = {
           assetVersionInfo = _.uniqWith(assetVersionInfo, _.isEqual)
           self.getVersionedAssetJSON(uid, --version, assetVersionInfo)
           .then(resolve)
-          .catch(reject)
+            .catch(reject)
         }).catch(reject)
+      }).catch((error) => {
+        if (error.status === 408) {
+          // retrying when timeout
+          (self.assetDownloadRetry[uid+version] ? ++self.assetDownloadRetry[uid+version] : self.assetDownloadRetry[uid+version] = 1 ) 
+          return self.getVersionedAssetJSON(uid, version, assetVersionInfo)
+          .then(resolve)
+            .catch(reject) 
+        }
+        reject(error);
       })
     })
   },
@@ -246,9 +262,12 @@ ExportAssets.prototype = {
         return resolve()
       }
       self.assetStream = {
-        url: asset.url,
-      }
+        url: config.securedAssets
+          ? `${asset.url}?authtoken=${config.authtoken || config.auth_token}`
+          : asset.url,
+      };
 
+      self.assetStream.url = encodeURI(self.assetStream.url);
       const assetStreamRequest = nativeRequest(self.assetStream)
       assetStreamRequest.on('response', function () {
         helper.makeDirectory(assetFolderPath)

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

@@ -35,10 +35,16 @@ function ExportContentTypes() {
 
 ExportContentTypes.prototype = {
   start: function (credentialConfig) {
+    this.content_types = []
     let self = this
     config = credentialConfig
-    contentTypesFolderPath = path.resolve(config.data, contentTypeConfig.dirName)
+    contentTypesFolderPath = path.resolve(config.data, (config.branchName || ""), contentTypeConfig.dirName)
+
     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}
+    }
     // Create folder for content types
     mkdirp.sync(contentTypesFolderPath)
     addlogs(config, 'Starting content type export', 'success')
@@ -97,7 +103,7 @@ ExportContentTypes.prototype = {
         helper.writeFile(path.join(contentTypesFolderPath, content_type.uid + '.json'),
           content_type)
       })
-      addlogs(config, chalk.green('Content type export completed successfully'), 'success')
+      addlogs(config, chalk.green('Content type(s) exported successfully'), 'success')
       return resolve()
     })
   },

package/src/lib/export/entries.js

@@ -42,9 +42,9 @@ function exportEntries() {
 exportEntries.prototype.start = function (credentialConfig) {
   let self = this
   config = credentialConfig
-  entryFolderPath = path.resolve(config.data, config.modules.entries.dirName)
-  localesFilePath = path.resolve(config.data, config.modules.locales.dirName, config.modules.locales.fileName)
-  schemaFilePath = path.resolve(config.data,  config.modules.content_types.dirName, 'schema.json')
+  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) {
@@ -130,7 +130,7 @@ exportEntries.prototype.getEntries = function (apiDetails) {
       },
     }
     client.stack({api_key: config.source_stack, management_token: config.management_token}).contentType(apiDetails.content_type).entry().query(queryrequestObject).find()
-    .then(entriesList => {
+      .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))
@@ -179,9 +179,9 @@ exportEntries.prototype.getEntries = function (apiDetails) {
           })
         })
       }
-      if (apiDetails.skip > entriesList.items.length) {
-        addlogs(config, 'Completed exporting ' + apiDetails.content_type +
-            ' content type\'s entries in ' + apiDetails.locale + ' locale', 'success')
+      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

package/src/lib/export/environments.js

@@ -26,11 +26,13 @@ function ExportEnvironments() {
 }
 
 ExportEnvironments.prototype.start = function (mergConfig) {
+  this.master = {}
+  this.environments = {}
   let self = this
   config = mergConfig
   addlogs(config, 'Starting environment export', 'success')
   const environmentConfig = config.modules.environments
-  const environmentsFolderPath = path.resolve(config.data, environmentConfig.dirName)
+  const environmentsFolderPath = path.resolve(config.data, (config.branchName || ""), environmentConfig.dirName)
   // Create folder for environments
   mkdirp.sync(environmentsFolderPath)
   let client = stack.Client(config)
@@ -50,7 +52,7 @@ ExportEnvironments.prototype.start = function (mergConfig) {
         return resolve()
       }
       if (environmentResponse.items.length === 0) {
-        addlogs(config, 'No environments were found in the Stack', 'success')
+        addlogs(config, 'No environments found', 'success')
         return resolve()
       }
     }).catch(error => {

package/src/lib/export/extensions.js

@@ -25,10 +25,12 @@ function ExportExtensions() {
 }
 
 ExportExtensions.prototype.start = function (mergeConfig) {
+  this.master = {}
+  this.extensions = {}
   addlogs(config, 'Starting extension export', 'success')
   let self = this
   config = mergeConfig
-  let extensionsFolderPath = path.resolve(config.data, extensionConfig.dirName)
+  let extensionsFolderPath = path.resolve(config.data, (config.branchName || ""), extensionConfig.dirName)
   // Create folder for extensions
   mkdirp.sync(extensionsFolderPath)
   let client = stack.Client(config)
@@ -47,7 +49,7 @@ ExportExtensions.prototype.start = function (mergeConfig) {
         addlogs(config, chalk.green('All the extensions have been exported successfully'), 'success')
         return resolve()
       }
-      addlogs(config, chalk.white('No extensions were found in the Stack'))
+      addlogs(config, 'No extensions found', 'success')
       return resolve()
     }).catch(error => {
       addlogs(config, error, 'error')

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

@@ -1,113 +1,139 @@
 /*!
-* Contentstack Export
-* Copyright (c) 2019 Contentstack LLC
-* MIT Licensed
-*/
+ * Contentstack Export
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
 
-const mkdirp = require('mkdirp')
-const path = require('path')
-const chalk = require('chalk')
+const mkdirp = require("mkdirp");
+const path = require("path");
+const chalk = require("chalk");
 
-const stack = require('../util/contentstack-management-sdk')
-const helper = require('../util/helper')
-const {addlogs} = require('../util/log')
-
-let config = require('../../config/default')
-const globalfieldsConfig = config.modules.globalfields
-const globalfieldsFolderPath = path.resolve(config.data, globalfieldsConfig.dirName)
-const validKeys = globalfieldsConfig.validKeys
-const limit = 100
-
-// Create folder for Global Fields
-mkdirp.sync(globalfieldsFolderPath)
+const stack = require("../util/contentstack-management-sdk");
+const helper = require("../util/helper");
+const { addlogs } = require("../util/log");
 
+let config = require("../../config/default");
+const limit = 100;
+const validKeys = config.modules.globalfields.validKeys;
+let globalfieldsFolderPath;
+const globalfieldsConfig = config.modules.globalfields;
 function ExportGlobalFields() {
-  this.global_fields = []
+  this.global_fields = [];
   this.requestOptions = {
     qs: {
       include_count: true,
-      asc: 'updated_at',
+      asc: "updated_at",
       limit: limit,
     },
-  }
-  this.master = {}
-  this.globalfields = {}
+  };
+  this.master = {};
+  this.globalfields = {};
 }
 
 ExportGlobalFields.prototype = {
   start: function (credentialConfig) {
-    const self = this
-    config = credentialConfig
-    addlogs(config, 'Starting Global Fields export', 'success')
+    this.master = {};
+    this.globalfields = {};
+    config = {...config, ...credentialConfig};
+    globalfieldsFolderPath = path.resolve(
+      config.data,
+      (config.branchName || ""),
+      globalfieldsConfig.dirName
+    );
+    // Create folder for Global Fields
+    mkdirp.sync(globalfieldsFolderPath);
+    const self = this;
+    addlogs(config, "Starting Global Fields export", "success");
     return new Promise(function (resolve, reject) {
       try {
-        return self.getGlobalFields(null, config).then(function (result) {
-          if (!result) {
-            return self.writeGlobalFields().then(result => {
-              return resolve()
-            }).catch(error => {
-              return reject(error)
-            })
-          }
-          return resolve()
-        }).catch(error => {
-          return reject(error)
-        })
+        return self
+          .getGlobalFields(null, config)
+          .then(function (result) {
+            if (!result) {
+              return self
+                .writeGlobalFields()
+                .then(() => {
+                  return resolve();
+                })
+                .catch((error) => {
+                  return reject(error);
+                });
+            }
+            return resolve();
+          })
+          .catch((error) => {
+            return reject(error);
+          });
       } catch (error) {
-        return reject(error)
+        return reject(error);
       }
-    })
+    });
   },
-  getGlobalFields: function (skip, config) {
-    const self = this
-    if (typeof skip !== 'number') {
-      skip = 0
-      self.requestOptions.qs.skip = skip
+  getGlobalFields: function (skip, globalFieldConfig) {
+    const self = this;
+    if (typeof skip !== "number") {
+      skip = 0;
+      self.requestOptions.qs.skip = skip;
     } else {
-      self.requestOptions.qs.skip = skip
+      self.requestOptions.qs.skip = skip;
     }
-    
-    let client = stack.Client(config)
+
+    let client = stack.Client(globalFieldConfig);
     return new Promise(function (resolve, reject) {
-      client.stack({api_key: config.source_stack, management_token: config.management_token}).globalField().query(self.requestOptions.qs).find()
-      .then(globalFieldResponse => {
-        try {
-          if (globalFieldResponse.items.length === 0) {
-            addlogs(config, 'No Global Fields were found in the Stack', 'success')
-            return resolve('No Global Fields')
-          }
-          globalFieldResponse.items.forEach(function (globalField) {
-            for (const key in globalField) {
-              if (validKeys.indexOf(key) === -1) {
-                delete globalField[key]
-              }
+      client
+        .stack({
+          api_key: globalFieldConfig.source_stack,
+          management_token: globalFieldConfig.management_token,
+        })
+        .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");
             }
-            self.global_fields.push(globalField)
-          })
+            globalFieldResponse.items.forEach(function (globalField) {
+              for (const key in globalField) {
+                if (validKeys.indexOf(key) === -1) {
+                  delete globalField[key];
+                }
+              }
+              self.global_fields.push(globalField);
+            });
 
-          skip += limit
+            skip += limit;
 
-          if (skip > globalFieldResponse.count) {
-            return resolve()
-          }
+            if (skip > globalFieldResponse.count) {
+              return resolve();
+            }
 
-          return self.getGlobalFields(skip, config)
-          .then(resolve)
-          .catch(reject)
-        } catch (error) {
-          return reject(error)
-        }
-      })
-    })
+            return self
+              .getGlobalFields(skip, globalFieldConfig)
+              .then(resolve)
+              .catch(reject);
+          } catch (error) {
+            return reject(error);
+          }
+        });
+    });
   },
   writeGlobalFields: function () {
-    const self = this
+    const self = this;
     return new Promise(function (resolve) {
-      helper.writeFile(path.join(globalfieldsFolderPath, globalfieldsConfig.fileName), self.global_fields)
-      addlogs(config, chalk.green('Global Fields export completed successfully'), 'success')
-      return resolve()
-    })
+      helper.writeFile(
+        path.join(globalfieldsFolderPath, globalfieldsConfig.fileName),
+        self.global_fields
+      );
+      addlogs(
+        config,
+        chalk.green("Global Fields export completed successfully"),
+        "success"
+      );
+      return resolve();
+    });
   },
-}
+};
 
-module.exports = new ExportGlobalFields()
+module.exports = new ExportGlobalFields();

package/src/lib/export/labels.js

@@ -28,10 +28,11 @@ function ExportLabels() {
 
 ExportLabels.prototype.start = function (credentialConfig) {
   addlogs(config, 'Starting labels export', 'success')
+  this.labels = {}
   let self = this
   config = credentialConfig
   client = stack.Client(config)
-  let labelsFolderPath = path.resolve(config.data, labelConfig.dirName)
+  let labelsFolderPath = path.resolve(config.data, (config.branchName || ""), labelConfig.dirName)
   // Create locale folder
   mkdirp.sync(labelsFolderPath)
   return new Promise(function (resolve, reject) {
@@ -39,13 +40,14 @@ ExportLabels.prototype.start = function (credentialConfig) {
     .then((response) => {
       if (response.items.length !== 0) {
         response.items.forEach(function (label) {
-          delete label['stackHeaders']
-          addlogs(config, chalk.white(label.name + ' labels was exported successfully'), 'success')
+          addlogs(config, label.name + ' labels was exported successfully', 'success')
           self.labels[label.uid] = label
+          let deleteItems = config.modules.labels.invalidKeys 
+          deleteItems.forEach(e => delete label[e])
         })
         addlogs(config, chalk.green('All the labels have been exported successfully'), 'success')
       } else {
-        addlogs(config, 'No labels, other than master-labels were found in the Stack', 'success')
+        addlogs(config, 'No labels found', 'success')
       }
       helper.writeFile(path.join(labelsFolderPath, labelConfig.fileName), self.labels)
       return resolve()

package/src/lib/export/locales.js

@@ -16,6 +16,7 @@ const masterLocale = config.master_locale
 let requiredKeys = localeConfig.requiredKeys
 let stack = require('../util/contentstack-management-sdk')
 
+
 function ExportLocales() {
   this.qs = {
     include_count: true,
@@ -33,10 +34,11 @@ function ExportLocales() {
 }
 
 ExportLocales.prototype.start = function (credentialConfig) {
+  this.locales = {}
   addlogs(credentialConfig, 'Starting locale export', 'success')
   let self = this
   config = credentialConfig
-  let localesFolderPath = path.resolve(config.data, localeConfig.dirName)
+  let localesFolderPath = path.resolve(config.data, (config.branchName || ""), localeConfig.dirName)
   mkdirp.sync(localesFolderPath)
 
   let client = stack.Client(config)
@@ -45,23 +47,23 @@ ExportLocales.prototype.start = function (credentialConfig) {
     .then(localeResponse => {
       if (localeResponse.items.length !== 0) {
         localeResponse.items.forEach(function (locale) {
-          addlogs(credentialConfig, 'locale was exported successfully', 'success')
+          addlogs(credentialConfig, locale.name + ' locale was exported successfully', 'success')
           for (const key in locale) {
             if (requiredKeys.indexOf(key) === -1) {
-              delete locale.key
+              delete locale[key]
             }
           }
           self.locales[locale.uid] = locale
         })
         addlogs(credentialConfig, chalk.green('All the locales have been exported successfully'), 'success')
       } else if (localeResponse.items.length === 0) {
-        addlogs(credentialConfig, 'No locales, other than master-locale were found in the Stack', 'success')
+        addlogs(credentialConfig, 'No languages found except the master language', 'success')
       }
       helper.writeFile(path.join(localesFolderPath, localeConfig.fileName), self.locales)
-      resolve()
+      return resolve()
     }).catch(error => {
       addlogs(credentialConfig, error, 'error')
-      reject()
+      return reject()
     })
   })
 }

package/src/lib/export/stack.js

@@ -8,10 +8,11 @@ var chalk = require('chalk')
 var mkdirp = require('mkdirp')
 var path = require('path')
 
-var request = require('../util/request')
 var app = require('../../app')
 var helper = require('../util/helper')
 var {addlogs} = require('../util/log')
+const stack = require('../util/contentstack-management-sdk')
+
 
 let config = require('../../config/default')
 
@@ -28,22 +29,39 @@ function ExportStack () {
 
 ExportStack.prototype.start = function (credentialConfig) {
   config = credentialConfig
-  addlogs(config, 'Exporting stack details', 'success')
-  let stackFolderPath = path.resolve(config.data, stackConfig.dirName)
-  let stackContentsFile = path.resolve(stackFolderPath, stackConfig.fileName)
-
-  // Create asset folder
-  mkdirp.sync(stackFolderPath)
-
-  return new Promise((resolve, reject) => {
-    return client.stack({api_key: config.source_stack}).fetch()
-    .then(response => {
-      helper.writeFile(stackContentsFile, response)
-      addlogs(config, 'Exported stack details successfully!', 'success')
-      return resolve()
+  client = stack.Client(config)
+  if (!config.preserveStackVersion && !config.hasOwnProperty("master_locale")) {
+    return new Promise((resolve, reject) => {
+    var result =  client.stack({ api_key: credentialConfig.source_stack, management_token: credentialConfig.management_token }).locale().query()     
+    result.find()
+      .then(response => {
+        var masterLocalObj = response.items.filter(obj => {
+            if (obj.fallback_locale === null) {
+              return obj
+            }
+            });
+        return resolve(masterLocalObj[0])
+      }).catch(error => {
+        return reject(error)
+      })
+    })
+  } else if(config.preserveStackVersion) {
+    addlogs(config, 'Exporting stack details', 'success')
+    let stackFolderPath = path.resolve(config.data, stackConfig.dirName)
+    let stackContentsFile = path.resolve(stackFolderPath, stackConfig.fileName)
+  
+    mkdirp.sync(stackFolderPath)
+  
+    return new Promise((resolve, reject) => {
+      return client.stack({api_key: config.source_stack}).fetch()
+      .then(response => {
+        helper.writeFile(stackContentsFile, response)
+        addlogs(config, 'Exported stack details successfully!', 'success')
+        return resolve(response)
+      })
+      .catch(reject)
     })
-    .catch(reject)
-  })
+  }
 }
 
 module.exports = new ExportStack()

package/src/lib/export/webhooks.js

@@ -29,10 +29,12 @@ function ExportWebhooks() {
 
 ExportWebhooks.prototype.start = function (credentialConfig) {
   addlogs(config, 'Starting webhooks export', 'success')
+  this.master = {}
+  this.webhooks = {}
   let self = this
   config = credentialConfig
   client = stack.Client(config)
-  const webhooksFolderPath = path.resolve(config.data, webhooksConfig.dirName)
+  const webhooksFolderPath = path.resolve(config.data, (config.branchName || ""), webhooksConfig.dirName)
   mkdirp.sync(webhooksFolderPath)
   return new Promise(function (resolve, reject) {
     client.stack({api_key: config.source_stack, management_token: config.management_token}).webhook().fetchAll(self.requestOptions)
@@ -49,7 +51,7 @@ ExportWebhooks.prototype.start = function (credentialConfig) {
         addlogs(config, chalk.green('All the webhooks have been exported successfully'), 'success')
         return resolve()
       }
-      addlogs(config, 'No webhooks were found in the Stack', 'success')
+      addlogs(config, 'No webhooks found', 'success')
       return resolve()
     }).catch(function (error) {
       if (error.statusCode === 401) {

package/src/lib/export/workflows.js

@@ -0,0 +1,60 @@
+/*!
+ * Contentstack Export
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+
+const mkdirp = require('mkdirp')
+const path = require('path')
+const chalk = require('chalk')
+
+let helper = require('../util/helper')
+let {addlogs} = require('../util/log')
+
+const stack = require('../util/contentstack-management-sdk')
+let config = require('../../config/default')
+let workFlowConfig = config.modules.workflows
+let client
+
+function ExportWorkFlows() {
+  this.workflows = {}
+}
+
+ExportWorkFlows.prototype.start = function (credentialConfig) {
+  addlogs(config, 'Starting workflow export', 'success')
+  this.workflows = {}
+  let self = this
+  config = credentialConfig
+  client = stack.Client(config)
+
+  let workflowsFolderPath = path.resolve(config.data, (config.branchName || ""), workFlowConfig.dirName)
+  mkdirp.sync(workflowsFolderPath)
+  return new Promise(function (resolve, reject) {
+    return client.stack({api_key: config.source_stack, management_token: config.management_token}).workflow().fetchAll()
+    .then(response => {
+      if (response.items.length !== 0) {
+        response.items.forEach(function (workflow) {
+          addlogs(config, workflow.name + ' workflow was exported successfully', 'success')
+          self.workflows[workflow.uid] = workflow
+          let deleteItems = config.modules.workflows.invalidKeys
+          deleteItems.forEach(e => delete workflow[e])
+        })
+        addlogs(config, chalk.green('All the workflow have been exported successfully'), 'success')
+      }
+      if (response.items.length === 0) {
+        addlogs(config, 'No workflow were found in the Stack', 'success')
+      }
+      helper.writeFile(path.join(workflowsFolderPath, workFlowConfig.fileName), self.workflows)
+      return resolve()
+    }).catch(function (error) {
+      if (error.statusCode === 401) {
+        addlogs(config, chalk.red('You are not allowed to export workflow, Unless you provide email and password in config', 'error'))
+        return resolve()
+      } 
+      addlogs(config, error, 'error')
+      return resolve()
+    })
+  })
+}
+
+module.exports = new ExportWorkFlows()