Why async.series only produce one output?

Question

I have the following code which makes 10 requests to randomuser API using got and async.series. For some reasons, this only gives me one output. How do I go about to fix this?

const got = require('got');
const async = require('async');

var tenOperations = [];
for(var i = 0; i < 10; i++) {
  tenOperations.push(doRequest);
}
function doRequest(callback) {
  got('https://randomuser.me/api/')
  .then(response => {
    console.log(response.body);
  })
  .catch(error => {
    console.log(error.response.body);
  });
};

async.series(tenOperations, function(err, results) {
  if(err) console.log(err);
  console.log(results);
});

Here is the sample output:

     {
    "results": [
        {
            "user": {
                "gender": "female",
                "name": {
                    "title": "miss",
                    "first": "غزل",
                    "last": "كامياران"
                },
                "location": {
                    "street": "6186 آزادی",
                    "city": "رشت",
                    "state": "تهران",
                    "zip": 64318
                },
                "email": "غزل.كامياران@example.com",
                "username": "goldenpanda201",
                "password": "muscles",
                "salt": "OStU2tyA",
                "md5": "92ac8a84380a24785597d0e916b0174e",
                "sha1": "93f6e830538dbc557017011583cca3b5e527f854",
                "sha256": "99a4c35237b1ebe276732fbf62efca24fd457428853de8a967dd465b80b82f0f",
                "registered": 1352433856,
                "dob": 1370066399,
                "phone": "053-14062122",
                "cell": "0929-641-1309",
                "picture": {
                    "large": "https://randomuser.me/api/portraits/women/48.jpg",
                    "medium": "https://randomuser.me/api/portraits/med/women/48.jpg",
                    "thumbnail": "https://randomuser.me/api/portraits/thumb/women/48.jpg"
                }
            }
        }
    ]
}

Answer 1

If you just want to make ten requests to the same API in sequence (one after another, not in a parallel), you can do this:

const got = require('got');

function runSequence(url, num) {
    let cntr = 0;
    let results = [];
    return new Promise(function(resolve, reject) {

        function checkDone(data) {
            ++cntr;
            results.push(data);
            if (cntr < num) {
                next();
            } else {
                resolve(results);
            }
        }

        function next() {
            got(url).then(response => {
                console.log(response.body);
                checkDone(response.body);
            }).catch(error => {
                console.log(error.response.body);
                checkDone(null);
            });
        }
        next();
    });
}

runSequence('https://randomuser.me/api/', 10).then(function(results) {
    // access array of results here
});

---

If the API calls don't have to be done one at a time and you can have them all in flight at the same time, then you can do this:

function runParallel(url, num) {
    let promises = [];
    for (let i = 0; i < num; i++) {
        promises.push(got(url));
    }
    return Promise.all(promises);
}

runParallel('https://randomuser.me/api/', 10).then(function(results) {
    // access array of results here
});

Note: The parallel option aborts on the first error, whereas both the sequence options shown here continue on error. Either could be changed to the other behavior. You did not specify which you wanted.

---

Here's a slightly different way of running the sequence:

function runSequence(url, num) {
    let cntr = 0;
    let results = [];

    function checkDone(data) {
        ++cntr;
        results.push(data);
        if (cntr < num) {
            return next();
        } else {
            return results;
        }            
    }

    function next() {
        return got(url).then(response => {
            return checkDone(response.body);
        }).catch(error => {
            return checkDone(null);
        });
    }

    return next();
}

---

Here's a generic function for repeating some async operation N times. You pass in the async function (that returns a promise), the number of times you want it repeated in sequence and whether you want it to continue on error or abort on error.

// pass a function that returns a promise
function repeatSequence(fn, num, continueOnError) {
    let cntr = 0;
    let results = [];

    checkDone(data) {
        ++cntr;
        results.push(data);
        if (cntr < num) {
            return next();
        } else {
            return results;
        }
    }

    function next() {
        return fn().then(checkDone).catch(function(err) {
            if (continueOnError) {
                return checkDone(null);
            } else {
                // reject on error
                throw err;
            }
        });
    }

    return next();
}

---

And, if you use the Bluebird Promise library, you can make use of Promise.mapSeries() with this:

function repeatSequence(fn, num, continueOnError) {
    var array = new Array(num);
    return Promise.mapSeries(array, function () {
        return fn().catch(function (err) {
            if (continueOnError) {
                return null;
            } else {
                throw (err);
            }
        });
    });
}

Or, if you don't want the continueOnError option, it just becomes this:

function repeatSequence(fn, num) {
    var array = new Array(num);
    return Promise.mapSeries(array, fn);
}

Answer 2

I must agree with Bergi that we must not mix callbacks with promises. Even though they are both async mechanisms, each of these two constructs are essentially and philosophically not to be treated the same.

However, as jfriend00 pointed out, the primary problem was that the "callbacks" were not being called, in each step. This would have been the correct solution while using a non-promise library.

Solution

Please find below my modifications. The essence would be:

1. This solution is an example of how you might implement it using promises only.

2. Ports like async-q might help you play better with existing libraries.

   const got = require('got');
   const async_q = require('async-q');
   
   var tenOperations = [];
   for(var i = 0; i < 10; i++) {
       tenOperations.push(doRequest);
   }
   
   function doRequest() {
       return got('https://randomuser.me/api/')
       .then(response => {
           console.log('resp', response.body);
           return JSON.parse(response.body);
       })
       .catch(error => {
           console.log('error', error.response.body);
           return error.response.body;
       });
   }
   
   async_q
   .series(tenOperations)
   .then (results => {
       console.log('results', results);
   })
   .done();