Avoiding Callback Hell With Multiple Meteor Method Calls On Client

I have multiple Meteor.calls, where each methods depends on the response of another Meteor method. Client Meteor.call('methodOne', function(err, resOne){ if(!err){ Mete

Solution 1:

Since the other answer suggests RSVP this answer will suggest Bluebird which is actually the fastest promise library when running real benchmarks. Rather than amicrobenchmark that does not really measure anything meaningful. Anyway, I'm not picking it for performance, I'm picking it here because it's also the easiest to use and the one with the best debuggability.

Unlike the other answer, this one also does not suppress errors and the cost of making the function return a promise is marginal since no promise constructor is called.

var call = Promise.promisify(Meteor.call, Meteor);

var calls = call("methodOne").
            then(call.bind(Meteor, "methodTwo")).
            then(call.bind(Meteor, "methodThree"));

calls.then(function(resThree){
    console.log("Got Response!", resThree);
}).catch(function(err){
    console.log("Got Error", err); 
});

Solution 2:

Your approach on the client results in a lot more round trips between the server and the browser. I know you indicated that you were worried about spaghetti code on the server and I don't have visibility into your application as you do, but just going by the example you provide, it seems like an ideal place to wrap all three calls on the server and make only one call from the client, IMHO.

Solution 3:

EDIT: You're probably better off looking at @Benjamin Gruenbaum answer, which not only results in better performance, but also provides much more concise code.

Promises - yes there is.

I like RSVP very much, why? Simply because it's the fastest one. (quick benchmark: jsperf ).

Here's quick re-write of your code:

var promise = newRSVP.Promise(function(fulfill, reject) {
  Meteor.call('methodOne', '', function(err, resOne) {
    if (!err) {
      returnreject(err);
    }
    fulfill(resOne);
  });
});

promise.then(function(resOne) {
  returnnewRSVP.Promise(function(fulfill, reject) {
    Meteor.call('methodTwo', resOne, function(err, resTwo) {
      if (err) {
        returnreject(err);
      }
      fulfill(resTwo);
    });
  });
}).then(function(resTwo) {
  returnnewRSVP.Promise(function(fulfill, reject) {
    Meteor.call('methodTwo', resTwo, function(err, resThree) {
      if (err) {
        reject(err);
      }
      fulfill(resThree);
    });
  });
}).then(function(resThree) {
  // resThree is available - continue as you likeconsole.log(resThree);
}).catch(function(err) {
  console.log(err);
});

That's the way to prevent "the ever rightward drift" of your code.

Promises are cool, use them.