@contentstack/cli-cm-import 1.2.4 → 1.4.0

package/src/lib/import/entries.js

@@ -3,6 +3,7 @@
  * Copyright (c) 2019 Contentstack LLC
  * MIT Licensed
  */
+
 const Promise = require('bluebird');
 const fs = require('fs');
 const path = require('path');
@@ -14,119 +15,111 @@ const util = require('../util');
 const helper = require('../util/fs');
 const { addlogs } = require('../util/log');
 const suppress = require('../util/supress-mandatory-fields');
-const stack = require('../util/contentstack-management-sdk');
 const extension_suppress = require('../util/extensionsUidReplace');
 const lookupReplaceAssets = require('../util/lookupReplaceAssets');
 const lookupReplaceEntries = require('../util/lookupReplaceEntries');
-const { getInstalledExtensions } = require('../util/marketplace-app-helper');
-
-let client;
-let config = util.getConfig();
-
-let reqConcurrency = config.concurrency;
-let eConfig = config.modules.entries;
-let ePath = path.resolve(config.data, eConfig.dirName);
-let ctPath = path.resolve(config.data, config.modules.content_types.dirName);
-let lPath = path.resolve(config.data, config.modules.locales.dirName, config.modules.locales.fileName);
-
-let mappedAssetUidPath;
-let mappedAssetUrlPath;
-let entryMapperPath;
-let environmentPath;
-let entryUidMapperPath;
-let uniqueUidMapperPath;
-let modifiedSchemaPath;
-let createdEntriesWOUidPath;
-let failedWOPath;
-let masterLanguage;
-
-let skipFiles = ['__master.json', '__priority.json', 'schema.json'];
-let entryBatchLimit = config.rateLimit || 10;
-const importConcurrency = eConfig.importConcurrency || config.importConcurrency;
-const writeConcurrency = eConfig.writeConcurrency || config.writeConcurrency;
-
-function EntriesImport() {
-  let self = this;
-  mappedAssetUidPath = path.resolve(config.data, 'mapper', 'assets', 'uid-mapping.json');
-  mappedAssetUrlPath = path.resolve(config.data, 'mapper', 'assets', 'url-mapping.json');
-
-  entryMapperPath = path.resolve(config.data, 'mapper', 'entries');
-  environmentPath = path.resolve(config.data, 'environments', 'environments.json');
-  mkdirp.sync(entryMapperPath);
-
-  entryUidMapperPath = path.join(entryMapperPath, 'uid-mapping.json');
-  uniqueUidMapperPath = path.join(entryMapperPath, 'unique-mapping.json');
-  modifiedSchemaPath = path.join(entryMapperPath, 'modified-schemas.json');
-
-  createdEntriesWOUidPath = path.join(entryMapperPath, 'created-entries-wo-uid.json');
-  failedWOPath = path.join(entryMapperPath, 'failedWO.json');
-
-  // Object of Schemas, referred to by their content type uid
-  this.ctSchemas = {};
-  // Array of content type uids, that have reference fields
-  this.refSchemas = [];
-  // map of content types uids and their json-rte fields
-  this.ctJsonRte = [];
-  // map of content types uids and their json-rte fields
-  this.ctJsonRteWithEntryRefs = [];
-  // Entry refs that are held back to resolve after all entries have been created
-  this.jsonRteEntryRefs = {};
-  // Collection of entries, that were not created, as they already exist on Stack
-  this.createdEntriesWOUid = [];
-  // Collection of entry uids, mapped to the language they exist in
-  this.uniqueUids = {};
-  // Map of old entry uid to new
-  this.mappedUids = {};
-  // Entries that were created successfully
-  this.success = [];
-  // Entries that failed to get created OR updated
-  this.fails = [];
-  // List of installed extensions to replace uid
-  this.installedExtensions = [];
-
-  let files = fs.readdirSync(ctPath);
-  this.environment = helper.readFileSync(environmentPath);
-  for (let index in files) {
-    if (index) {
-      try {
-        if (skipFiles.indexOf(files[index]) === -1) {
-          if (files[index] != 'field_rules_uid.json') {
-            let schema = require(path.resolve(path.join(ctPath, files[index])));
-            self.ctSchemas[schema.uid] = schema;
+const config = require('../../config/default');
+
+module.exports = class ImportEntries {
+  mappedAssetUidPath;
+  mappedAssetUrlPath;
+  entryMapperPath;
+  environmentPath;
+  entryUidMapperPath;
+  uniqueUidMapperPath;
+  modifiedSchemaPath;
+  createdEntriesWOUidPath;
+  failedWOPath;
+  masterLanguage;
+  reqConcurrency;
+  eConfig;
+  ePath;
+  ctPath;
+  lPath;
+  importConcurrency;
+  skipFiles = ['__master.json', '__priority.json', 'schema.json'];
+
+  constructor(importConfig, stackAPIClient) {
+    this.config = _.merge(config, importConfig);
+    this.stackAPIClient = stackAPIClient;
+    this.mappedAssetUidPath = path.resolve(this.config.data, 'mapper', 'assets', 'uid-mapping.json');
+    this.mappedAssetUrlPath = path.resolve(this.config.data, 'mapper', 'assets', 'url-mapping.json');
+
+    this.entryMapperPath = path.resolve(this.config.data, 'mapper', 'entries');
+    this.environmentPath = path.resolve(this.config.data, 'environments', 'environments.json');
+    mkdirp.sync(this.entryMapperPath);
+
+    this.entryUidMapperPath = path.join(this.entryMapperPath, 'uid-mapping.json');
+    this.uniqueUidMapperPath = path.join(this.entryMapperPath, 'unique-mapping.json');
+    this.modifiedSchemaPath = path.join(this.entryMapperPath, 'modified-schemas.json');
+
+    this.createdEntriesWOUidPath = path.join(this.entryMapperPath, 'created-entries-wo-uid.json');
+    this.failedWOPath = path.join(this.entryMapperPath, 'failedWO.json');
+
+    this.reqConcurrency = this.config.concurrency;
+    this.eConfig = this.config.modules.entries;
+    this.ePath = path.resolve(this.config.data, this.eConfig.dirName);
+    this.ctPath = path.resolve(this.config.data, this.config.modules.content_types.dirName);
+    this.lPath = path.resolve(
+      this.config.data,
+      this.config.modules.locales.dirName,
+      this.config.modules.locales.fileName,
+    );
+
+    this.importConcurrency = this.eConfig.importConcurrency || this.config.importConcurrency;
+
+    // Object of Schemas, referred to by their content type uid
+    this.ctSchemas = {};
+    // Array of content type uids, that have reference fields
+    this.refSchemas = [];
+    // map of content types uids and their json-rte fields
+    this.ctJsonRte = [];
+    // map of content types uids and their json-rte fields
+    this.ctJsonRteWithEntryRefs = [];
+    // Entry refs that are held back to resolve after all entries have been created
+    this.jsonRteEntryRefs = {};
+    // Collection of entries, that were not created, as they already exist on Stack
+    this.createdEntriesWOUid = [];
+    // Collection of entry uids, mapped to the language they exist in
+    this.uniqueUids = {};
+    // Map of old entry uid to new
+    this.mappedUids = {};
+    // Entries that were created successfully
+    this.success = [];
+    // Entries that failed to get created OR updated
+    this.fails = [];
+    // List of installed extensions to replace uid
+    this.installedExtensions = [];
+
+    let files = fs.readdirSync(this.ctPath);
+    this.environment = helper.readFileSync(this.environmentPath);
+    for (let index in files) {
+      if (index) {
+        try {
+          if (this.skipFiles.indexOf(files[index]) === -1) {
+            if (files[index] != 'field_rules_uid.json') {
+              let schema = require(path.resolve(path.join(this.ctPath, files[index])));
+              this.ctSchemas[schema.uid] = schema;
+            }
           }
+        } catch (error) {
+          addlogs(this.config, `Failed to read the content types to import entries ${util.formatError(error)}`);
+          process.exit(0);
         }
-      } catch (error) {
-        addlogs(config, `Failed to read the content types to import entries ${util.formatError(error)}`);
-        process.exit(0);
       }
     }
   }
-}
-
-EntriesImport.prototype = {
-  /**
-   * Start point for entry import
-   * @return promise
-   */
-  start: async function (credentialConfig) {
-    let self = this;
-    config = credentialConfig;
-    client = stack.Client(config);
-    masterLanguage = config.master_locale;
-    addlogs(config, 'Migrating entries', 'success');
-    let languages = helper.readFileSync(lPath);
-    const appMapperFolderPath = path.join(config.data, 'mapper', 'marketplace_apps');
-
-    if (fs.existsSync(path.join(appMapperFolderPath, 'marketplace-apps.json'))) {
-      self.installedExtensions = helper.readFileSync(path.join(appMapperFolderPath, 'marketplace-apps.json')) || {};
-    }
 
-    if (_.isEmpty(self.installedExtensions)) {
-      self.installedExtensions = await getInstalledExtensions(config);
-    }
-
-    return new Promise(function (resolve, reject) {
-      let langs = [masterLanguage.code];
+  async start() {
+    let self = this;
+    this.masterLanguage = this.config.master_locale;
+    addlogs(this.config, 'Migrating entries', 'success');
+    let languages = helper.readFileSync(this.lPath);
+    const appMapperPath = path.join(this.config.data, 'mapper', 'marketplace_apps', 'uid-mapping.json');
+    this.installedExtensions = ((await helper.readFileSync(appMapperPath)) || { extension_uid: {} }).extension_uid;
+
+    return new Promise((resolve, reject) => {
+      let langs = [self.masterLanguage.code];
       for (let i in languages) {
         if (i) {
           langs.push(languages[i].code);
@@ -139,118 +132,114 @@ EntriesImport.prototype = {
       // Also remove field visibility rules
       return self
         .supressFields()
-        .then(async function () {
-          addlogs(config, 'Completed suppressing content type reference fields', 'success');
+        .then(async () => {
+          addlogs(self.config, 'Completed suppressing content type reference fields', 'success');
 
-          let mappedAssetUids = helper.readFileSync(mappedAssetUidPath) || {};
-          let mappedAssetUrls = helper.readFileSync(mappedAssetUrlPath) || {};
+          let mappedAssetUids = helper.readFileSync(self.mappedAssetUidPath) || {};
+          let mappedAssetUrls = helper.readFileSync(self.mappedAssetUrlPath) || {};
 
           // Step 2: Iterate over available languages to create entries in each.
           let counter = 0;
           return Promise.map(
             langs,
-            async function () {
+            async () => {
               let lang = langs[counter];
               if (
-                (config.hasOwnProperty('onlylocales') && config.onlylocales.indexOf(lang) !== -1) ||
-                !config.hasOwnProperty('onlylocales')
+                (self.config.hasOwnProperty('onlylocales') && self.config.onlylocales.indexOf(lang) !== -1) ||
+                !self.config.hasOwnProperty('onlylocales')
               ) {
-                addlogs(config, `Starting to create entries ${lang} locale`, 'info');
+                addlogs(self.config, `Starting to create entries ${lang} locale`, 'info');
                 await self.createEntries(lang, mappedAssetUids, mappedAssetUrls);
-                addlogs(config, 'Entries created successfully', 'info');
+                addlogs(self.config, 'Entries created successfully', 'info');
                 try {
                   await self.getCreatedEntriesWOUid();
                 } catch (error) {
                   addlogs(
-                    config,
+                    self.config,
                     `Failed get the existing entries to update the mapper ${util.formatError(error)}, 'error`,
                   );
                 }
-                addlogs(config, 'Starting to update entries with references', 'info');
+                addlogs(self.config, 'Starting to update entries with references', 'info');
                 await self.repostEntries(lang);
-                addlogs(config, "Successfully imported '" + lang + "' entries!", 'success');
+                addlogs(self.config, "Successfully imported '" + lang + "' entries!", 'success');
                 counter++;
               } else {
-                addlogs(config, lang + ' has not been configured for import, thus skipping it', 'success');
+                addlogs(self.config, lang + ' has not been configured for import, thus skipping it', 'success');
                 counter++;
               }
             },
             {
               concurrency: 1,
             },
-          ).then(async function () {
+          ).then(async () => {
             // Step 3: Revert all the changes done in content type in step 1
-            addlogs(config, 'Restoring content type changes', 'info');
+            addlogs(self.config, 'Restoring content type changes', 'info');
             await self.unSuppressFields();
-            addlogs(config, 'Removing entries from master language which got created by default', 'info');
+            addlogs(self.config, 'Removing entries from master language which got created by default', 'info');
             await self.removeBuggedEntries();
-            addlogs(config, 'Updating the field rules of content type', 'info');
-            let ct_field_visibility_uid = helper.readFileSync(path.join(ctPath + '/field_rules_uid.json'));
-            let ct_files = fs.readdirSync(ctPath);
+            addlogs(self.config, 'Updating the field rules of content type', 'info');
+            let ct_field_visibility_uid = helper.readFileSync(path.join(self.ctPath + '/field_rules_uid.json'));
+            let ct_files = fs.readdirSync(self.ctPath);
             if (ct_field_visibility_uid && ct_field_visibility_uid != 'undefined') {
               for (const element of ct_field_visibility_uid) {
                 if (ct_files.indexOf(element + '.json') > -1) {
-                  let schema = require(path.resolve(ctPath, element));
+                  let schema = require(path.resolve(self.ctPath, element));
                   try {
                     await self.field_rules_update(schema);
                   } catch (error) {
                     addlogs(
-                      config,
+                      self.config,
                       `Failed to update the field rules for content type ${schema.uid} ${util.formatError(error)}`,
                     );
                   }
                 }
               }
             }
-            addlogs(config, chalk.green('Entries have been imported successfully!'), 'success');
-            if (config.entriesPublish) {
-              addlogs(config, chalk.green('Publishing entries'), 'success');
+            addlogs(self.config, chalk.green('Entries have been imported successfully!'), 'success');
+            if (self.config.entriesPublish) {
+              addlogs(self.config, chalk.green('Publishing entries'), 'success');
               return self
                 .publish(langs)
-                .then(function () {
-                  addlogs(config, chalk.green('All the entries have been published successfully'), 'success');
+                .then(() => {
+                  addlogs(self.config, chalk.green('All the entries have been published successfully'), 'success');
                   return resolve();
                 })
                 .catch((error) => {
-                  addlogs(config, `Error in publishing entries ${util.formatError(error)}`, 'error');
+                  addlogs(self.config, `Error in publishing entries ${util.formatError(error)}`, 'error');
                 });
             }
             return resolve();
           });
         })
-        .catch(function (error) {
-          addlogs.log(config, util.formatError(error), 'error');
+        .catch((error) => {
+          addlogs(self.config, util.formatError(error), 'error');
           reject('Failed import entries');
         });
     });
-  },
+  }
 
-  createEntries: function (lang, mappedAssetUids, mappedAssetUrls) {
+  createEntries(lang, mappedAssetUids, mappedAssetUrls) {
     let self = this;
-    return new Promise(async function (resolve, reject) {
+    return new Promise(async (resolve, reject) => {
       let contentTypeUids = Object.keys(self.ctSchemas);
-      if (fs.existsSync(entryUidMapperPath)) {
-        self.mappedUids = await helper.readLargeFile(entryUidMapperPath);
+      if (fs.existsSync(this.entryUidMapperPath)) {
+        self.mappedUids = await helper.readLargeFile(this.entryUidMapperPath);
       }
       self.mappedUids = self.mappedUids || {};
       return Promise.map(
         contentTypeUids,
-        async function (ctUid) {
-          let eLangFolderPath = path.join(entryMapperPath, lang);
-          let eLogFolderPath = path.join(entryMapperPath, lang, ctUid);
+        async (ctUid) => {
+          let eLangFolderPath = path.join(this.entryMapperPath, lang);
+          let eLogFolderPath = path.join(this.entryMapperPath, lang, ctUid);
           mkdirp.sync(eLogFolderPath);
           // entry file path
-          let eFilePath = path.resolve(ePath, ctUid, lang + '.json');
+          let eFilePath = path.resolve(this.ePath, ctUid, lang + '.json');
 
           // log created/updated entries
           let successEntryLogPath = path.join(eLogFolderPath, 'success.json');
           let failedEntryLogPath = path.join(eLogFolderPath, 'fails.json');
           let createdEntriesPath = path.join(eLogFolderPath, 'created-entries.json');
           let createdEntries = {};
-          let stackForEntries = client.stack({
-            api_key: config.target_stack,
-            management_token: config.management_token,
-          });
 
           if (fs.existsSync(createdEntriesPath)) {
             createdEntries = await helper.readLargeFile(createdEntriesPath);
@@ -260,12 +249,12 @@ EntriesImport.prototype = {
             let entries = await helper.readLargeFile(eFilePath);
             if (!_.isPlainObject(entries) || _.isEmpty(entries)) {
               addlogs(
-                config,
+                this.config,
                 chalk.white("No entries were found for Content type:'" + ctUid + "' in '" + lang + "' language!"),
                 'success',
               );
             } else {
-              addlogs(config, `Creating entries for content type ${ctUid} in language ${lang} ...`, 'success');
+              addlogs(this.config, `Creating entries for content type ${ctUid} in language ${lang} ...`, 'success');
               for (let eUid in entries) {
                 if (eUid) {
                   try {
@@ -292,15 +281,15 @@ EntriesImport.prototype = {
                       self.installedExtensions,
                     );
                   } catch (error) {
-                    addlogs(config, 'Failed to update entry while creating entry id ' + eUid);
-                    addlogs(config, util.formatError(error), 'error');
+                    addlogs(this.config, 'Failed to update entry while creating entry id ' + eUid);
+                    addlogs(this.config, util.formatError(error), 'error');
                   }
                 }
               }
               let eUids = Object.keys(entries);
               let batches = [];
 
-              let entryBatchLimit = eConfig.batchLimit || 10;
+              let entryBatchLimit = this.eConfig.batchLimit || 10;
               let batchSize = Math.round(entryBatchLimit / 3);
 
               // Run entry creation in batches of ~16~ entries
@@ -309,14 +298,14 @@ EntriesImport.prototype = {
               }
               return Promise.map(
                 batches,
-                async function (batch) {
+                async (batch) => {
                   return Promise.map(
                     batch,
-                    async function (eUid, batchIndex) {
+                    async (eUid, batchIndex) => {
                       // if entry is already created
                       if (createdEntries.hasOwnProperty(eUid)) {
                         addlogs(
-                          config,
+                          this.config,
                           'Skipping ' +
                             JSON.stringify({
                               content_type: ctUid,
@@ -329,7 +318,7 @@ EntriesImport.prototype = {
                         );
                         self.success[ctUid] = createdEntries[eUid];
                         // if its a non-master language, i.e. the entry isn't present in the master language
-                        if (lang !== masterLanguage.code) {
+                        if (lang !== this.masterLanguage.code) {
                           self.uniqueUids[eUid] = self.uniqueUids[eUid] || {};
                           if (self.uniqueUids[eUid].locales) {
                             self.uniqueUids[eUid].locales.push(lang);
@@ -349,7 +338,7 @@ EntriesImport.prototype = {
                         },
                       };
                       if (self.mappedUids.hasOwnProperty(eUid)) {
-                        let entryToUpdate = stackForEntries.contentType(ctUid).entry(self.mappedUids[eUid]);
+                        let entryToUpdate = self.stackAPIClient.contentType(ctUid).entry(self.mappedUids[eUid]);
                         Object.assign(entryToUpdate, _.cloneDeep(entries[eUid]));
                         return entryToUpdate
                           .update({ locale: entryToUpdate.locale })
@@ -360,7 +349,7 @@ EntriesImport.prototype = {
                               self.mappedUids[eUid] = entryResponse.uid;
                               createdEntries = entryResponse;
                               // if its a non-master language, i.e. the entry isn't present in the master language
-                              if (lang !== masterLanguage.code) {
+                              if (lang !== this.masterLanguage.code) {
                                 self.uniqueUids[eUid] = self.uniqueUids[eUid] || {};
                                 if (self.uniqueUids[eUid].locales) {
                                   self.uniqueUids[eUid].locales.push(lang);
@@ -371,8 +360,12 @@ EntriesImport.prototype = {
                               }
                             }
                           })
-                          .catch(function (error) {
-                            addlogs(config, `Failed to update an entry ${eUid} ${util.formatError(error)}`, 'error');
+                          .catch((error) => {
+                            addlogs(
+                              this.config,
+                              `Failed to update an entry ${eUid} ${util.formatError(error)}`,
+                              'error',
+                            );
                             self.fails.push({
                               content_type: ctUid,
                               locale: lang,
@@ -383,8 +376,7 @@ EntriesImport.prototype = {
                           });
                       }
                       delete requestObject.json.entry.publish_details;
-                      return client
-                        .stack({ api_key: config.target_stack, management_token: config.management_token })
+                      return self.stackAPIClient
                         .contentType(ctUid)
                         .entry()
                         .create(requestObject.json, { locale: lang })
@@ -395,7 +387,7 @@ EntriesImport.prototype = {
                             self.mappedUids[eUid] = entryResponse.uid;
                             createdEntries = entryResponse;
                             // if its a non-master language, i.e. the entry isn't present in the master language
-                            if (lang !== masterLanguage.code) {
+                            if (lang !== this.masterLanguage.code) {
                               self.uniqueUids[eUid] = self.uniqueUids[eUid] || {};
                               if (self.uniqueUids[eUid].locales) {
                                 self.uniqueUids[eUid].locales.push(lang);
@@ -406,16 +398,20 @@ EntriesImport.prototype = {
                             }
                           }
                         })
-                        .catch(function (error) {
+                        .catch((error) => {
                           if (error.hasOwnProperty('error_code') && error.error_code === 119) {
                             if (error.errors.title) {
                               addlogs(
-                                config,
+                                this.config,
                                 'Entry ' + eUid + ' already exist, skip to avoid creating a duplicate entry',
                                 'error',
                               );
                             } else {
-                              addlogs(config, `Failed to create an entry ${eUid} ${util.formatError(error)}`, 'error');
+                              addlogs(
+                                this.config,
+                                `Failed to create an entry ${eUid} ${util.formatError(error)}`,
+                                'error',
+                              );
                             }
                             self.createdEntriesWOUid.push({
                               content_type: ctUid,
@@ -423,12 +419,12 @@ EntriesImport.prototype = {
                               entry: entries[eUid],
                               error: error,
                             });
-                            helper.writeFileSync(createdEntriesWOUidPath, self.createdEntriesWOUid);
+                            helper.writeFileSync(this.createdEntriesWOUidPath, self.createdEntriesWOUid);
                             return;
                           }
                           // TODO: if status code: 422, check the reason
                           // 429 for rate limit
-                          addlogs(config, `Failed to create an entry ${eUid} ${util.formatError(error)}`, 'error');
+                          addlogs(this.config, `Failed to create an entry ${eUid} ${util.formatError(error)}`, 'error');
                           self.fails.push({
                             content_type: ctUid,
                             locale: lang,
@@ -439,13 +435,13 @@ EntriesImport.prototype = {
                       // create/update 5 entries at a time
                     },
                     {
-                      concurrency: importConcurrency,
+                      concurrency: this.importConcurrency,
                     },
-                  ).then(function () {
+                  ).then(() => {
                     helper.writeFileSync(successEntryLogPath, self.success[ctUid]);
                     helper.writeFileSync(failedEntryLogPath, self.fails[ctUid]);
-                    helper.writeFileSync(entryUidMapperPath, self.mappedUids);
-                    helper.writeFileSync(uniqueUidMapperPath, self.uniqueUids);
+                    helper.writeFileSync(this.entryUidMapperPath, self.mappedUids);
+                    helper.writeFileSync(this.uniqueUidMapperPath, self.uniqueUids);
                     helper.writeFileSync(createdEntriesPath, createdEntries);
                   });
                   // process one batch at a time
@@ -453,10 +449,10 @@ EntriesImport.prototype = {
                 {
                   concurrency: 1,
                 },
-              ).then(function () {
+              ).then(() => {
                 if (self.success && self.success[ctUid] && self.success[ctUid].length > 0)
                   addlogs(
-                    config,
+                    this.config,
                     self.success[ctUid].length +
                       ' entries created successfully in ' +
                       ctUid +
@@ -467,7 +463,7 @@ EntriesImport.prototype = {
                   );
                 if (self.fails && self.fails[ctUid] && self.fails[ctUid].length > 0)
                   addlogs(
-                    config,
+                    this.config,
                     self.fails[ctUid].length +
                       ' entries failed to create in ' +
                       ctUid +
@@ -482,7 +478,7 @@ EntriesImport.prototype = {
             }
           } else {
             addlogs(
-              config,
+              this.config,
               chalk.white(
                 'Unable to find entry file path for ' +
                   ctUid +
@@ -498,64 +494,64 @@ EntriesImport.prototype = {
           concurrency: 1,
         },
       )
-        .then(function () {
-          addlogs(config, chalk.green("Entries created successfully in '" + lang + "' language"), 'success');
+        .then(() => {
+          addlogs(this.config, chalk.green("Entries created successfully in '" + lang + "' language"), 'success');
           return resolve();
         })
-        .catch(function (error) {
-          addlogs(config, chalk.red("Failed to create entries in '" + lang + "' language"), 'error');
+        .catch((error) => {
+          addlogs(this.config, chalk.red("Failed to create entries in '" + lang + "' language"), 'error');
           return reject(error);
         });
     });
-  },
-  getCreatedEntriesWOUid: function () {
+  }
+  getCreatedEntriesWOUid() {
     let self = this;
-    return new Promise(function (resolve) {
-      self.createdEntriesWOUid = helper.readFileSync(createdEntriesWOUidPath);
+    return new Promise((resolve) => {
+      self.createdEntriesWOUid = helper.readFileSync(this.createdEntriesWOUidPath);
       self.failedWO = [];
       if (_.isArray(self.createdEntriesWOUid) && self.createdEntriesWOUid.length > 0) {
         return Promise.map(
           self.createdEntriesWOUid,
-          function (entry) {
+          (entry) => {
             return self.fetchEntry(entry);
           },
           {
-            concurrency: importConcurrency,
+            concurrency: this.importConcurrency,
           },
-        ).then(function () {
-          helper.writeFileSync(failedWOPath, self.failedWO);
-          addlogs(config, 'Mapped entries without mapped uid successfully!', 'success');
+        ).then(() => {
+          helper.writeFileSync(this.failedWOPath, self.failedWO);
+          addlogs(this.config, 'Mapped entries without mapped uid successfully!', 'success');
           return resolve();
         });
       }
-      addlogs(config, 'No entries without mapped uid found!', 'success');
+      addlogs(this.config, 'No entries without mapped uid found!', 'success');
       return resolve();
     });
-  },
-  repostEntries: function (lang) {
+  }
+  repostEntries(lang) {
     let self = this;
-    return new Promise(async function (resolve, reject) {
-      let _mapped_ = await helper.readLargeFile(path.join(entryMapperPath, 'uid-mapping.json'));
+    return new Promise(async (resolve, reject) => {
+      let _mapped_ = await helper.readLargeFile(path.join(this.entryMapperPath, 'uid-mapping.json'));
       if (_.isPlainObject(_mapped_)) {
         self.mappedUids = _.merge(_mapped_, self.mappedUids);
       }
       return Promise.map(
         self.refSchemas,
-        async function (ctUid) {
-          let eFolderPath = path.join(entryMapperPath, lang, ctUid);
+        async (ctUid) => {
+          let eFolderPath = path.join(this.entryMapperPath, lang, ctUid);
           let eSuccessFilePath = path.join(eFolderPath, 'success.json');
-          let eFilePath = path.resolve(ePath, ctUid, lang + '.json');
+          let eFilePath = path.resolve(this.ePath, ctUid, lang + '.json');
           let sourceStackEntries = await helper.readLargeFile(eFilePath);
 
           if (!fs.existsSync(eSuccessFilePath)) {
-            addlogs(config, 'Success file was not found at: ' + eSuccessFilePath, 'success');
+            addlogs(this.config, 'Success file was not found at: ' + eSuccessFilePath, 'success');
             return;
           }
 
           let entries = await helper.readLargeFile(eSuccessFilePath, { type: 'array' }); // TBD LARGE
           entries = entries || [];
           if (entries.length === 0) {
-            addlogs(config, "No entries were created to be updated in '" + lang + "' language!", 'success');
+            addlogs(this.config, "No entries were created to be updated in '" + lang + "' language!", 'success');
             return;
           }
 
@@ -570,11 +566,11 @@ EntriesImport.prototype = {
 
           // map reference uids @mapper/language/mapped-uids.json
           // map failed reference uids @mapper/language/unmapped-uids.json
-          let refUidMapperPath = path.join(entryMapperPath, lang);
+          let refUidMapperPath = path.join(this.entryMapperPath, lang);
 
-          addlogs(config, 'staring to update the entry for reposting');
+          addlogs(this.config, 'staring to update the entry for reposting');
 
-          entries = _.map(entries, function (entry) {
+          entries = _.map(entries, (entry) => {
             try {
               let uid = entry.uid;
               let updatedEntry;
@@ -600,15 +596,15 @@ EntriesImport.prototype = {
               return _entry;
             } catch (error) {
               addlogs(
-                config,
+                this.config,
                 `Failed to update the entry ${uid} references while reposting ${util.formatError(error)}`,
               );
             }
           });
 
-          addlogs(config, 'Starting the reposting process for entries');
+          addlogs(this.config, 'Starting the reposting process for entries');
 
-          const entryBatchLimit = eConfig.batchLimit || 10;
+          const entryBatchLimit = this.eConfig.batchLimit || 10;
           const batchSize = Math.round(entryBatchLimit / 3);
           // Run entry creation in batches
           for (let i = 0; i < entries.length; i += batchSize) {
@@ -616,14 +612,14 @@ EntriesImport.prototype = {
           }
           return Promise.map(
             batches,
-            async function (batch, index) {
+            async (batch, index) => {
               return Promise.map(
                 batch,
-                async function (entry) {
+                async (entry) => {
                   entry.uid = self.mappedUids[entry.uid];
                   if (refsUpdatedUids.indexOf(entry.uid) !== -1) {
                     addlogs(
-                      config,
+                      this.config,
                       'Entry: ' +
                         entry.uid +
                         ' in Content Type: ' +
@@ -637,27 +633,18 @@ EntriesImport.prototype = {
                   }
 
                   let promiseResult = new Promise((resolveUpdatedUids, rejectUpdatedUids) => {
-                    let entryResponse = client
-                      .stack({ api_key: config.target_stack, management_token: config.management_token })
-                      .contentType(ctUid)
-                      .entry(entry.uid);
+                    let entryResponse = self.stackAPIClient.contentType(ctUid).entry(entry.uid);
                     Object.assign(entryResponse, entry);
                     delete entryResponse.publish_details;
                     return entryResponse
                       .update({ locale: lang })
                       .then((response) => {
-                        // for (let j = 0; j < entries.length; j++) {
-                        //   if (entries[j].uid === response.uid) {
-                        //     entries[j] = response;
-                        //     break;
-                        //   }
-                        // }
                         refsUpdatedUids.push(response.uid);
                         return resolveUpdatedUids();
                       })
-                      .catch(function (error) {
+                      .catch((error) => {
                         addlogs(
-                          config,
+                          this.config,
                           chalk.red(
                             'Entry Uid: ' +
                               entry.uid +
@@ -669,7 +656,7 @@ EntriesImport.prototype = {
                           'error',
                         );
 
-                        addlogs(config, util.formatError(error), 'error');
+                        addlogs(this.config, util.formatError(error), 'error');
                         refsUpdateFailed.push({
                           content_type: ctUid,
                           entry: entry,
@@ -682,20 +669,24 @@ EntriesImport.prototype = {
                   await promiseResult;
                 },
                 {
-                  concurrency: importConcurrency,
+                  concurrency: this.importConcurrency,
                 },
               )
-                .then(function () {
+                .then(() => {
                   // batch completed successfully
                   helper.writeFileSync(path.join(eFolderPath, 'success.json'), entries);
                   helper.writeFileSync(path.join(eFolderPath, 'refsUpdatedUids.json'), refsUpdatedUids);
                   helper.writeFileSync(path.join(eFolderPath, 'refsUpdateFailed.json'), refsUpdateFailed);
-                  addlogs(config, 'Completed re-post entries batch no: ' + (index + 1) + ' successfully!', 'success');
+                  addlogs(
+                    this.config,
+                    'Completed re-post entries batch no: ' + (index + 1) + ' successfully!',
+                    'success',
+                  );
                 })
-                .catch(function (error) {
+                .catch((error) => {
                   // error while executing entry in batch
-                  addlogs(config, chalk.red('Failed re-post entries at batch no: ' + (index + 1)), 'error');
-                  addlogs(config, util.formatError(error), 'error');
+                  addlogs(this.config, chalk.red('Failed re-post entries at batch no: ' + (index + 1)), 'error');
+                  addlogs(this.config, util.formatError(error), 'error');
                   // throw error;
                 });
             },
@@ -703,18 +694,21 @@ EntriesImport.prototype = {
               concurrency: 1,
             },
           )
-            .then(function () {
+            .then(() => {
               // finished updating entries with references
               addlogs(
-                config,
+                this.config,
                 "Imported entries of Content Type: '" + ctUid + "' in language: '" + lang + "' successfully!",
                 'success',
               );
             })
-            .catch(function (error) {
+            .catch((error) => {
               // error while updating entries with references
-              addlogs(config, chalk.red(`Failed re-post entries of content type ${ctUid} locale ${lang}`, 'error'));
-              addlogs(config, util.formatError(error), 'error');
+              addlogs(
+                this.config,
+                chalk.red(`Failed re-post entries of content type ${ctUid} locale ${lang}`, 'error'),
+              );
+              addlogs(this.config, util.formatError(error), 'error');
               // throw error;
             });
         },
@@ -722,23 +716,23 @@ EntriesImport.prototype = {
           concurrency: 1,
         },
       )
-        .then(function () {
+        .then(() => {
           // completed updating entry references
-          addlogs(config, chalk.green("Imported entries in '" + lang + "' language successfully!"), 'success');
+          addlogs(this.config, chalk.green("Imported entries in '" + lang + "' language successfully!"), 'success');
           return resolve();
         })
-        .catch(function (error) {
+        .catch((error) => {
           // error while updating entry references
-          addlogs(config, chalk.red('Failed to re post entries in ' + lang + ' language'), 'error');
+          addlogs(this.config, chalk.red('Failed to re post entries in ' + lang + ' language'), 'error');
           return reject(error);
         });
     });
-  },
-  supressFields: async function () {
+  }
+  supressFields() {
     // it should be spelled as suppressFields
-    addlogs(config, 'Suppressing content type reference fields', 'success');
+    addlogs(this.config, 'Suppressing content type reference fields', 'success');
     let self = this;
-    return new Promise(async function (resolve, reject) {
+    return new Promise(async (resolve, reject) => {
       let modifiedSchemas = [];
       let suppressedSchemas = [];
 
@@ -781,48 +775,46 @@ EntriesImport.prototype = {
           }
 
           // Replace extensions with new UID
-          extension_suppress(contentTypeSchema.schema, config.preserveStackVersion, self.installedExtensions);
+          extension_suppress(contentTypeSchema.schema, this.config.preserveStackVersion, self.installedExtensions);
         }
       }
 
       // write modified schema in backup file
-      helper.writeFileSync(modifiedSchemaPath, modifiedSchemas);
+      helper.writeFileSync(this.modifiedSchemaPath, modifiedSchemas);
 
       return Promise.map(
         suppressedSchemas,
-        async function (schema) {
-          let contentTypeResponse = client
-            .stack({ api_key: config.target_stack, management_token: config.management_token })
-            .contentType(schema.uid);
+        async (schema) => {
+          let contentTypeResponse = self.stackAPIClient.contentType(schema.uid);
           Object.assign(contentTypeResponse, _.cloneDeep(schema));
           return contentTypeResponse
             .update()
             .then((_updatedcontentType) => {
               // empty function
             })
-            .catch(function (_error) {
-              addlogs(config, util.formatError(error), 'error');
+            .catch((_error) => {
+              addlogs(this.config, util.formatError(error), 'error');
               reject(`Failed suppress content type ${schema.uid} reference fields`);
             });
           // update 5 content types at a time
         },
         {
           // update reqConcurrency content types at a time
-          concurrency: importConcurrency,
+          concurrency: this.importConcurrency,
         },
       )
-        .then(function () {
+        .then(() => {
           return resolve();
         })
-        .catch(function (error) {
-          addlogs(config, util.formatError(error), 'error');
+        .catch((error) => {
+          addlogs(this.config, util.formatError(error), 'error');
           return reject('Failed to suppress reference fields in content type');
         });
     });
-  },
-  fetchEntry: function (query) {
+  }
+  fetchEntry(query) {
     let self = this;
-    return new Promise(function (resolve, _reject) {
+    return new Promise((resolve, _reject) => {
       let requestObject = {
         qs: {
           query: {
@@ -832,39 +824,38 @@ EntriesImport.prototype = {
         },
       };
 
-      return client
-        .stack({ api_key: config.target_stack, management_token: config.management_token })
+      return self.stackAPIClient
         .contentType(query.content_type)
         .entry()
         .query(requestObject.qs)
         .find()
-        .then(function (response) {
+        .then((response) => {
           if (response.body.entries.length <= 0) {
-            addlogs(config, 'Unable to map entry WO uid: ' + query.entry.uid, 'error');
+            addlogs(this.config, 'Unable to map entry WO uid: ' + query.entry.uid, 'error');
             self.failedWO.push(query);
             return resolve();
           }
           self.mappedUids[query.entry.uid] = response.body.entries[0].uid;
-          let _ePath = path.join(entryMapperPath, query.locale, query.content_type, 'success.json');
+          let _ePath = path.join(this.entryMapperPath, query.locale, query.content_type, 'success.json');
           let entries = helper.readFileSync(_ePath);
           entries.push(query.entry);
           helper.writeFileSync(_ePath, entries);
           addlogs(
-            config,
+            this.config,
             'Completed mapping entry wo uid: ' + query.entry.uid + ': ' + response.body.entries[0].uid,
             'clientsuccess',
           );
           return resolve();
         })
-        .catch(function (_error) {
+        .catch((_error) => {
           return resolve();
         });
     });
-  },
-  unSuppressFields: function () {
+  }
+  unSuppressFields() {
     let self = this;
-    return new Promise(async function (resolve, reject) {
-      let modifiedSchemas = helper.readFileSync(modifiedSchemaPath);
+    return new Promise(async (resolve, reject) => {
+      let modifiedSchemas = helper.readFileSync(this.modifiedSchemaPath);
       let modifiedSchemasUids = [];
       let updatedExtensionUidsSchemas = [];
       for (let uid in modifiedSchemas) {
@@ -874,17 +865,16 @@ EntriesImport.prototype = {
             delete _contentTypeSchema.field_rules;
           }
 
-          extension_suppress(_contentTypeSchema.schema, config.preserveStackVersion, self.installedExtensions);
+          extension_suppress(_contentTypeSchema.schema, this.config.preserveStackVersion, self.installedExtensions);
           updatedExtensionUidsSchemas.push(_contentTypeSchema);
         }
       }
 
       return Promise.map(
         updatedExtensionUidsSchemas,
-        async function (schema) {
+        async (schema) => {
           let promise = new Promise((resolveContentType, rejectContentType) => {
-            client
-              .stack({ api_key: config.target_stack, management_token: config.management_token })
+            self.stackAPIClient
               .contentType(schema.uid)
               .fetch()
               .then((contentTypeResponse) => {
@@ -894,29 +884,29 @@ EntriesImport.prototype = {
                   .then((_updatedcontentType) => {
                     modifiedSchemasUids.push(schema.uid);
                     addlogs(
-                      config,
+                      this.config,
                       chalk.white("Content type: '" + schema.uid + "' has been restored to its previous glory!"),
                     );
                     return resolveContentType();
                   })
-                  .catch(function (error) {
-                    addlogs(config, chalk.red('Failed to re-update ' + schema.uid), 'error');
-                    addlogs(config, error, 'error');
+                  .catch((error) => {
+                    addlogs(this.config, chalk.red('Failed to re-update ' + schema.uid), 'error');
+                    addlogs(this.config, error, 'error');
                     return rejectContentType(error);
                   });
               })
-              .catch(function (error) {
-                addlogs(config, error, 'error');
+              .catch((error) => {
+                addlogs(this.config, error, 'error');
                 return rejectContentType(error);
               });
           });
           await promise;
         },
         {
-          concurrency: reqConcurrency,
+          concurrency: this.reqConcurrency,
         },
       )
-        .then(function () {
+        .then(() => {
           for (let i = 0; i < modifiedSchemas.length; i++) {
             if (modifiedSchemasUids.indexOf(modifiedSchemas[i].uid) !== -1) {
               modifiedSchemas.splice(i, 1);
@@ -924,24 +914,24 @@ EntriesImport.prototype = {
             }
           }
           // re-write, in case some schemas failed to update
-          helper.writeFileSync(modifiedSchemaPath, _.compact(modifiedSchemas));
-          addlogs(config, 'Re-modified content type schemas to their original form!', 'success');
+          helper.writeFileSync(this.modifiedSchemaPath, _.compact(modifiedSchemas));
+          addlogs(this.config, 'Re-modified content type schemas to their original form!', 'success');
           return resolve();
         })
-        .catch(function (error) {
+        .catch((error) => {
           // failed to update modified schemas back to their original form
           return reject(error);
         });
     });
-  },
-  removeBuggedEntries: function () {
+  }
+  removeBuggedEntries() {
     let self = this;
-    return new Promise(function (resolve, reject) {
-      let entries = helper.readFileSync(uniqueUidMapperPath);
+    return new Promise((resolve, reject) => {
+      let entries = helper.readFileSync(this.uniqueUidMapperPath);
       let bugged = [];
       let removed = [];
       for (let uid in entries) {
-        if (entries[uid].locales.indexOf(masterLanguage.code) === -1) {
+        if (entries[uid].locales.indexOf(this.masterLanguage.code) === -1) {
           bugged.push({
             content_type: entries[uid].content_type,
             uid: uid,
@@ -951,26 +941,25 @@ EntriesImport.prototype = {
 
       return Promise.map(
         bugged,
-        function (entry) {
-          return client
-            .stack({ api_key: config.target_stack, management_token: config.management_token })
+        (entry) => {
+          return self.stackAPIClient
             .contentType(entry.content_type)
             .entry(self.mappedUids[entry.uid])
-            .delete({ locale: masterLanguage.code })
-            .then(function () {
+            .delete({ locale: this.masterLanguage.code })
+            .then(() => {
               removed.push(self.mappedUids[entry.uid]);
-              addlogs(config, 'Removed bugged entry from master ' + JSON.stringify(entry), 'success');
+              addlogs(this.config, 'Removed bugged entry from master ' + JSON.stringify(entry), 'success');
             })
-            .catch(function (error) {
-              addlogs(config, chalk.red('Failed to remove bugged entry from master language'), 'error');
-              addlogs(config, util.formatError(error), 'error');
+            .catch((error) => {
+              addlogs(this.config, chalk.red('Failed to remove bugged entry from master language'), 'error');
+              addlogs(this.config, util.formatError(error), 'error');
             });
         },
         {
-          concurrency: importConcurrency,
+          concurrency: this.importConcurrency,
         },
       )
-        .then(function () {
+        .then(() => {
           for (let i = 0; i < bugged.length; i++) {
             if (removed.indexOf(bugged[i].uid) !== -1) {
               bugged.splice(i, 1);
@@ -978,20 +967,20 @@ EntriesImport.prototype = {
             }
           }
 
-          helper.writeFileSync(path.join(entryMapperPath, 'removed-uids.json'), removed);
-          helper.writeFileSync(path.join(entryMapperPath, 'pending-uids.json'), bugged);
+          helper.writeFileSync(path.join(this.entryMapperPath, 'removed-uids.json'), removed);
+          helper.writeFileSync(path.join(this.entryMapperPath, 'pending-uids.json'), bugged);
 
-          addlogs(config, chalk.green('The stack has been eradicated from bugged entries!'), 'success');
+          addlogs(this.config, chalk.green('The stack has been eradicated from bugged entries!'), 'success');
           return resolve();
         })
-        .catch(function (error) {
+        .catch((error) => {
           // error while removing bugged entries from stack
-          addlogs(config, util.formatError(error), 'error');
+          addlogs(this.config, util.formatError(error), 'error');
         });
     });
-  },
-  field_rules_update: function (schema) {
-    return new Promise(function (resolve, reject) {
+  }
+  field_rules_update(schema) {
+    return new Promise((resolve, reject) => {
       if (schema.field_rules) {
         let fieldRuleLength = schema.field_rules.length;
         for (let k = 0; k < fieldRuleLength; k++) {
@@ -1003,7 +992,7 @@ EntriesImport.prototype = {
               let updatedValue = [];
               for (const element of fieldRulesArray) {
                 let splitedFieldRulesValue = element;
-                let oldUid = helper.readFileSync(path.join(entryUidMapperPath));
+                let oldUid = helper.readFileSync(path.join(this.entryUidMapperPath));
                 if (oldUid.hasOwnProperty(splitedFieldRulesValue)) {
                   updatedValue.push(oldUid[splitedFieldRulesValue]);
                 } else {
@@ -1015,11 +1004,10 @@ EntriesImport.prototype = {
           }
         }
       } else {
-        addlogs(config, 'field_rules is not available', 'error');
+        addlogs(this.config, 'field_rules is not available', 'error');
       }
 
-      client
-        .stack({ api_key: config.target_stack, management_token: config.management_token })
+      self.stackAPIClient
         .contentType(schema.uid)
         .fetch()
         .then((contentTypeResponse) => {
@@ -1030,29 +1018,29 @@ EntriesImport.prototype = {
         .then(() => {
           return resolve();
         })
-        .catch(function (error) {
-          addlogs(config, `failed to update the field rules ${util.formatError(error)}`);
+        .catch((error) => {
+          addlogs(this.config, `failed to update the field rules ${util.formatError(error)}`);
         });
     });
-  },
-  publish: function (langs) {
+  }
+  publish(langs) {
     let self = this;
     let requestObject = {
       entry: {},
     };
 
     let contentTypeUids = Object.keys(self.ctSchemas);
-    let entryMapper = helper.readFileSync(entryUidMapperPath);
+    let entryMapper = helper.readFileSync(this.entryUidMapperPath);
 
-    return new Promise(function (resolve, reject) {
+    return new Promise((resolve, reject) => {
       return Promise.map(
         langs,
-        function (_lang, counter) {
+        (_lang, counter) => {
           let lang = langs[counter];
           return Promise.map(
             contentTypeUids,
-            async function (ctUid) {
-              let eFilePath = path.resolve(ePath, ctUid, lang + '.json');
+            async (ctUid) => {
+              let eFilePath = path.resolve(this.ePath, ctUid, lang + '.json');
               let entries = await helper.readLargeFile(eFilePath);
 
               let eUids = Object.keys(entries);
@@ -1060,7 +1048,7 @@ EntriesImport.prototype = {
               let batchSize;
 
               if (eUids.length > 0) {
-                let entryBatchLimit = eConfig.batchLimit || 10;
+                let entryBatchLimit = this.eConfig.batchLimit || 10;
                 batchSize = Math.round(entryBatchLimit / 3);
                 // Run entry creation in batches
                 for (let i = 0; i < eUids.length; i += batchSize) {
@@ -1072,15 +1060,15 @@ EntriesImport.prototype = {
 
               return Promise.map(
                 batches,
-                async function (batch, index) {
+                async (batch, index) => {
                   return Promise.map(
                     batch,
-                    async function (eUid) {
+                    async (eUid) => {
                       let entry = entries[eUid];
                       let envId = [];
                       let locales = [];
                       if (entry.publish_details && entry.publish_details.length > 0) {
-                        _.forEach(entries[eUid].publish_details, function (pubObject) {
+                        _.forEach(entries[eUid].publish_details, (pubObject) => {
                           if (
                             self.environment.hasOwnProperty(pubObject.environment) &&
                             _.indexOf(envId, self.environment[pubObject.environment].name) === -1
@@ -1100,25 +1088,24 @@ EntriesImport.prototype = {
                           requestObject.entry.environments = envId;
                           requestObject.entry.locales = locales;
                           return new Promise((resolveEntryPublished, rejectEntryPublished) => {
-                            client
-                              .stack({ api_key: config.target_stack, management_token: config.management_token })
+                            self.stackAPIClient
                               .contentType(ctUid)
                               .entry(entryUid)
                               .publish({ publishDetails: requestObject.entry, locale: lang })
                               // eslint-disable-next-line max-nested-callbacks
                               .then((result) => {
-                                // addlogs(config, 'Entry ' + eUid + ' published successfully in ' + ctUid + ' content type', 'success')
+                                // addlogs(this.config, 'Entry ' + eUid + ' published successfully in ' + ctUid + ' content type', 'success')
                                 addlogs(
-                                  config,
+                                  this.config,
                                   'Entry ' + eUid + ' published successfully in ' + ctUid + ' content type',
                                   'success',
                                 );
                                 return resolveEntryPublished(result);
                                 // eslint-disable-next-line max-nested-callbacks
                               })
-                              .catch(function (err) {
+                              .catch((err) => {
                                 addlogs(
-                                  config,
+                                  this.config,
                                   `failed to publish entry ${eUid} content type ${ctUid} ${util.formatError(err)}`,
                                 );
                                 return resolveEntryPublished('');
@@ -1133,35 +1120,35 @@ EntriesImport.prototype = {
                       concurrency: 1,
                     },
                   )
-                    .then(function () {
+                    .then(() => {
                       // empty function
                     })
-                    .catch(function (error) {
+                    .catch((error) => {
                       // error while executing entry in batch
-                      addlogs(config, util.formatError(error), 'error');
+                      addlogs(this.config, util.formatError(error), 'error');
                     });
                 },
                 {
                   concurrency: 1,
                 },
               )
-                .then(function () {
-                  // addlogs(config, 'Entries published successfully in ' + ctUid + ' content type', 'success')
+                .then(() => {
+                  // addlogs(this.config, 'Entries published successfully in ' + ctUid + ' content type', 'success')
                   addlogs('Entries published successfully in ' + ctUid + ' content type');
                 })
-                .catch(function (error) {
-                  addlogs(config, `failed to publish entry in content type ${ctUid} ${util.formatError(error)}`);
+                .catch((error) => {
+                  addlogs(this.config, `failed to publish entry in content type ${ctUid} ${util.formatError(error)}`);
                 });
             },
             {
               concurrency: 1,
             },
           )
-            .then(function () {
+            .then(() => {
               // empty function
               // addlogs('Published entries successfully in ' +);
             })
-            .catch(function (error) {
+            .catch((error) => {
               addlogs(`Failed to publish few entries in ${lang} ${util.formatError(error)}`);
             });
         },
@@ -1169,16 +1156,15 @@ EntriesImport.prototype = {
           concurrency: 1,
         },
       )
-        .then(function () {
+        .then(() => {
           return resolve();
         })
         .catch((error) => {
           addlogs(`Failed to publish entries ${util.formatError(error)}`);
-          // return reject(error);
         });
     });
-  },
-  removeEntryRefsFromJSONRTE: function (entry, ctSchema) {
+  }
+  removeEntryRefsFromJSONRTE(entry, ctSchema) {
     for (const element of ctSchema) {
       switch (element.data_type) {
         case 'blocks': {
@@ -1235,8 +1221,8 @@ EntriesImport.prototype = {
       }
     }
     return entry;
-  },
-  doEntryReferencesExist: function (element) {
+  }
+  doEntryReferencesExist(element) {
     // checks if the children of p element contain any references
     // only checking one level deep, not recursive
 
@@ -1258,10 +1244,10 @@ EntriesImport.prototype = {
       }
     }
     return false;
-  },
-  restoreJsonRteEntryRefs: function (entry, sourceStackEntry, ctSchema) {
-    let mappedAssetUids = helper.readFileSync(mappedAssetUidPath) || {};
-    let mappedAssetUrls = helper.readFileSync(mappedAssetUrlPath) || {};
+  }
+  restoreJsonRteEntryRefs(entry, sourceStackEntry, ctSchema) {
+    let mappedAssetUids = helper.readFileSync(this.mappedAssetUidPath) || {};
+    let mappedAssetUrls = helper.readFileSync(this.mappedAssetUrlPath) || {};
     for (const element of ctSchema) {
       switch (element.data_type) {
         case 'blocks': {
@@ -1355,11 +1341,11 @@ EntriesImport.prototype = {
       }
     }
     return entry;
-  },
-  isEntryRef: function (element) {
+  }
+  isEntryRef(element) {
     return element.type === 'reference' && element.attrs.type === 'entry';
-  },
-  removeUidsFromJsonRteFields: function (entry, ctSchema) {
+  }
+  removeUidsFromJsonRteFields(entry, ctSchema) {
     for (const element of ctSchema) {
       switch (element.data_type) {
         case 'blocks': {
@@ -1407,7 +1393,7 @@ EntriesImport.prototype = {
               });
             } else {
               delete entry[element.uid].uid; // remove uid
-              if (entry[element.uid]  && _.isObject(entry[element.uid].attrs)) {
+              if (entry[element.uid] && _.isObject(entry[element.uid].attrs)) {
                 entry[element.uid].attrs.dirty = true;
               }
               if (entry[element.uid] && !_.isEmpty(entry[element.uid].children)) {
@@ -1422,8 +1408,8 @@ EntriesImport.prototype = {
       }
     }
     return entry;
-  },
-  removeUidsFromChildren: function (children) {
+  }
+  removeUidsFromChildren(children) {
     if (children.length && children.length > 0) {
       return children.map((child) => {
         if (child.type && child.type.length > 0) {
@@ -1450,8 +1436,8 @@ EntriesImport.prototype = {
       }
       return children;
     }
-  },
-  setDirtyTrue: function (jsonRteChild) {
+  }
+  setDirtyTrue(jsonRteChild) {
     // also removing uids in this function
     if (jsonRteChild.type) {
       if (_.isObject(jsonRteChild.attrs)) {
@@ -1464,8 +1450,8 @@ EntriesImport.prototype = {
       }
     }
     return jsonRteChild;
-  },
-  resolveAssetRefsInEntryRefsForJsonRte: function (jsonRteChild, mappedAssetUids, mappedAssetUrls) {
+  }
+  resolveAssetRefsInEntryRefsForJsonRte(jsonRteChild, mappedAssetUids, mappedAssetUrls) {
     if (jsonRteChild.type) {
       if (jsonRteChild.attrs.type === 'asset') {
         let assetUrl;
@@ -1496,7 +1482,5 @@ EntriesImport.prototype = {
     }
 
     return jsonRteChild;
-  },
+  }
 };
-
-module.exports = EntriesImport;