How do I convert an existing callback API to promises

Question

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   nodeback     function getStuff dat  callback              getStuff  dataParam   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  promisify  it

User · Answer

You can use JavaScript native promises with Node JS.

My Cloud 9 code link: https://ide.c9.io/adx2803/native-promises-in-node

/**
* Created by dixit-lab on 20/6/16.
*/

var express = require('express');
var request = require('request');   //Simplified HTTP request client.


var app = express();

function promisify(url) {
    return new Promise(function (resolve, reject) {
        request.get(url, function (error, response, body) {
            if (!error && response.statusCode == 200) {
                resolve(body);
            }
            else {
                reject(error);
            }
        })
    });
}

//get all the albums of a user who have posted post 100
app.get('/listAlbums', function (req, res) {
    //get the post with post id 100
    promisify('http://jsonplaceholder.typicode.com/posts/100').then(function (result) {
        var obj = JSON.parse(result);
        return promisify('http://jsonplaceholder.typicode.com/users/' + obj.userId + '/albums')
    })
    .catch(function (e) {
        console.log(e);
    })
    .then(function (result) {
        res.end(result);
    })
})

var server = app.listen(8081, function () {
    var host = server.address().address
    var port = server.address().port

    console.log("Example app listening at http://%s:%s", host, port)
})

//run webservice on browser : http://localhost:8081/listAlbums

User · Answer

Under node v7 6  which has built in promises and async      promisify js let promisify   fn   gt      args    gt      new Promise  resolve  reject    gt          fn    args   err  result    gt                if  err  return reject err               return resolve result                      module exports   promisify    How to use   let readdir   require  fs   readdir  let promisify   require    promisify    let readdirP   promisify readdir    async function myAsyncFn path        let entries   await readdirP path       return entries

User · Answer

Node js 8 0 0 includes a new util promisify   API that allows standard Node js callback style APIs to be wrapped in a function that returns a Promise  An example use of util promisify   is shown below   const fs   require  fs    const util   require  util     const readFile   util promisify fs readFile    readFile   some file      then  data    gt                      catch  err    gt                      See Improved support for Promises

User · Answer

You can do something like this      flow  const toPromise    f   any    gt  void    gt      return new Promise lt any gt   resolve  reject    gt        try         f  result    gt            resolve result                 catch  e          reject e                export default toPromise   Then use it  async loadData       const friends   await toPromise FriendsManager loadFriends     console log friends

User · Answer

In release candidate for Node js 8 0 0  there s a new utility  util promisify  I ve written about util promisify   that encapsulates the capacity of promisifying whatever function   It is not much different from the approaches suggested in the other answers  but has the advantage of being a core method  and not requiring additional dependencies    const fs   require  fs    const util   require  util     const readFile   util promisify fs readFile     Then you ve a readFile method that returns a native Promise   readFile    notes txt      then txt   gt  console log txt      catch

User · Answer

From the future  A simple generic function I normally use  const promisify    fn     args    gt      return new Promise  resolve  reject    gt        fn    args   err  data    gt          if  err            return reject err                 resolve data                     How to use it    promisify fn  arg1  arg2   You are probably not looking to this answer  but this will help understand the inner workings of the available utils

User · Answer

When you have a few functions that take a callback and you want them to return a promise instead you can use this function to do the conversion   function callbackToPromise func        return function                change this to use what ever promise lib you are using            In this case i m using angular  q that I exposed on a util module          var defered   util  q defer             var cb    val    gt                defered resolve val                      var args   Array prototype slice call arguments           args push cb               func apply this  args            return defered promise

User · Answer

