Correct error handling of nested async functions with promise

Question

Let's take this example async function, asyncFunction, which takes a Boolean parameter res. if res is true, the promise will resolve with the string "success". if res is false, the promise will reject with an error object containing the string "success".

const asyncFunction = (res) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (res) return resolve("Success");
      return reject(new Error("Error"));
    }, 1000);
  });
};

I am calling asyncFunction from the function innerFunction when uses a try-catch block. So far so good.

const innerFunction = async () => {
  try {
    return await asyncFunction(false); //Will reject
  } catch (error) {
    console.log("caught error inside innerFunction");
    return error;
  }
};

In outerFunction, I'm executing

const outerFunction = async () => {
  try {
    const result = await innerFunction();
    console.log(result);
  } catch (error) {
    console.log("caught error inside outerFunction");
    console.log(error);
  }
};

Finally, I'm running outer function.

outerFunction();

I expected both catch blocks to catch the error and I was wrong. I guess that you can't catch the same exception twice? I'm not sure but my guess is that the Error object, behind the scenes, gets flagged as a "handled" error and therefore does not get recognized as one in outerFunction. (I would love some insight on this!)

My solution is to throw a new error in innerFunction:

const innerFunction = async () => {
  try {
    return await asyncFunction(false); //Will reject
  } catch (error) {
    console.log("caught error inside innerFunction");
    throw new Error(error);
  }
};

I apologize for the length, but finally, my question is: is this a "correct" way of handling a situation where I must handle the error in outerFunction? Is there any "better" way to do this?

Thank you!

Mulan · Accepted Answer · 2021-05-13 14:30:43Z

1

No you cannot catch same error twice. The method of relaying error will be buggy. instead what I would do is to just forward the outputs and handle them in the outer function.

const innerFunction = async () => asyncFunction(false); // <-- Just return the outputs
const outerFunction = async () => {
  try {
    const result = await innerFunction(); // <-- Error is forwarded and thus handled
  } catch (error) {
    console.log("Caught error inside outerFunction");
  }
};

edited May 13, 2021 at 14:30

Mulan

136k35 gold badges240 silver badges276 bronze badges

answered May 13, 2021 at 5:25

Kabeer Jaffri

7181 gold badge9 silver badges9 bronze badges

Sign up to request clarification or add additional context in comments.

Collectives™ on Stack Overflow

Correct error handling of nested async functions with promise

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related