Bluebird Promising the result of a heavy function

Question

I've been using Bluebird a lot recently on a HAPI API development. I've just run into my first real problem, that perhaps my understanding or naivety has me stumped.

The following code is an example of what I am facing:-

var Promise = require('bluebird'),
    stuff = require('../stuff');

module.exports = {
    getSomething: function(request, reply) {
       var p = Promise.resolve();
       p = p.then(function() {
           return db.find() //etc. etc.
       });

       p = p.then(function(resultFromPromise) {
           //problems begin here
           var data = stuff.doSomeReallyLongAndBoringFunction(resultFromPromise);
           return data;
       });

       p.then(function(data) {
           //no data here.
       });
    };
};

I've commented where the problems usually begin. the stuff.doSomeReallyLongAndBoringFunction() returns an object (using more promises concidently) and it's this object I want to access, but //no data here always fires before data returns. stuff.doSomeReallyLongAndBoringFunction() continues to run regardless and completes successfully, but after the code goes async, I don't know how to promise that function's return value back.

Can anyone offer any guidance? Please accept my apologies for any naivety in the question!

Help as always, is appreciated

NB just for clarity, stuff.doSomeReallyLongAndBoringFunction() does not return a Promise itself. Although, I did try return new Promise(reject, resolve) { }); manual wrap. It is simply a function that uses promises itself (successfully) to get data.

Update 1 stuff.doSomeReallyLongAndBoringFunction() is too big to post directly, but it does something like this:-

var Promise = require('bluebird'),
    rp = require('request-promise');

module.exports = {
    doSomeReallyLongAndBoringFunction: function() {
       var p = Promise.resolve();
       p = p.then(function() {
           return db.find() //etc. etc.
       });

       p.then(function() {
           rp(options).then(function(response){
               //get some data from remote location
           }).then(function(dataFromService) {
               //do some jiggery pokery with said data
               var marshalledData = dataFromService;
               db.something.create({
                   Field: 'something'
               }).exec(function(err, saved) {
                   return marshalledData;
               });
           });
       }).catch(function(err) {

       });
    };
};

Update 2 Thank you Justin for your help. Here is the actual code, perhaps this may help?

Promise.resolve()
    .then(function() {
        if(typeof utils.intTryParse(place) !== 'number') {
            return foursquare.createPlaceFromFoursquare(sso, place, request, reply);
        } else {
            return { Place: { PlaceId: place }};
        }
    }).then(function(placeObj) {
        console.log('Place set as', placeObj);  //always returns undefined, despite function actually completing after async op...
    });

Answer 1

If your doSomeReallyLongAndBoringFunction is really running asynchronously, then it doesn't make sense to run it the way you have setup.

Edit - Here's a simple explanation of the way your code looks to be running vs a refactored version. It's been simplified , so you'll need to fill in the relevant sections with your actual implementation.

var Promise = require('bluebird');
    

function myAsync() {
    setTimeout(function(){
        return 'done sleeping';
    }, 2000);
};

//The way your code is running 
Promise.resolve()
    .then(function(){
        return 'hello';
    })
    .then(function(done){
        console.log(done);
        return myAsync();   //your error is here
    })
    .then(function(done){
        console.log(done);
    });


//refactored
Promise.resolve()
    .then(function(){
        return 'hello';
    })
    .then(function(done){
        console.log(done);

        return new Promise(function(resolve) {
            setTimeout(function(){
                resolve('done sleeping');
            }, 2000);
        });
    })
    .then(function(done){
        console.log(done);
    });

Answer 2

just for clarity, stuff.doSomeReallyLongAndBoringFunction() does not return a Promise itself.

And that's your problem. As it does something asynchronous and you want to get its result, it should return a promise. In fact, that's the case for every asynchronous function, especially then callbacks! It should be something like

module.exports = {
    doSomeReallyLongAndBoringFunction: function() {
        return db.find()
//      ^^^^^^
        .then(function() {
             return rp(options).then(function(response){
//           ^^^^^^
                 //get some data from remote location
             }).then(function(dataFromService) {
                 //do some jiggery pokery with said data
                 var marshalledData = dataFromService;
                 return db.something.create({
//               ^^^^^^
                     Field: 'something'
                 }).execAsyc();
             });
         }).catch(function(err) {
         });
    }
};

Your getSomething method has the same issues, and should look like this:

var createPlace = Promise.promisify(foursquare.createPlaceFromFoursquare);
module.exports = {
    getSomething: function(request) {
        var p;
        if (typeof utils.intTryParse(place) !== 'number')
            p = createPlace(sso, place, request); // this returns a promise!
        else
            p = Promise.resolve({Place: {PlaceId: place}});

        return p.then(function(placeObj) {
//      ^^^^^^
            console.log('Place set as', placeObj);
        });
    }
};

See also these generic rules for promise development.

Answer 3

doSomeReallyLongAndBoringFunction needs to look like this:

doSomeReallyLongAndBoringFunction: function(param) {
  var resolver = Promise.defer();

  /* 
   * do some asynchronous task and when you are finished
   * in the callback, do this:
   */
        resolver.resolve(resultFromAsyncTask);
  /*
   *
   *
   */

  return resolver.promise;
}