Promises have state  they start as pending and can settle to    fulfilled meaning that the computation completed successfully  rejected meaning that the computation failed    Promise returning functions should never throw  they should return rejections instead  Throwing from a promise returning function will force you to use both a   catch   and a  catch  People using promisified APIs do not expect promises to throw  If you re not sure how async APIs work in JS - please see this answer first   1  DOM load or other one time event   So  creating promises generally means specifying when they settle - that means when they move to the fulfilled or rejected phase to indicate the data is available  and can be accessed with  then    With modern promise implementations that support the Promise constructor like native ES6 promises   function load         return new Promise function resolve  reject            window onload   resolve              You would then use the resulting promise like so   load   then function            Do things after onload       With libraries that support deferred  Let s use  q for this example here  but we ll also use jQuery later    function load         var d    q defer        window onload   function     d resolve           return d promise      Or with a jQuery like API  hooking on an event happening once   function done         var d     Deferred            myObject   once  click  function             d resolve                return d promise        2  Plain callback   These APIs are rather common since well    callbacks are common in JS  Let s look at the common case of having onSuccess and onFail   function getUserData userId  onLoad  onFail          With modern promise implementations that support the Promise constructor like native ES6 promises   function getUserDataAsync userId        return new Promise function resolve  reject            getUserData userId  resolve  reject               With libraries that support deferred  Let s use jQuery for this example here  but we ve also used  q above    function getUserDataAsync userId        var d     Deferred        getUserData userId  function res   d resolve res      function err   d reject err           return d promise        jQuery also offers a   Deferred fn  form  which has the advantage of allowing us to write an expression that emulates very closely the new Promise fn  form  as follows   function getUserDataAsync userId        return   Deferred function dfrd            getUserData userId  dfrd resolve  dfrd reject          promise        Note  Here we exploit the fact that a jQuery deferred s resolve and reject methods are  detachable   ie  they are bound to the instance of a jQuery Deferred    Not all libs offer this feature   3  Node style callback   nodeback     Node style callbacks  nodebacks  have a particular format where the callbacks is always the last argument and its first parameter is an error  Let s first promisify one manually   getStuff  dataParam   function err  data          To   function getStuffAsync param        return new Promise function resolve  reject            getStuff param  function err  data                if  err     null  reject err               else resolve data                           With deferreds you can do the following  let s use Q for this example  although Q now supports the new syntax which you should prefer     function getStuffAsync param        var d   Q defer        getStuff param  function err  data            if  err     null  d reject err           else d resolve data               return d promise         In general  you should not promisify things manually too much  most promise libraries that were designed with Node in mind as well as native promises in Node 8  have a built in method for promisifying nodebacks  For example  var getStuffAsync   Promise promisify getStuff      Bluebird var getStuffAsync   Q denodeify getStuff      Q var getStuffAsync   util promisify getStuff      Native promises  node only   4  A whole library with node style callbacks   There is no golden rule here  you promisify them one by one  However  some promise implementations allow you to do this in bulk  for example in Bluebird  converting a nodeback API to a promise API is as simple as   Promise promisifyAll API     Or with native promises in Node   const   promisify     require  util    const promiseAPI   Object entries API  map   key  v     gt    key  fn  promisify v                               reduce  o  p    gt  Object assign o    p key   p fn           Notes    Of course  when you are in a  then handler you do not need to promisify things  Returning a promise from a  then handler will resolve or reject with that promise s value  Throwing from a  then handler is also good practice and will reject the promise - this is the famous promise throw safety   In an actual onload case  you should use addEventListener rather than onX

User · Answer

With plain old vanilla javaScript  here s a solution to promisify an api callback   function get url  callback            var xhr   new XMLHttpRequest            xhr open  get   url           xhr addEventListener  readystatechange   function                  if  xhr readyState     4                    if  xhr status     200                        console log  successful     should call callback                             callback null  JSON parse xhr responseText                      else                       console log  error     callback with error data                             callback xhr  null                                                       xhr send                       function promisify  convert api based callbacks to promises         description takes in a factory function and promisifies it         params  function  input function to promisify         params  array  an array of inputs to the function to be promisified         return  function  promisified function               function promisify fn            return function                  var args   Array prototype slice call arguments               return new Promise function resolve  reject                    fn apply null  args concat function  err  result                        if  err  reject err                       else resolve result                                                         var get promisified   promisify get   var promise   get promisified  some url    promise then function  data               corresponds to the resolve function         console log  successful operation     data      function  error            console log error

User · Answer

es6-promisify converts callback-based functions to Promise-based functions   const promisify   require  es6-promisify     const promisedFn   promisify callbackedFn  args     Ref  https   www npmjs com package es6-promisify

User · Answer

I don t think the window onload suggestion by  Benjamin will work all the time  as it doesn t detect whether it is called after the load  I have been bitten by that many times  Here is a version which should always work   function promiseDOMready         return new Promise function resolve            if  document readyState      complete   return resolve            document addEventListener  DOMContentLoaded   resolve             promiseDOMready   then initOnLoad

User · Answer

