NodeJS - loop with nested API calls

A couple of things to think about:

If you care about the fate of a promise, always return it.

In your case, findMore does not return the promise from request, so getData has no handle to track the resolution (or rejection) of that promise.

You can track the resolution of multiple promises with Promise.all.

The Promise.all() method returns a single Promise that resolves when all of the promises in the iterable argument have resolved or when the iterable argument contains no promises. It rejects with the reason of the first promise that rejects.

Lets put these to use on your example:

function getData() { 
    var options = {
        method: 'GET',
        uri: 'https://api.call1.com',
        qs: {
            access_token: _accessToken,
        }
    };

    return request(options)
        .then(function(apires){
            var obj = JSON.parse(apires);
            var findMorePromises = obj.data.map(function(entry) {        
                return findMore(entry.id)
            });
            return Promise.all(findMorePromises);
        })
}

function findMore(id) {
    var options = {
        method: 'GET',
        uri: 'https://api.call2.com',
        qs: {
            access_token: _accessToken,
        }
    };

    return request(options)
        .then(function(apires){
           return JSON.parse(apires);
        })
}

I've used map to construct the array of promises, but you could just as well use a foreach and push into an array similar to be more similar to your example code.

It's also good practice to make sure you are handling rejection of any promises (via catch), but I'll assume that is out of the scope of this question.

You want to use Promise.all.

So first thing first, you need an array of promises. Inside your for each loop, set findMore to a variable, and make it return the promise. Then have a line where you do Promise.all(promiseArr).then(function(){console.log("done)})

Your code would look like this

function getData() { 
            var promiseArr = []
            var options = {
            method: 'GET',
            uri: 'https://api.call1.com',
                qs: {
                    access_token: _accessToken,
                }
            };
            request(options).then(function(apires){
               console.log("complete 1");
                var obj = JSON.parse(apires);
                obj.data.forEach(function(entry) {        
                    var p = findMore(entry.id)
                    promiseArr.push(p)
                });
            }).then(function(){
                       Promise.all(promiseArr).then(function(){
                       console.log("this is all done")
                       })
                    })
   }


   function findMore(id) {
            var options = {
            method: 'GET',
            uri: 'https://api.call2.com',
                qs: {
                    access_token: _accessToken,
                }
            };
            return request(options).then(function(apires){
               console.log("complete 2");
                var obj = JSON.parse(apires);
            })
   }

the basic idea of Promise.all is that it only executes once all promises in the array have been resolved, or when any of the promises fail. You can read more about it here

You need to use Promise.all to run all async requests in parallel. Also you must return the result of findMore and getData (they are promises).

function getData() { 
  var options = {...};
  return request(options)
    .then(function(apires) {
      console.log("complete 1");
      var obj = JSON.parse(apires);
      var ops = obj.data.map(function(entry) {
        return findMore(entry.id);
      });
      return Promise.all(ops);
}

function findMore(id) {
  var options = {...};
  return request(options)
    .then(function(apires) {
      console.log("complete 2");
      return JSON.parse(apires);
    });
}

getData()
  .then(data => console.log(data))
  .catch(err => console.log(err));

If you can use ES7, it can be written with async/await:

let getData = async () => { 
  let options = {...};
  let res = awit request(options);
  let ops = res.data.map(entry => findMore(entry.id));
  let data = await Promise.all(ops);
  return data;
};

let findMore = async (id) => {
  let options = {...};
  let apires = awit request(options);
  return JSON.parse(apires);
};

EDIT: As others have mentioned, using a Promise.all() is likely a better solution in this case.

If you are open to using jQuery (a JavaScript library), then you can use the .ajaxStop() event handler and specify your own function. Sample code:

$(document).ajaxStop(function(){
    alert("All AJAX requests are completed.");
});

You will need to include the jQuery module. The instructions for Node.js are:

1. Install module through npm:

   npm install jquery
   

2. Then use a "require" to use jQuery in your JavaScript code (a window with a document is required but there is no such "window" in Node so you can mock one with jsdom), see npm - jQuery for details:

   require("jsdom").env("", function(err, window) {
       if (err) {
           console.error(err);
           return;
       }
   
       var $ = require("jquery")(window);
   });
   

If you want to stick to a pure JavaScript approach, you will need to create your own "module" to keep track of AJAX requests. In this module you can keep track of how many pending requests there are and remove them once they are terminated. Please see: Check when all Ajax Requests are complete - Pure JavaScript for more details.