I want to work with promises but I have a callback API in a format like:

###1. DOM load or other one time event:

    window.onload; // set to callback
    ...
    window.onload = function() {

    };

###2. Plain callback:

    function request(onChangeHandler) {
        ...
    }
    request(function() {
        // change happened
        ...
    });

###3. Node style callback (&quot;nodeback&quot;):

    function getStuff(dat, callback) {
        ...
    }
    getStuff(&quot;dataParam&quot;, function(err, data) {
        ...
    })

###4. A whole library with node style callbacks:

    API;
    API.one(function(err, data) {
        API.two(function(err, data2) {
            API.three(function(err, data3) {
                ...
            });
        });
    });

###How do I work with the API in promises, how do I &quot;promisify&quot; it?

How do I convert an existing callback API to promises?

I have restructured my code to [promises][1], and built a wonderful long **flat promise chain**, consisting of multiple `.then()` callbacks. In the end I want to return some composite value, and need to access multiple **intermediate promise results**. However the resolution values from the middle of the sequence are not in scope in the last callback, how do I access them?

    function getExample() {
        return promiseA(…).then(function(resultA) {
            // Some processing
            return promiseB(…);
        }).then(function(resultB) {
            // More processing
            return // How do I gain access to resultA here?
        });
    }

  [1]: https://en.wikipedia.org/wiki/Futures_and_promises


How do I access previous promise results in a .then() chain?

I was writing code that does something that looks like:

    function getStuffDone(param) {           | function getStuffDone(param) {
        var d = Q.defer(); /* or $q.defer */ |     return new Promise(function(resolve, reject) {
        // or = new $.Deferred() etc.        |     // using a promise constructor
        myPromiseFn(param+1)                 |         myPromiseFn(param+1)
        .then(function(val) { /* or .done */ |         .then(function(val) {
            d.resolve(val);                  |             resolve(val);
        }).catch(function(err) { /* .fail */ |         }).catch(function(err) {
            d.reject(err);                   |             reject(err);
        });                                  |         });
        return d.promise; /* or promise() */ |     });
    }                                        | }

Someone told me this is called the &quot;**deferred antipattern**&quot; or the &quot;**`Promise` constructor antipattern**&quot; respectively, what&#39;s bad about this code and why is this called an [antipattern](https://en.wikipedia.org/wiki/Anti-pattern)?

What is the explicit promise construction antipattern and how do I avoid it?

I&#39;ve been developing JavaScript for a few years and I don&#39;t understand the fuss about promises at all.

It seems like all I do is change:

    api(function(result){
        api2(function(result2){
            api3(function(result3){
                 // do work
            });
        });
    });

