Brandon Brandon - 5 days ago 6
Javascript Question

Catching errors from nested async/await functions

I have a function chain in a

node 4.3
script that looks something like, callback -> promise -> async/await -> async/await -> async/await

like so:

const topLevel = (resolve, reject) => {
const foo = doThing(data)
.then(results => {
resolve(results)
})
.catch(err => {
reject(err)
})
}

async function doThing(data) {
const thing = await doAnotherThing(data)
return thing
}

async function doAnotherThing(data) {
const thingDone = await etcFunction(data)
return thingDone
}


(The reason it isn't
async/await
all the way through is that the top level function is a task queue library, and ostensibly can't be run
async/await
style)

If
etcFunction()
throws, does the
error
bubble up all the way to the top-level
Promise
?

If not, how can I bubble-up
errors
? Do I need to wrap each
await
in a
try/catch
and
throw
from there, like so?

async function doAnotherThing(data) {
try {
await etcFunction(data)
} catch(err) {
throw err
}
}

Answer

If etcFunction() throws, does the error bubble up all the way through the async functions?

Yes. The promise returned by the outermost function will be rejected. There's no need to do try { … } catch(e) { throw e; }, that's just as pointless as it would be in synchronous code.

… bubble up all the way to the top-level Promise?

No. Your topLevel contains multiple mistakes. If you don't return the doThing(data) from the then callback, it will be ignored (not even awaited) and the rejection stays unhandled. You'll have to use

.then(data => { return doThing(data); })
// or
.then(data => doThing(data))
// or just
.then(doThing) // recommended

And in general, your function should look like this:

function toplevel(onsuccess, onerror) {
    makePromise()
    .then(doThing)
    .then(onsuccess, onerror);
}

No unnecessary function expressions, no .then(…).catch(…) antipattern (that could lead to onsuccess and onerror to both be called).

Comments