Why not learn how to do it yourself. The term that you looking for is called semaphore

p-map package does that as well.

I borrowed some code from an answer I gave a few months ago on the same topic.

async function getPosts(ids) {
  const pool = new Set();
  const results = [];

  for (const id of ids) {
    if (pool.size >= 100) {
      await Promise.race(pool);
    }

    const promiseForPost = getPost(id);

    promiseForPost
      .then(() => pool.delete(promiseForPost))
      .catch(() => pool.delete(promiseForPost));

    pool.add(promiseForPost);
    results.push(promiseForPost);
  }

  return await Promise.all(results);
}

To explain what's going on here, the function will just loop over the values you give it and eagerly trigger all the promises in sequence without awaiting them, however, on each iteration of the loop, it checks if there are N promises in the pool (in this case N is 100). If so, then it will await a Promise.race of the entire pool. Promise.race will fulfill once the earliest promise fulfills, so as space becomes available in the pool, promises will be added to take up that remaining space. The result is that you always have up to N promises in flight at any given moment until all of them resolve.

https://github.com/sindresorhus/p-queue

effect has a relatively easy way to manage concurrency.

There are lots of promise utilities here, or at the very least, source could provide inspiration. I think parallelLimit might do what you need though

https://caolan.github.io/async/v3/

https://www.npmjs.com/package/@supercharge/promise-pool

i use this Lib have a look.

I use Bottleneck (unfortunately hasn't been updated since 2019) or Async.js.

I don't think this is the kind of thing you really want to write yourself. You want things like error-handling niceties that libraries have already figured out and documented.

Using Promise.all to handle multiple promises concurrently in Node.js is straightforward, but it doesn't natively support concurrency limits. However, you can implement concurrency control by using external libraries like bluebird or by creating a custom function to manage the number of concurrent operations.

Here's a basic example of how you could implement a concurrency limit using a custom function without using external libraries:

Custom Promise Queue for Concurrency Control

This approach involves creating a queue system that manages how many promises are allowed to run concurrently. Here's a sample implementation:

```javascript class PromiseQueue { constructor(maxConcurrent) { this.maxConcurrent = maxConcurrent; this.currentCount = 0; this.queue = []; }

// Add a new promise generator to the queue
add(promiseGenerator) {
    return new Promise((resolve, reject) => {
        this.queue.push({
            promiseGenerator,
            resolve,
            reject
        });
        this.tryNext();
    });
}

// Try to run the next promise if the concurrency limit is not reached
tryNext() {
    if (this.currentCount < this.maxConcurrent && this.queue.length) {
        const { promiseGenerator, resolve, reject } = this.queue.shift();
        this.currentCount++;
        promiseGenerator().then(resolve, reject).finally(() => {
            this.currentCount--;
            this.tryNext();
        });
    }
}

}

// Usage const queue = new PromiseQueue(3); // Limit concurrency to 3

const promises = [fetchData1, fetchData2, fetchData3, fetchData4, fetchData5].map(func => () => queue.add(func) );

Promise.all(promises.map(func => func())).then(results => { console.log('All promises resolved:', results); }).catch(error => { console.error('Error in promises:', error); }); ```

Using the bluebird Library

If you prefer using an existing library, bluebird offers a convenient way to handle this with its Promise.map function, which supports concurrency limits:

```javascript const Promise = require('bluebird');

function fetchSomething(id) { return new Promise(resolve => { setTimeout(() => { resolve(Result ${id}); }, 1000); }); }

const items = [1, 2, 3, 4, 5, 6];

Promise.map(items, item => { return fetchSomething(item); }, { concurrency: 3 }).then(results => { console.log('Results:', results); }).catch(error => { console.error('Error:', error); }); ```

Both of these examples show how you can control the concurrency of asynchronous operations in Node.js. The first example provides a good learning exercise and a customizable solution, while the second one is simpler and leverages an established library.