Today  I can use Promise in Node js as a plain Javascript method   A simple and basic example to Promise  with KISS way    Plain Javascript Async API code   function divisionAPI  number  divider  successCallback  errorCallback         if  divider    0            return errorCallback  new Error  Division by zero                successCallback  number   divider        Promise Javascript Async API code   function divisionAPI  number  divider         return new Promise function  fulfilled  rejected             if  divider    0                return rejected  new Error  Division by zero                        fulfilled  number   divider                  I recommend visiting this beautiful source   Also Promise can be used with together async await in ES7 to make the program flow wait for a fullfiled result like the following   function getName           return new Promise function  fulfilled  rejected             var name    John Doe               wait 3000 milliseconds before calling fulfilled   method         setTimeout                function                     fulfilled  name                               3000                        async function foo           var name   await getName       awaits for a fulfilled result       console log name      the console writes  John Doe  after 3000 milliseconds      foo      calling the foo   method to run the code   Another usage with the same code by using  then   method  function getName           return new Promise function  fulfilled  rejected             var name    John Doe               wait 3000 milliseconds before calling fulfilled   method         setTimeout                function                     fulfilled  name                               3000                           the console writes  John Doe  after 3000 milliseconds getName   then function name   console log name       Promise can also be used on any platform that is based on Node js like react-native   Bonus  An hybrid method   The callback method is assumed to have two parameters as error and result   function divisionAPI  number  divider  callback         return new Promise function  fulfilled  rejected             if  divider    0                let error   new Error  Division by zero               callback  amp  amp  callback  error               return rejected  error                      let result   number   divider         callback  amp  amp  callback  null  result           fulfilled  result                 The above method can respond result for old fashion callback and Promise usages   Hope this helps

User · Answer

You can use native Promise in ES6  for exemple dealing with setTimeout   enqueue data         const queue   this         returns the Promise     return new Promise function  resolve  reject            setTimeout     gt                    queue source push data                   resolve queue     call native resolve when finish                             10      resolve   will be called in 10 ms              In this exemple  the Promise has no reason to fail  so reject   is never called

User · Answer

My promisify version of a callback function is the P function    x000D   x000D  var P   function     x000D    var self   this  x000D    var method   arguments 0   x000D    var params   Array prototype slice call arguments  1   x000D    return new Promise  resolve  reject    gt    x000D      if  method  amp  amp  typeof method      function     x000D        params push function err  state    x000D          if   err  return resolve state  x000D          else return reject err   x000D            x000D        method apply self  params   x000D        else return reject new Error  not a function     x000D        x000D    x000D  var callback   function par  callback    x000D    var rnd   Math floor Math random     2    1  x000D    return rnd  gt  1   callback null  par    callback new Error  trap     x000D    x000D   x000D  callback  callback    err  state    gt  err   console error err    console log state   x000D  callback  callback    err  state    gt  err   console error err    console log state   x000D  callback  callback    err  state    gt  err   console error err    console log state   x000D  callback  callback    err  state    gt  err   console error err    console log state   x000D   x000D  P callback   promise   then v   gt  console log v   catch e   gt  console error e   x000D  P callback   promise   then v   gt  console log v   catch e   gt  console error e   x000D  P callback   promise   then v   gt  console log v   catch e   gt  console error e   x000D  P callback   promise   then v   gt  console log v   catch e   gt  console error e   x000D   x000D   x000D    The P function requires that the callback signature must be callback error result

User · Answer

Before converting a function as promise In Node JS  var request   require  request      http wrapped module  function requestWrapper url  callback        request get url  function  err  response          if  err            callback err          else          callback null  response                                         requestWrapper url  function  err  response        console log err  response       After Converting It  var request   require  request     function requestWrapper url      return new Promise function  resolve  reject      returning promise     request get url  function  err  response          if  err            reject err     promise reject        else          resolve response     promise resolve                         requestWrapper  http   localhost 8080 promise request 1   then function response       console log response    resolve callback success     catch function error       console log error    reject callback failure       Incase you need to handle multiple request   var allRequests       allRequests push requestWrapper  http   localhost 8080 promise request 1     allRequests push requestWrapper  http   localhost 8080 promise request 2    allRequests push requestWrapper  http   localhost 8080 promise request 5         Promise all allRequests  then function  results      console log results    result will be array which contains each promise response    catch function  err      console log err

User · Answer

