Accommodating a Q.all in a promise chain

Question

I swear by Q for its simplicity, so I might not have done much research checking out other 'then' implementations. But I've used Q a good deal!

I have a chain of 'then' promises, and I want to resolve a 'batch' of promises in the middle of it and proceed with other operations in sequence; so it's obvious I should use Q.all. But I'm stuck here. Either Q's doing it wrong, or I am.

Here are two hypothetical async operations

var f=function(delay){
  return Q.delay(delay).then(function(){
    console.log("returning delayed",delay)
    return delay
  })
}

f2=function(delay){
  var defer=Q.defer()
  setTimeout(function(){
    console.log("returning timedout",delay)
    return delay
  },delay)
  return defer.promise
}

And this is the promise chain

  Q('begin')
    .then(console.log)
    .then(Q.all([100,200,300,400].map(f)))
    .then(function(){
      console.log("Finally",arguments)
    }).done()

And this is the output I wish

begin
returning delayed 100
returning delayed 200
returning delayed 300
returning delayed 400
Finally { '0': undefined }

But this is the output I get

begin
Finally { '0': undefined }
returning delayed 100
returning delayed 200
returning delayed 300
returning delayed 400

I get the same sequence with f2

Now, if I run this

Q.all([100,200,300,400].map(f)).then(function(){
  console.log("Finally",arguments)
}).done()

I do get

returning delayed 100
returning delayed 200
returning delayed 300
returning delayed 400
Finally { '0': [ 100, 200, 300, 400 ] }

but using f2 instead of f gives me

returning timedout 100
returning timedout 200
returning timedout 300
returning timedout 400

It doesn't execute the finally block.

I get the same outputs with Q.[all/allResolved/allSettled]

So, my queries are,

1. How do I achieve the intended output by using Q.all specifically. I do have a workaround though, but it doesn't look nice.
2. How are f and f2 different since the results by running Q.all().then() with them aren't the same.

Answer 1

Q.all takes an array of promises, but then returns a promise (that is the only resolved when every promise in the array is resolved.

So, I think you need to return the result of Q.all in order to not immediately call the next then :

Q('begin')
    .then(console.log)
    .then(function() {
        return Q.all([100,200,300,400].map(f));
    })
    .then(function(){
      console.log("Finally",arguments)
    }).done()

Answer 2

Answering the second question, your usage of f2 is incorrect.

When you create a promise using a deferred you must resolve it in order for it to become fulfilled. You can read more about it in How to convert a callback API to promises .

In your case you're creating an empty deferred and returning its promise but you never actually call .resolve on the deferred. Doing it "more correctly" would be something like:

f2=function(delay){
  var defer=Q.defer()
  setTimeout(function(){
    console.log("returning timedout",delay)
    defer.resolve(delay); // note the resolve here vs the return
  },delay)
  return defer.promise
}

Using Q.delay works better since it's already promisified. As for other then implementations Q is hardly bleeding edge right now to say the least :)