@contentstack/cli-cm-import 1.1.0 → 1.2.1

package/src/lib/import/webhooks.js

@@ -9,113 +9,107 @@ const fs = require('fs');
 const path = require('path');
 const Promise = require('bluebird');
 const chalk = require('chalk');
-const {isEmpty} = require('lodash');
+const { isEmpty, merge } = require('lodash');
 
 const helper = require('../util/fs');
+const { formatError } = require('../util');
 const { addlogs } = require('../util/log');
-let config = require('../../config/default');
-let stack = require('../util/contentstack-management-sdk');
-let reqConcurrency = config.concurrency;
-let webhooksConfig = config.modules.webhooks;
+const config = require('../../config/default');
+const stack = require('../util/contentstack-management-sdk');
 
-let webhooksFolderPath;
-let webMapperPath;
-let webUidMapperPath;
-let webSuccessPath;
-let webFailsPath;
-let client;
+module.exports = class ImportWebhooks {
+  config;
+  fails = [];
+  success = [];
+  webUidMapper = {};
+  webhooksConfig = config.modules.webhooks;
+  reqConcurrency = config.concurrency || config.fetchConcurrency;
 
-function importWebhooks() {
-  this.fails = [];
-  this.success = [];
-  this.webUidMapper = {};
-}
+  constructor(credentialConfig) {
+    this.config = merge(config, credentialConfig);
+  }
+
+  start() {
+    addlogs(this.config, chalk.white('Migrating webhooks'), 'success');
+
+    const self = this;
+    const client = stack.Client(this.config);
+
+    let webMapperPath = path.resolve(this.config.data, 'mapper', 'webhooks');
+    let webFailsPath = path.resolve(this.config.data, 'mapper', 'webhooks', 'fails.json');
+    let webSuccessPath = path.resolve(this.config.data, 'mapper', 'webhooks', 'success.json');
+    let webUidMapperPath = path.resolve(this.config.data, 'mapper', 'webhooks', 'uid-mapping.json');
+
+    let webhooksFolderPath = path.resolve(this.config.data, this.webhooksConfig.dirName);
+    this.webhooks = helper.readFileSync(path.resolve(webhooksFolderPath, this.webhooksConfig.fileName));
 
-importWebhooks.prototype = {
-  start: function (credentialConfig) {
-    let self = this;
-    config = credentialConfig;
-    addlogs(config, chalk.white('Migrating webhooks'), 'success');
-    client = stack.Client(config);
-    webhooksFolderPath = path.resolve(config.data, webhooksConfig.dirName);
-    webMapperPath = path.resolve(config.data, 'mapper', 'webhooks');
-    webUidMapperPath = path.resolve(config.data, 'mapper', 'webhooks', 'uid-mapping.json');
-    webSuccessPath = path.resolve(config.data, 'mapper', 'webhooks', 'success.json');
-    webFailsPath = path.resolve(config.data, 'mapper', 'webhooks', 'fails.json');
-    self.webhooks = helper.readFile(path.resolve(webhooksFolderPath, webhooksConfig.fileName));
     if (fs.existsSync(webUidMapperPath)) {
-      self.webUidMapper = helper.readFile(webUidMapperPath);
+      self.webUidMapper = helper.readFileSync(webUidMapperPath);
       self.webUidMapper = self.webUidMapper || {};
     }
+
     mkdirp.sync(webMapperPath);
 
     return new Promise(function (resolve, reject) {
       if (self.webhooks == undefined || isEmpty(self.webhooks)) {
-        addlogs(config, chalk.white('No Webhooks Found'), 'success');
+        addlogs(self.config, chalk.white('No Webhooks Found'), 'success');
         return resolve({ empty: true });
       }
+
       let webUids = Object.keys(self.webhooks);
       return Promise.map(
         webUids,
         function (webUid) {
           let web = self.webhooks[webUid];
-          if (config.importWebhookStatus !== 'current' || config.importWebhookStatus === 'disable') {
+          if (self.config.importWebhookStatus !== 'current' || self.config.importWebhookStatus === 'disable') {
             web.disabled = true;
           }
 
           if (!self.webUidMapper.hasOwnProperty(webUid)) {
-            let requestOption = {
-              json: {
-                webhook: web,
-              },
-            };
+            let requestOption = { json: { webhook: web } };
 
             return client
-              .stack({ api_key: config.target_stack, management_token: config.management_token })
+              .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
               .webhook()
               .create(requestOption.json)
               .then(function (response) {
                 self.success.push(response);
                 self.webUidMapper[webUid] = response.uid;
-                helper.writeFile(webUidMapperPath, self.webUidMapper);
+                helper.writeFileSync(webUidMapperPath, self.webUidMapper);
               })
               .catch(function (err) {
                 let error = JSON.parse(err.message);
                 self.fails.push(web);
                 addlogs(
-                  config,
-                  chalk.red("Webhooks: '" + web.name + "' failed to be import\n" + JSON.stringify(error)),
+                  self.config,
+                  chalk.red("Webhooks: '" + web.name + "' failed to be import\n" + formatError(error)),
                   'error',
                 );
               });
           } else {
             // the webhooks has already been created
             addlogs(
-              config,
+              self.config,
               chalk.white("The Webhooks: '" + web.name + "' already exists. Skipping it to avoid duplicates!"),
               'success',
             );
           }
           // import 2 webhooks at a time
         },
-        {
-          concurrency: reqConcurrency,
-        },
+        { concurrency: self.reqConcurrency },
       )
         .then(function () {
           // webhooks have imported successfully
-          helper.writeFile(webSuccessPath, self.success);
-          addlogs(config, chalk.green('Webhooks have been imported successfully!'), 'success');
+          helper.writeFileSync(webSuccessPath, self.success);
+          addlogs(self.config, chalk.green('Webhooks have been imported successfully!'), 'success');
           return resolve();
         })
         .catch(function (error) {
           // error while importing environments
-          helper.writeFile(webFailsPath, self.fails);
-          addlogs(config, chalk.red('Webhooks import failed'), 'error');
+          helper.writeFileSync(webFailsPath, self.fails);
+          addlogs(self.config, chalk.red('Webhooks import failed'), 'error');
           return reject(error);
         });
     });
-  },
+  }
 };
-
-module.exports = new importWebhooks();

package/src/lib/import/workflows.js

@@ -9,49 +9,49 @@ const fs = require('fs');
 const path = require('path');
 const Promise = require('bluebird');
 const chalk = require('chalk');
-const {isEmpty} = require('lodash');
+const { isEmpty, merge } = require('lodash');
 
 const helper = require('../util/fs');
+const { formatError } = require('../util');
 const { addlogs } = require('../util/log');
 let config = require('../../config/default');
 let stack = require('../util/contentstack-management-sdk');
 
-let reqConcurrency = config.concurrency;
-let workflowConfig = config.modules.workflows;
-let workflowFolderPath;
-let workflowMapperPath;
-let workflowUidMapperPath;
-let workflowSuccessPath;
-let workflowFailsPath;
-let client;
-
-function importWorkflows() {
-  this.fails = [];
-  this.success = [];
-  this.workflowUidMapper = {};
-  this.labelUids = [];
-  if (fs.existsSync(workflowUidMapperPath)) {
-    this.workflowUidMapper = helper.readFile(workflowUidMapperPath);
-    this.workflowUidMapper = this.workflowUidMapper || {};
+module.exports = class importWorkflows {
+  client;
+  fails = [];
+  success = [];
+  workflowUidMapper = {};
+  workflowConfig = config.modules.workflows;
+  reqConcurrency = config.concurrency || config.fetchConcurrency || 1;
+
+  constructor(credentialConfig) {
+    this.config = merge(config, credentialConfig);
+    this.client = stack.Client(this.config);
   }
-}
 
-importWorkflows.prototype = {
-  start: function (credentialConfig) {
+  start() {
+    addlogs(this.config, chalk.white('Migrating workflows'), 'success');
+
     let self = this;
-    config = credentialConfig;
-    client = stack.Client(config);
-    addlogs(config, chalk.white('Migrating workflows'), 'success');
-    workflowFolderPath = path.resolve(config.data, workflowConfig.dirName);
-    self.workflows = helper.readFile(path.resolve(workflowFolderPath, workflowConfig.fileName));
-    workflowMapperPath = path.resolve(config.data, 'mapper', 'workflows');
-    workflowUidMapperPath = path.resolve(config.data, 'mapper', 'workflows', 'uid-mapping.json');
-    workflowSuccessPath = path.resolve(config.data, 'workflows', 'success.json');
-    workflowFailsPath = path.resolve(config.data, 'workflows', 'fails.json');
+    let workflowMapperPath = path.resolve(this.config.data, 'mapper', 'workflows');
+    let workflowFailsPath = path.resolve(this.config.data, 'workflows', 'fails.json');
+    let workflowSuccessPath = path.resolve(this.config.data, 'workflows', 'success.json');
+    let workflowUidMapperPath = path.resolve(this.config.data, 'mapper', 'workflows', 'uid-mapping.json');
+    let workflowFolderPath = path.resolve(this.config.data, this.workflowConfig.dirName);
+
+    self.workflows = helper.readFileSync(path.resolve(workflowFolderPath, this.workflowConfig.fileName));
+
+    if (fs.existsSync(workflowUidMapperPath)) {
+      this.workflowUidMapper = helper.readFileSync(workflowUidMapperPath);
+      this.workflowUidMapper = this.workflowUidMapper || {};
+    }
+
     mkdirp.sync(workflowMapperPath);
+
     return new Promise(function (resolve, reject) {
       if (self.workflows == undefined || isEmpty(self.workflows)) {
-        addlogs(config, chalk.white('No workflow Found'), 'success');
+        addlogs(self.config, chalk.white('No workflow Found'), 'success');
         return resolve({ empty: true });
       }
       self.workflowsUids = Object.keys(self.workflows);
@@ -61,18 +61,19 @@ importWorkflows.prototype = {
           let workflow = self.workflows[workflowUid];
 
           if (!self.workflowUidMapper.hasOwnProperty(workflowUid)) {
-            const workflowStages = workflow.workflow_stages;
             const roleNameMap = {};
-            const roles = await client.stack({ api_key: config.target_stack, management_token: config.management_token }).role().fetchAll();
+            const workflowStages = workflow.workflow_stages;
+            const roles = await self.client
+              .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
+              .role()
+              .fetchAll();
+
             for (const role of roles.items) {
               roleNameMap[role.name] = role.uid;
             }
-            for (let i = 0; i < workflowStages.length; i++) {
-              const stage = workflowStages[i];
-              if (
-                stage.SYS_ACL.users.uids.length &&
-                stage.SYS_ACL.users.uids[0] !== '$all'
-              ) {
+
+            for (const stage of workflowStages) {
+              if (stage.SYS_ACL.users.uids.length && stage.SYS_ACL.users.uids[0] !== '$all') {
                 stage.SYS_ACL.users.uids = ['$all'];
               }
 
@@ -82,16 +83,19 @@ importWorkflows.prototype = {
                     const roleData = stage.SYS_ACL.roles.uids[i];
                     if (!roleNameMap[roleData.name]) {
                       // rules.branch is required to create custom roles.
-                      const branchRuleExists = roleData.rules.find(rule => rule.module === 'branch');
+                      const branchRuleExists = roleData.rules.find((rule) => rule.module === 'branch');
                       if (!branchRuleExists) {
                         roleData.rules.push({
                           module: 'branch',
                           branches: ['main'],
-                          acl: { read: true }
+                          acl: { read: true },
                         });
                       }
 
-                      const role = await client.stack({ api_key: config.target_stack, management_token: config.management_token }).role().create({ role: roleData });
+                      const role = await self.client
+                        .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
+                        .role()
+                        .create({ role: roleData });
                       stage.SYS_ACL.roles.uids[i] = role.uid;
                       roleNameMap[roleData.name] = role.uid;
                     } else {
@@ -99,14 +103,22 @@ importWorkflows.prototype = {
                     }
                   }
                 } catch (error) {
-                  addlogs(config, chalk.red('Error while importing workflows roles. ' + error && error.message), 'error');
-                  return reject({ message: 'Error while importing workflows roles' });
+                  addlogs(
+                    self.config,
+                    chalk.red('Error while importing workflows roles. ' + formatError(error)),
+                    'error',
+                  );
+                  reject({ message: 'Error while importing workflows roles' });
                 }
               }
             }
 
             if (workflow.admin_users !== undefined) {
-              addlogs(config, chalk.yellow('We are skipping import of `Workflow superuser(s)` from workflow'), 'info');
+              addlogs(
+                self.config,
+                chalk.yellow('We are skipping import of `Workflow superuser(s)` from workflow'),
+                'info',
+              );
               delete workflow.admin_users;
             }
             // One branch is required to create workflow.
@@ -114,55 +126,53 @@ importWorkflows.prototype = {
               workflow.branches = ['main'];
             }
 
-            return client
-              .stack({ api_key: config.target_stack, management_token: config.management_token })
+            return self.client
+              .stack({ api_key: self.config.target_stack, management_token: self.config.management_token })
               .workflow()
               .create({ workflow })
               .then(function (response) {
                 self.workflowUidMapper[workflowUid] = response;
-                helper.writeFile(workflowUidMapperPath, self.workflowUidMapper);
+                helper.writeFileSync(workflowUidMapperPath, self.workflowUidMapper);
               })
               .catch(function (error) {
                 self.fails.push(workflow);
                 if (error.errors.name) {
-                  addlogs(config, chalk.red("workflow: '" + workflow.name + "'  already exist"), 'error');
+                  addlogs(self.config, chalk.red("workflow: '" + workflow.name + "'  already exist"), 'error');
                 } else if (error.errors['workflow_stages.0.users']) {
                   addlogs(
-                    config,
+                    self.config,
                     chalk.red(
                       "Failed to import Workflows as you've specified certain roles in the Stage transition and access rules section. We currently don't import roles to the stack.",
                     ),
                     'error',
                   );
                 } else {
-                  addlogs(config, chalk.red("workflow: '" + workflow.name + "'  failed"), 'error');
+                  addlogs(self.config, chalk.red("workflow: '" + workflow.name + "'  failed"), 'error');
                 }
               });
           } else {
             // the workflow has already been created
             addlogs(
-              config,
+              self.config,
               chalk.white("The Workflows: '" + workflow.name + "' already exists. Skipping it to avoid duplicates!"),
               'success',
             );
           }
           // import 1 workflows at a time
         },
-        {
-          concurrency: reqConcurrency,
-        },
+        { concurrency: self.reqConcurrency },
       )
         .then(function () {
-          helper.writeFile(workflowSuccessPath, self.success);
-          addlogs(config, chalk.green('Workflows have been imported successfully!'), 'success');
-          return resolve();
+          helper.writeFileSync(workflowSuccessPath, self.success);
+          addlogs(self.config, chalk.green('Workflows have been imported successfully!'), 'success');
+          resolve();
         })
         .catch(function (error) {
-          helper.writeFile(workflowFailsPath, self.fails);
-          addlogs(config, chalk.red('Workflows import failed'), 'error');
+          helper.writeFileSync(workflowFailsPath, self.fails);
+          addlogs(self.config, chalk.red('Workflows import failed'), 'error');
+          addlogs(self.config, formatError(error), 'error');
           return reject(error);
         });
     });
-  },
+  }
 };
-module.exports = new importWorkflows();

package/src/lib/util/extensionsUidReplace.js

@@ -6,7 +6,7 @@
 
 // eslint-disable-next-line unicorn/filename-case
 let path = require('path');
-const _ = require('lodash')
+const _ = require('lodash');
 let helper = require('./fs');
 let util = require('../util');
 let config = util.getConfig();
@@ -39,33 +39,33 @@ let extension_uid_Replace = (module.exports = function (schema, preserveStackVer
       }
     } else if (schema[i].data_type === 'global_field') {
       let global_fields_key_value = schema[i].reference_to;
-      let global_fields_data = helper.readFile(path.join(globalfieldsPath));
+      let global_fields_data = helper.readFileSync(path.join(globalfieldsPath));
       if (global_fields_data && global_fields_data.hasOwnProperty(global_fields_key_value)) {
         schema[i].reference_to = global_fields_data[global_fields_key_value];
       }
     } else if (schema[i].hasOwnProperty('extension_uid')) {
       const extension_key_value = schema[i].extension_uid;
-      const data = helper.readFile(path.join(extensionPath));
+      const data = helper.readFileSync(path.join(extensionPath));
       if (data && data.hasOwnProperty(extension_key_value)) {
         // eslint-disable-next-line camelcase
         schema[i].extension_uid = data[extension_key_value];
       } else if (schema[i].field_metadata && schema[i].field_metadata.extension) {
         if (installedExtensions) {
-          const marketplaceApps = helper.readFile(marketplaceAppPath);
-          const oldExt = _.find(marketplaceApps, { uid: schema[i].extension_uid })
+          const marketplaceApps = helper.readFileSync(marketplaceAppPath);
+          const oldExt = _.find(marketplaceApps, { uid: schema[i].extension_uid });
 
           if (oldExt) {
-            const ext = _.find(installedExtensions, { type: 'field', title: oldExt.title, app_uid: oldExt.app_uid })
+            const ext = _.find(installedExtensions, { type: 'field', title: oldExt.title, app_uid: oldExt.app_uid });
 
             if (ext) {
-              schema[i].extension_uid = ext.uid
+              schema[i].extension_uid = ext.uid;
             }
           }
         }
       }
     } else if (schema[i].data_type === 'json' && schema[i].hasOwnProperty('plugins') && schema[i].plugins.length > 0) {
       const newPluginUidsArray = [];
-      const data = helper.readFile(path.join(extensionPath));
+      const data = helper.readFileSync(path.join(extensionPath));
       schema[i].plugins.forEach((extension_key_value) => {
         if (data && data.hasOwnProperty(extension_key_value)) {
           newPluginUidsArray.push(data[extension_key_value]);
@@ -74,4 +74,4 @@ let extension_uid_Replace = (module.exports = function (schema, preserveStackVer
       schema[i].plugins = newPluginUidsArray;
     }
   }
-})
+});

package/src/lib/util/fs.js

@@ -7,33 +7,112 @@
 var fs = require('fs');
 var path = require('path');
 var mkdirp = require('mkdirp');
+const bigJSON = require('big-json');
 
-exports.readFile = function (filePath, parse) {
-  var data;
+exports.readFileSync = function (filePath, parse) {
+  let data;
   parse = typeof parse === 'undefined' ? true : parse;
   filePath = path.resolve(filePath);
   if (fs.existsSync(filePath)) {
-    data = parse ? JSON.parse(fs.readFileSync(filePath, 'utf-8')) : data;
+    try {
+      data = parse ? JSON.parse(fs.readFileSync(filePath, 'utf-8')) : data;
+    } catch (error) {
+      return data;
+    }
   }
   return data;
 };
 
-exports.writeFile = function (filePath, data) {
+// by default file type is json
+exports.readFile = async (filePath, options = { type: 'json' }) => {
+  return new Promise((resolve, reject) => {
+    filePath = path.resolve(filePath);
+    fs.readFile(filePath, 'utf-8', (error, data) => {
+      if (error) {
+        if (error.code === 'ENOENT') {
+          return resolve();
+        }
+        reject(error);
+      } else {
+        if (options.type !== 'json') {
+          return resolve(data);
+        }
+        resolve(JSON.parse(data));
+      }
+    });
+  });
+};
+
+exports.writeFileSync = function (filePath, data) {
   data = typeof data === 'object' ? JSON.stringify(data) : data || '{}';
   fs.writeFileSync(filePath, data);
 };
 
-exports.makeDirectory = function () {
-  for (var key in arguments) {
-    var dirname = path.resolve(arguments[key]);
-    if (!fs.existsSync(dirname)) {
-      mkdirp.sync(dirname);
-    }
+exports.writeFile = function (filePath, data) {
+  return new Promise((resolve, reject) => {
+    data = typeof data === 'object' ? JSON.stringify(data) : data || '{}';
+    fs.writeFile(filePath, data, (error) => {
+      if (error) {
+        return reject(error);
+      }
+      resolve('done');
+    });
+  });
+};
+
+exports.makeDirectory = async function (path) {
+  if (!path) {
+    throw new Error('Invalid path to create directory');
+  }
+  return mkdirp(path);
+};
+
+exports.readLargeFile = function (filePath, opts = {}) {
+  if (typeof filePath !== 'string') {
+    return;
+  }
+  filePath = path.resolve(filePath);
+  if (fs.existsSync(filePath)) {
+    return new Promise((resolve, reject) => {
+      const readStream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+      const parseStream = bigJSON.createParseStream();
+      parseStream.on('data', function (data) {
+        if (opts.type === 'array') {
+          return resolve(Object.values(data));
+        }
+        resolve(data);
+      });
+      parseStream.on('error', function (error) {
+        console.log('error', error);
+        reject(error);
+      });
+      readStream.pipe(parseStream);
+    });
   }
 };
 
-exports.readdir = function (dirPath) {
-  if (fs.existsSync(path)) {
+exports.writeLargeFile = function (filePath, data) {
+  if (typeof filePath !== 'string' || typeof data !== 'object') {
+    return;
+  }
+  filePath = path.resolve(filePath);
+  return new Promise((resolve, reject) => {
+    const stringifyStream = bigJSON.createStringifyStream({
+      body: data,
+    });
+    var writeStream = fs.createWriteStream(filePath, 'utf-8');
+    stringifyStream.pipe(writeStream);
+    writeStream.on('finish', () => {
+      resolve();
+    });
+    writeStream.on('error', (error) => {
+      reject(error);
+    });
+  });
+};
+
+exports.readdirSync = function (dirPath) {
+  if (fs.existsSync(dirPath)) {
     return fs.readdirSync(dirPath);
   } else {
     return [];

package/src/lib/util/index.js

@@ -13,6 +13,7 @@ var chalk = require('chalk');
 var { addlogs } = require('./log');
 var defaultConfig = require('../../config/default');
 const stack = require('./contentstack-management-sdk');
+const promiseLimit = require('promise-limit');
 var config;
 
 exports.initialization = function (configData) {
@@ -69,7 +70,7 @@ exports.sanitizeStack = function (importConfig) {
           importConfig.modules.stack.fileName,
         );
 
-        const oldStackDetails = fs.readFile(stackFilePath);
+        const oldStackDetails = fs.readFileSync(stackFilePath);
         if (!oldStackDetails || !oldStackDetails.settings || !oldStackDetails.settings.hasOwnProperty('version')) {
           throw new Error(`${JSON.stringify(oldStackDetails)} is invalid!`);
         }
@@ -129,7 +130,7 @@ exports.field_rules_update = function (importConfig, ctPath) {
   return new Promise(function (resolve, reject) {
     let client = stack.Client(importConfig);
 
-    fs.readFile(path.join(ctPath + '/field_rules_uid.json'), async (err, data) => {
+    fs.readFileSync(path.join(ctPath + '/field_rules_uid.json'), async (err, data) => {
       if (err) {
         throw err;
       }
@@ -152,7 +153,7 @@ exports.field_rules_update = function (importConfig, ctPath) {
                   let updatedValue = [];
                   for (let j = 0; j < fieldRulesArray.length; j++) {
                     let splitedFieldRulesValue = fieldRulesArray[j];
-                    let oldUid = helper.readFile(path.join(entryUidMapperPath));
+                    let oldUid = helper.readFileSync(path.join(entryUidMapperPath));
                     if (oldUid.hasOwnProperty(splitedFieldRulesValue)) {
                       updatedValue.push(oldUid[splitedFieldRulesValue]);
                     } else {
@@ -185,3 +186,38 @@ exports.field_rules_update = function (importConfig, ctPath) {
 exports.getConfig = function () {
   return config;
 };
+
+exports.formatError = function (error) {
+  try {
+    if (typeof error === 'string') {
+      error = JSON.parse(error);
+    } else {
+      error = JSON.parse(error.message);
+    }
+  } catch (e) {}
+  let message = error.errorMessage || error.error_message || error.message || error;
+  if (error.errors && Object.keys(error.errors).length > 0) {
+    Object.keys(error.errors).forEach((e) => {
+      let entity = e;
+      if (e === 'authorization') entity = 'Management Token';
+      if (e === 'api_key') entity = 'Stack API key';
+      if (e === 'uid') entity = 'Content Type';
+      if (e === 'access_token') entity = 'Delivery Token';
+      message += ' ' + [entity, error.errors[e]].join(' ');
+    });
+  }
+  return message;
+};
+
+exports.executeTask = function (tasks = [], handler, options) {
+  if (typeof handler !== 'function') {
+    throw new Error('Invalid handler');
+  }
+  const { concurrency = 1 } = options;
+  const limit = promiseLimit(concurrency);
+  return Promise.all(
+    tasks.map((task) => {
+      return limit(() => handler(task));
+    }),
+  );
+};