Example of converting a recursive callback to an asynchronous iterator

recursive-callback-to-async.js

const promise_ = Symbol('promise');
class Deferred {
    constructor() {
        this[promise_] = new Promise((resolve, reject) => {
            this.resolve = resolve;
            this.reject = reject;
        });
    }

    get promise() {
        return this[promise_];
    }
}

function countDown(n, cb) {
    if (n > 0) {
        setTimeout(() => cb([n, n], n - 1), 500);
    }
}

async function* getResults() {
    let nextN = null;
    let rows = null;
    let batchDone = new Deferred();
    function callback(rows_, nextN_) {
        rows = rows_;
        nextN = nextN_;
        batchDone.resolve();
    }

    countDown(5, callback);

    while (true) {
        await batchDone.promise;
        for (const row of rows) {
            yield row;
        }

        if (!nextN) {
            return;
        }

        countDown(nextN, callback);
        nextN = null;
        rows = null;
        batchDone = new Deferred();
    }
}

async function main() {
    for await (const row of getResults()) {
        console.log('Got row', row);
    }
}
main();