Run multiple promises simultaneously, but resolve in sequence (JS)

Question

Update 2023/08/03, 10:44: Modified my code to make clear the for loop could actually run for hours

I have an use case where I'd like to run multiple promises simultaneously, but resolve every promise in the order it was pushed into the queue. I came up with the solution below, but I'm not very happy with the approach. Any suggestions for improvements?

class PromiseQueue {
    #queue = [];

    enqueue(promise) {
        return new Promise((resolve) => {
            this.#queue.push({
                promise: promise(),
                resolve
            });
            
            if (this.#queue.length == 1) this.#dequeue();
        });
    }
    
    #dequeue() {
        let item = this.#queue[0];
        if (!item) return;
        item.promise.then((val) => {
            item.resolve(val);
            this.#queue.shift();
            this.#dequeue();
        });
    }
}

Usage

function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

function randomNumber(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
}

async function* getSwaps() { 
// ....
}

async function run() {
    let queue = new PromiseQueue();
    let i = 0;
    // could run for hours
    for await (let logs of getSwaps() {
        let fn = async () => {
            await sleep(randomNumber(300, 1000));
            return i;
        }
        
        queue.enqueue(fn).then((val) => {
            console.log(val)
            // write data to database as soon as available
        });
        i++;
    }    
}

run();

Answer 1

You can instead use 'Promise.all()' which will execute your promises concurrently, returning them sequentially. Doing so will allow you to remove the class 'PromiseQueue' entirely, simplifying your code.

Make sure to revise your code by declaring 'queue' as an array, which will allow you to push the promises you already created in your 'fn' function. I've revised your code below:

function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

function randomNumber(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
}

async function run() {
    let queue = [];
    for (let i = 0; i < 20; i++) {
        let fn = async () => {
            await sleep(randomNumber(300, 1000));
            return i;
        }
        queue.push(fn());
    }

    Promise.all(queue)
    .then((result) => {
        result.forEach((value) => {
            console.log(value);
        })
    })
}

run();

To keep the result in line with your previous code, please note that I included a loop that the Promise.all() will resolve, returning your values as individual elements instead of the complete array.

For more information about Promise.all(), I've included a snippet from MDN Web Docs:

The Promise.all() static method takes an iterable of promises as input and returns a single Promise. This returned promise fulfills when all of the input's promises fulfill (including when an empty iterable is passed), with an array of the fulfillment values. It rejects when any of the input's promises rejects, with this first rejection reason.

Hope this helps!