Below is the implementation of how a function  callback API  can be converted to a promise   function promisify functionToExec      return function         var array   Object values arguments       return new Promise  resolve  reject    gt          array push resolve        try            functionToExec apply null  array           catch  error             reject error                           USE SCENARIO  function apiFunction  path  callback       Not a promise      Logic    var promisedFunction   promisify apiFunction    promisedFunction  path   then     gt        Receive the result here  callback         Or use it with await like this let result   await promisedFunction  path

User · Answer

Perhaps already answered  but this is how I do it typically     given you ve defined this  Future  fn somewhere  const Future   fn   gt   return new Promise  r t    gt  fn r t        define an eventFn that takes a promise  resolver  const eventFn   resolve   gt         do event related closure actions here  When finally done  call  resolve      something oneventfired   e   gt   resolve e         invoke eventFn in an  async  workflowFn using  Future     to obtain a  promise  wrapper const workflowFn   async      gt   await Future eventFn     Especially for things like indexedDb event wrappers to simplify usage   Or you might find this variation of Future to be more general purpose class PromiseEx extends Promise     resolve v    a        this settled   true  this settledValue   v      return this resolve  v    a         reject v    a        this settled   false  this settledValue   v      return this reject  v    a         static Future fn    args        let r t ft   new PromiseEx  r  t     gt   r r  t t        ft resolve    r  ft reject    t  fn ft    args       return ft

User · Answer

The callback style function always like this almost all function in node js is this style      fs readdir path   options   callback  fs readdir  mypath   err files   gt console log files     This style has same feature     the callback function is passed by last argument   the callback function always accept the error object as it s first argument     So  you could write a function for convert a function with this style like this   const R  require  ramda           A convenient function for handle error in callback function     Accept two function res resolve  and rej reject       return a wrap function that accept a list arguments     the first argument as error  if error is null     the res function will call else the rej function      param  function  res the function which will call when no error throw     param  function  rej the function which will call when  error occur     return  function  return a function that accept a list arguments     the first argument as error  if error is null  the res function    will call else the rej function      const checkErr    res  rej    gt   err     data    gt  R ifElse      R propEq  err   null       R compose          res          R prop  data              R compose          rej          R prop  err            err  data           wrap the callback style function to Promise style function     the callback style function must restrict by convention     1  the function must put the callback function where the last of arguments     such as  arg1 arg2 arg3 arg    callback     2  the callback function must call as callback err arg1 arg2 arg         param  function  fun the callback style function to transform     return  function  return the new function that will return a Promise     while the origin function throw a error  the Promise will be Promise reject error      while the origin function work fine  the Promise will be Promise resolve args  array      the args is which callback function accept        const toPromise    fun    gt      args    gt  new Promise       res  rej    gt  R apply          fun          R append              checkErr res  rej               args                     For more concise  above example used ramda js  Ramda js is a excellent library for functional programming  In above code  we used it s apply like javascript function prototype apply  and append like javascript function prototype push    So  we could convert the a callback style function to promise style function now   const  readdir    require  fs   const readdirP   toPromise readdir  readdir Path       then           files    gt  console log files            err    gt  console log err          toPromise and checkErr function is own by berserk library  it s a functional programming library fork by ramda js create by me    Hope this answer is useful for you

User · Answer

The Q library by kriskowal includes callback-to-promise functions  A method like this   obj prototype dosomething params  cb         blah blah      cb error  results       can be converted with Q ninvoke  Q ninvoke obj  dosomething  params   then function results

User · Answer

In Node js 8 you can promisify object methods on the fly using this npm module   https   www npmjs com package doasync  It uses util promisify and Proxies so that your objects stay unchanged  Memoization is also done with the use of WeakMaps   Here are some examples   With objects   const fs   require  fs    const doAsync   require  doasync     doAsync fs  readFile  package json    utf8      then result   gt        console dir JSON parse result    colors  true            With functions   doAsync request   http   www google com      then   body     gt        console log body                      You can even use native call and apply to bind some context   doAsync myFunc  apply context  params     then result   gt

User · Answer

It is like 5 years late  but I wanted to post here my promesify version which takes functions from callbacks API and turns them into promises  const promesify   fn   gt      return     params    gt         then  cbThen   gt           catch  cbCatch   gt            fn    params  cbThen  cbCatch                             Take a look to this very simple version here  https   gist github com jdtorregrosas aeee96dd07558a5d18db1ff02f31e21a

[javascript] How do I convert an existing callback API to promises?

Examples related to javascript

Examples related to node.js

Examples related to callback

Examples related to promise

Examples related to bluebird