Which I could use a library like [async](https://github.com/caolan/async) for anyway, with something like:

    api().then(function(result){
         api2().then(function(result2){
              api3().then(function(result3){
                   // do work
              });
         });
    });

Which is more code and less readable. I didn&#39;t gain anything here, it&#39;s not suddenly magically &#39;flat&#39; either. Not to mention having to convert things to promises.

So, what&#39;s the big fuss about promises here?

Aren&#39;t promises just callbacks?

Whether it&#39;s an ES6 Promise or a bluebird Promise, Q Promise, etc.

How do I test to see if a given object is a Promise?

How do I tell if an object is a Promise?

After Node.js added native support for promises, are there still reasons to use libraries like Q or BlueBird? 

For example if you are starting a new project and let&#39;s assume in this project you don&#39;t have any dependencies that use these libraries, can we say that there are really no more reasons to use such libraries?

Are there still reasons to use promise libraries like Q or BlueBird now that we have ES6 promises?

I had a look at the [bluebird promise FAQ][1], in which it mentions that [`.then(success, fail)` is an antipattern][2]. I don&#39;t quite understand its explanation as for the `try` and `catch`. 
What&#39;s wrong with the following?

&lt;!-- language: lang-js --&gt;

    some_promise_call()
    .then(function(res) { logger.log(res) }, function(err) { logger.log(err) })

It seems that the example is suggesting the following to be the correct way.

&lt;!-- language: lang-js --&gt;

    some_promise_call()
    .then(function(res) { logger.log(res) })
    .catch(function(err) { logger.log(err) })

What&#39;s the difference?


  [1]: https://github.com/petkaantonov/bluebird/wiki/Promise-anti-patterns
  [2]: https://github.com/petkaantonov/bluebird/wiki/Promise-anti-patterns#the-thensuccess-fail-anti-pattern

When is .then(success, fail) considered an antipattern for promises?

In Bluebird&#39;s [`util.js` file](https://github.com/petkaantonov/bluebird/blob/7454401269cfa47e5b001354388c062509103de7/src/util.js#L180), it has the following function:

    function toFastProperties(obj) {
        /*jshint -W027*/
        function f() {}
        f.prototype = obj;
        ASSERT(&quot;%HasFastProperties&quot;, true, obj);
        return f;
        eval(obj);
    }

For some reason, there&#39;s a statement after the return function, which I&#39;m not sure why it&#39;s there.

As well, it seems that it is deliberate, as the author had silenced the JSHint warning about this:

&gt; Unreachable &#39;eval&#39; after &#39;return&#39;. (W027)

What exactly does this function do? Does `util.toFastProperties` really make an object&#39;s properties &quot;faster&quot;?

I&#39;ve searched through Bluebird&#39;s GitHub repository for any comments in the source code or an explanation in their list of issues, but I couldn&#39;t find any.

How does Bluebird&#39;s util.toFastProperties function make an object&#39;s properties &quot;fast&quot;?

Bluebird offers a [`finally`][1] method that is being called whatever happens in your promise chain. I find it very handy for cleaning purposes (like unlocking a resource, hiding a loader, ...)

Is there an equivalent in ES6 native promises?

  [1]: http://bluebirdjs.com/docs/api/finally.html

What is the equivalent of Bluebird Promise.finally in native ES6 promises?

I have trouble understanding the difference between putting `.catch` BEFORE and AFTER then in a nested promise.

Alternative 1:

    test1Async(10).then((res) =&gt; {
      return test2Async(22)
        .then((res) =&gt; {
          return test3Async(100);
        }).catch((err) =&gt; {
          throw &quot;ERROR AFTER THEN&quot;;
        });
    }).then((res) =&gt; {
      console.log(res);
    }).catch((err) =&gt; {
      console.log(err);
    });

Alternative 2:

    test1Async(10).then((res) =&gt; {
       return test2Async(22)
         .catch((err) =&gt; {
            throw &quot;ERROR BEFORE THEN&quot;;
          })
          .then((res) =&gt; {
            return test3Async(100);
          });
      }).then((res) =&gt; {
        console.log(res);
      }).catch((err) =&gt; {
        console.log(err);
      });

The behavior of each function is as follow, test1 fail if number is `&lt;0` test2 fails if number is `&gt; 10` and test3 fails if number is not `100`. In this case test2 is only failing.

I tried to run and make test2Async fail, both BEFORE and AFTER then behaves the same way and that is not executing the test3Async. Can somebody explain to me the  main difference for placing catch in different places? 

In each function I `console.log(&#39;Running test X&#39;)` in order to check if it gets executed. 

This question arises because of the previous thread I posted https://stackoverflow.com/questions/41982433/how-to-turn-nested-callback-into-promise/41984015?noredirect=1#comment71158471_41982637. I figure it is a different problem and worth posting another topic.

Placement of catch BEFORE and AFTER then

I am still fairly new to promises and am using bluebird currently, however I have a scenario where I am not quite sure how to best deal with it.

So for example I have a promise chain within an express app like so:

    repository.Query(getAccountByIdQuery)
    		.catch(function(error){
    			res.status(404).send({ error: &quot;No account found with this Id&quot; });
    		})
    		.then(convertDocumentToModel)
    		.then(verifyOldPassword)
    		.catch(function(error) {
    			res.status(406).send({ OldPassword: error });
    		})
    		.then(changePassword)
    		.then(function(){
    			res.status(200).send();
    		})
    		.catch(function(error){
    			console.log(error);
    			res.status(500).send({ error: &quot;Unable to change password&quot; });
    		});

So the behaviour I am after is:

- Goes to get account by Id
- If there is a rejection at this point, bomb out and return an error
- If there is no error convert the document returned to a model
- Verify the password with the database document
- If the passwords dont match then bomb out and return a different error
- If there is no error change the passwords
- Then return success
- If anything else went wrong, return a 500

So currently catches do not seem to stop the chaining, and that makes sense, so I am wondering if there is a way for me to somehow force the chain to stop at a certain point based upon the errors, or if there is a better way to structure this to get some form of branching behaviour, as there is a case of `if X do Y else Z`.

Any help would be great.

Handling multiple catches in promise chain

I&#39;m using the Bluebird promise library under Node.js, it&#39;s great! But I have a question:

If you take a look at the documentation of Node&#39;s [child_process.exec][1] and [child_process.execFile][2] you can see that both of these functions are returning a ChildProcess object.

So what&#39;s the recommended way to promisify such functions?

Note that the following works (I get a Promise object):

    var Promise = require(&#39;bluebird&#39;);
    var execAsync = Promise.promisify(require(&#39;child_process&#39;).exec);
    var execFileAsync = Promise.promisify(require(&#39;child_process&#39;).execFile);

But how can one get access to the original return value of the original Node.js functions? (In these cases I would need to be able to access the originally returned ChildProcess objects.)

Any suggestion would be appreciated!

EDIT:

Here is an example code which is using the return value of the child_process.exec function:

    var exec = require(&#39;child_process&#39;).exec;
    var child = exec(&#39;node ./commands/server.js&#39;);
    child.stdout.on(&#39;data&#39;, function(data) {
        console.log(&#39;stdout: &#39; + data);
    });
    child.stderr.on(&#39;data&#39;, function(data) {
        console.log(&#39;stderr: &#39; + data);
    });
    child.on(&#39;close&#39;, function(code) {
        console.log(&#39;closing code: &#39; + code);
    });

But if I would use the promisified version of the exec function ( execAsync from above ) then the return value will be a promise, not a ChildProcess object. This is the real problem I am talking about.

  [1]: https://nodejs.org/api/child_process.html#child_process_child_process_exec_command_options_callback
  [2]: https://nodejs.org/api/child_process.html#child_process_child_process_execfile_file_args_options_callback

How to promisify Node&#39;s child_process.exec and child_process.execFile functions with Bluebird?

How to correctly construct a loop to make sure the following **promise call** and the chained **logger.log(res)** runs synchronously through iteration? (bluebird)

    db.getUser(email).then(function(res) { logger.log(res); }); // this is a promise

&lt;p&gt;I tried the following way (method from http://blog.victorquinn.com/javascript-promise-while-loop )

    var Promise = require(&#39;bluebird&#39;);

    var promiseWhile = function(condition, action) {
        var resolver = Promise.defer();

        var loop = function() {
            if (!condition()) return resolver.resolve();
            return Promise.cast(action())
                .then(loop)
                .catch(resolver.reject);
        };

        process.nextTick(loop);

        return resolver.promise;
    });

    var count = 0;
    promiseWhile(function() {
        return count &lt; 10;
    }, function() {
        return new Promise(function(resolve, reject) {
            db.getUser(email)
              .then(function(res) { 
                  logger.log(res); 
                  count++;
                  resolve();
              });
        }); 
    }).then(function() {
        console.log(&#39;all done&#39;);
    }); 
&lt;p&gt;Although it seems to work, but I don&#39;t think it guarantees the order of calling **logger.log(res);** 

&lt;p&gt;
Any suggestions?


Correct way to write loops for promise.

I&#39;m using bluebird and I see two ways to resolve synchronous functions into a Promise, but I don&#39;t get the differences between both ways. It looks like the stacktrace is a little bit different, so they aren&#39;t just an `alias`, right?

So what is the preferred way?

**Way A**

    function someFunction(someObject) {
      return new Promise(function(resolve) {
        someObject.resolved = true;
        resolve(someObject);
      });
    }

**Way B**

    function someFunction(someObject) {
      someObject.resolved = true;
      return Promise.resolve(someObject);
    }

Promise.resolve vs new Promise(resolve)

I&#39;m using the bluebird library and need to make a series of HTTP requests and need to some of the response data to the next HTTP request. I&#39;ve built a function that handles my requests called `callhttp()`. This takes a url and the body of a POST. 

I&#39;m calling it like this: 

    var payload = &#39;{&quot;Username&quot;: &quot;joe&quot;, &quot;Password&quot;: &quot;password&quot;}&#39;;
    var join = Promise.join;
    join(
        callhttp(&quot;172.16.28.200&quot;, payload),
        callhttp(&quot;172.16.28.200&quot;, payload),
        callhttp(&quot;172.16.28.200&quot;, payload),
        function (first, second, third) {
        console.log([first, second, third]);
    });
   
The first request gets an API key which needs to be passed to the second request and so on. How do get the response data from the first request? 

UPDATE

This is the `callhttp` function:

    var Promise = require(&quot;bluebird&quot;);
    var Request = Promise.promisify(require(&#39;request&#39;));
    
    function callhttp(host, body) {
    
        var options = {
            url: &#39;https://&#39; + host + &#39;/api/authorize&#39;,
            method: &quot;POST&quot;,
            headers: {
                &#39;content-type&#39;: &#39;application/json&#39;
            },
            body: body,
            strictSSL: false
        };
    
        return Request(options).spread(function (response) {
            if (response.statusCode == 200) {
               // console.log(body)
                console.log(response.connection.getPeerCertificate().subject.CN)
                return {
                    data: response.body
                };
            } else {
                // Just an example, 200 is not the only successful code
                throw new Error(&quot;HTTP Error: &quot; + response.statusCode );
            }
        });
    }

How to chain and share prior results with Promises

I&#39;m investigating building a web app in part with Koa, but I don&#39;t quite have a handle on the hows, whens, and whys of choosing between - and applying - the range of supportive &quot;making async easier&quot; technologies/approaches (listed below). 

Overall the disparate guidance on the web about this subject still leaves things blurry, especially in respect to evolving best practices, or at least better ones, and under what scenarios.  There seems to be little or nothing on the web that puts it all in context.

*I&#39;m hoping the responses to this big arse sprawling post can correct that*.  Also maybe the questions below can inspire someone to write a thorough blog post or the like to address this matter.  My sense is I&#39;m not even close to the only one who would benefit from that.

So I&#39;d be pleased if the bright community could help answer and provide clarity to the following questions in respect to the technologies listed below (in bold type):

&gt;-- a) How, and under what circumstance (as applicable) are they complements, supplements, substitutes, and/or overlapping solutions to one another? 

&gt;-- b) What are their trade-offs in respect to speed-performance, error handling ease, and debugging ease?  

&gt;-- c) When, where, and why may it be better to use &quot;this&quot; versus &quot;that&quot; technology, technologies-combo, and/or approach?  

&gt;-- d) Which technologies or approaches, if any, may be &quot;dimming stars&quot;.

*(Hoping that the opinions that are part of answers can be well explained.)*
 
 
==============================

Technologies: 


*** Koa ***

*My understanding:* 

&gt;Koa is a minimal foundation for build Node apps geared for taking advantage of ECMAScript-6 features, one feature in particular being generators.




*** Co ***

*My understanding:* 

&gt;-- Co is a library of utilites for running ECMAScript-6 generators (which are native to Node .011 harmony), with the goal to allieve some/much(?) of the need to write boilerplate code for running and managing generators.  

&gt;-- Co is intrinsically part of Koa(?). 

*Specific questions:*

&gt;-- If and how does one use Co differently in Koa than in a non-Koa context.  In other words, does Koa wholly facade Co?

&gt;-- Could Co be replaced in Koa with some other like generator library if there is/was a better one?  Are there any?




*** Promise Libraries such as &quot;Q&quot; and Bluebird ***

*My understanding:* 

&gt;-- They are in a sense &quot;polyfills&quot; for implmententing the Promises/A+ spec, if and until Node natively runs that spec.  
&gt;-- They have some further non-spec convenience utilities for facilitating the use promises, such as Bluebird&#39;s promisfyAll utility. 

*Specific questions:*

&gt;-- My understanding is the ECMAScript-6 spec does/will largely reflect the Promises/A+ spec, but even so, Node 0.11v harmony does not natively implement Promises.  (Is this correct?)  However when it does, will technologies such as Q and Bluebird be on their way out?

&gt;-- I&#39;ve read something to the effect that &quot;Q&quot; and Bluebird support generators.  What does this mean?  Does it mean in part that, for example, they to some degree provided the same utility as Co, and if so to what degree?



*** Thunks and Promises  ***

&gt;I think I have an fair handle on what they are, but hoping someone can provide a succinct and clear &quot;elevator pitch&quot; definition on what each is, and of course, as asked above, to explain when to use one versus the other -- in a Koa context and not in it.

*Specific questions:*

&gt;-- Pro and cons to using something like Bluebird&#39;s promisfy, versus say using Thunkify (github com/visionmedia/node-thunkify)?
 


==============================

*To give some further context to this post and its questions*, it might be interesting if Koa techniques presented in the following webpages could be discussed and contrasted (especiallly on a pros vs cons basis):

&gt;-- a) www.marcusoft . net/2014/03/koaintro.html  (Where&#39;s the thunks or promises, or am I not seeing something?)

&gt;-- b) strongloop . com/strongblog/node-js-express-introduction-koa-js-zone  (Again, where&#39;s the thunks or promises?)

&gt;-- c) github . com/koajs/koa/blob/master/docs/guide.md  (What does the &quot;next&quot; argument equate to, and what set it and where?)

&gt;-- d) blog.peterdecroos . com/blog/2014/01/22/javascript-generators-first-impressions  (Not in a Koa context, but presents the use of Co with a promise library (Bluebird), so I&#39;m assuming the technique/pattern presented here lends itself to usage in Koa(?). If so, then how well?



Thanks all!

Koa / Co / Bluebird or Q / Generators / Promises / Thunks interplay? (Node.js)

We&#39;re experimenting with using `--harmony_async_await` in Node 7, and compared to transpiling with babel for async/await are missing the ability to have long stack traces (http://bluebirdjs.com/docs/api/promise.longstacktraces.html).

Obviously, it would be great if there was an option to &#39;just see this&#39; - on the chrome(ium) side they appear to support it in the inspector, though the latest work on this is after v8.5.4 (i.e. not in Node 7):

https://bugs.chromium.org/p/v8/issues/detail?id=4483

https://codereview.chromium.org/2357423002/

An alternative approach would be to get v8 to use bluebird&#39;s promise implementation - but how could I do that? Overriding `global. Promise` doesn&#39;t change how async/await behave (they still use the default promises).

Is it possible to get stack traces across async/await boundaries using --harmony_async_await in Node 7?

I found an existing library that uses promises, however it doesn&#39;t use bluebird. The library functions don&#39;t come with all the extra features bluebird does like `.map()` or `.tap()`. How do I convert a &quot;normal&quot; or &quot;non-bluebird&quot; promise to a bluebird one, with all the extra features bluebird offers?

I tried wrapping the existing promise in `Promise.promisify` and `Promise.resolve` and neither seemed to work.

Convert promise to bluebird

So, I want my first level catch to be the one that handles the error. Is there anyway to propagate my error up to that first catch?

Reference code, not working (yet):

	Promise = require(&#39;./framework/libraries/bluebird.js&#39;);

	function promise() {
		var promise = new Promise(function(resolve, reject) {
			throw(&#39;Oh no!&#39;);
		});

		promise.catch(function(error) {
			throw(error);
		});
	}

	try {	
		promise();
	}
	// I WANT THIS CATCH TO CATCH THE ERROR THROWN IN THE PROMISE
	catch(error) {
		console.log(&#39;Caught!&#39;, error);
	}


All Bluebird Solutions on Gang of Coders

Total of 19 Bluebird Solutions