How to return from a Promise’s catch/then block?

by

This can’t be achieved with features of the language. However, pattern-based solutions are available.

Here are two solutions.

Rethrow previous error

This pattern is basically sound … 

Promise.resolve()
.then(Function1).catch(errorHandler1)
.then(Function2).catch(errorHandler2)
.then(Function3).catch(errorHandler3)
.then(Function4).catch(errorHandler4)
.catch(finalErrorHandler);

Promise.resolve() is not strictly necessary but allows all the .then().catch() lines to be of the same pattern, and the whole expression is easier on the eye.

… but :

  • if an errorHandler returns a result, then the chain will progress to the next line’s success handler.
  • if an errorHandler throws, then the chain will progress to the next line’s error handler.

The desired jump out of the chain won’t happen unless the error handlers are written such that they can distinguish between a previously thrown error and a freshly thrown error. For example :

function errorHandler1(error) {
    if (error instanceof MyCustomError) { // <<<<<<< test for previously thrown error 
        throw error;
    } else {
        // do errorHandler1 stuff then
        // return a result or 
        // throw new MyCustomError() or 
        // throw new Error(), new RangeError() etc. or some other type of custom error.
    }
}

Now :

  • if an errorHandler returns a result, then the chain will progress to the next FunctionN.
  • if an errorHandler throws a MyCustomError, then it will be repeatedly rethrown down the chain and caught by the first error handler that does not conform to the if(error instanceof MyCustomError) protocol (eg a final .catch()).
  • if an errorHandler throws any other type of error, then the chain will progress to the next catch.

This pattern would be useful if you need the flexibility to skip to end of chain or not, depending on the type of error thrown. Rare circumstances I expect.

DEMO

Insulated Catches

Another solution is to introduce a mechanism to keep each .catch(errorHandlerN) “insulated” such that it will catch only errors arising from its corresponding FunctionN, not from any preceding errors.

This can be achieved by having in the main chain only success handlers, each comprising an anonymous function containing a subchain.

Promise.resolve()
.then(function() { return Function1().catch(errorHandler1); })
.then(function() { return Function2().catch(errorHandler2); })
.then(function() { return Function3().catch(errorHandler3); })
.then(function() { return Function4().catch(errorHandler4); })
.catch(finalErrorHandler);

Here Promise.resolve() plays an important role. Without it, Function1().catch(errorHandler1) would be in the main chain the catch() would not be insulated from the main chain.

Now,

  • if an errorHandler returns a result, then the chain will progress to the next line.
  • if an errorHandler throws anything it likes, then the chain will progress directly to the finalErrorHandler.

Use this pattern if you want always to skip to the end of chain regardless of the type of error thrown. A custom error constructor is not required and the error handlers do not need to be written in a special way.

DEMO

Usage cases

Which pattern to choose will determined by the considerations already given but also possibly by the nature of your project team.

  • One-person team – you write everything and understand the issues – if you are free to choose, then run with your personal preference.
  • Multi-person team – one person writes the master chain and various others write the functions and their error handlers – if you can, opt for Insulated Catches – with everything under control of the master chain, you don’t need to enforce the discipline of writing the error handlers in that certain way.

More Related Contents:

  1. How to return many Promises and wait for them all before doing other stuff
  2. Why does .json() return a promise?
  3. async/await always returns promise
  4. How to turn this callback into a promise using async/await?
  5. Asynchronous exception handling with bluebird promises
  6. What is the difference between JavaScript promises and async await?
  7. How to wait for a JavaScript Promise to resolve before resuming function?
  8. Should an async API ever throw synchronously?
  9. Node JS Promise.all and forEach
  10. $.Deferred: How to detect when every promise has been executed
  11. How to async await in react render function?
  12. What does $.when.apply($, someArray) do?
  13. Why does the Promise constructor need an executor?
  14. Why can I not throw inside a Promise.catch handler?
  15. How to block for a javascript promise and return the resolved result? [duplicate]
  16. using async await and .then together
  17. How to implement a pseudo blocking async queue in JS/TS?
  18. Are JavaScript Promise asynchronous?
  19. Javascript – if with asynchronous case
  20. Using mongoose promises with async/await
  21. What are asynchronous functions in JavaScript? What is “async” and “await” in JavaScript?
  22. map() function with async/await
  23. How to use Promise.all with an object as input
  24. Javascript Asynchronous Exception Handling with node.js
  25. Why are javascript promises asynchronous when calling only synchronous functions?
  26. Produce a promise which depends on recursive promises
  27. When does async function actually return a pending promise?
  28. Properly batch nested promises in Node
  29. JavaScript asynchronous programming: promises vs generators
  30. Promise.all is returning an array of undefined and resolves before being done

Leave a Comment