Fulfill (don’t resolve) promise with another promise

by

There doesn’t seem to be a solution apart from the workaround I already described in the question. For future reference, if you want to fulfill (rather than resolve) a promise p with a value val, where val is another promise, then just calling the promise resolution function for p with argument val won’t work as expected. It would cause p to be “locked in” on the state of val, such that p will be fulfilled with val‘s resolution value once val is fulfilled (see spec).

Instead, wrap val in another object and resolve p with that object:

var resolveP;  // Promise resolution function for p

var p = new Promise(
    function(resolve, reject) {
        resolveP = resolve;
    }
);

function fulfillPwithPromise(val) {  // Fulfills p with a promise val
    resolveP({promise: val});
}

p.then(function(res) {
    // Do something as soon as p is fulfilled...

    return res.promise;
}).then(function(res) {
    // Do something as soon as the second promise is fulfilled...
});

This solution works if you already know that val is a promise. If you cannot make any assumptions about val‘s type, then you seem to be out of luck. Either you have to always wrap promise resolution values in another object, or you can try to detect whether val has a field then of type “function” and wrap it conditionally.

That said, in some cases the default behavior of promise resolution may actually have the desired effect. So only use the workaround described above if you are sure that you want to fulfill instead of resolve the first promise with the second one.

More Related Contents:

  1. How to return many Promises and wait for them all before doing other stuff
  2. ES6 promise settled callback?
  3. When is the body of a Promise executed?
  4. ES6 Promise.all() error handle – Is .settle() needed? [duplicate]
  5. ES6 Promises – something like async.each?
  6. Filtering an array with a function that returns a promise
  7. Why is the response object from JavaScript fetch API a promise?
  8. Why does the Promise constructor require a function that calls ‘resolve’ when complete, but ‘then’ does not – it returns a value instead?
  9. What is the best general practice to timeout a function in promise [closed]
  10. When would someone need to create a deferred?
  11. ES6 promise execution order for returned values
  12. Promises, pass additional parameters to then chain
  13. How to extract data out of a Promise
  14. What happens if you don’t resolve or reject a promise?
  15. Are JavaScript forever-pending promises bad?
  16. Why does javascript ES6 Promises continue execution after a resolve?
  17. using await on global scope without async keyword
  18. ES6 Promise replacement of async.eachLimit / async.mapLimit
  19. Why does JavaScript Promise then handler run after other code?
  20. When is the body of a Promise constructor callback executed?
  21. Arrow function without curly braces
  22. How do I destructure all properties into the current scope/closure in ES2015?
  23. How can I mock an ES6 module import using Jest?
  24. Resolve Javascript Promise outside the Promise constructor scope
  25. What is the difference between using constructor vs state = {} to declare state in react component?
  26. Javascript ES6 export const vs export let
  27. How to use javascript proxy for nested objects
  28. How to call another function within the same object?
  29. React cannot read property map of undefined
  30. What is the technical definition of a Javascript iterable and how do you test for it?

Leave a Comment