The default behavior of Promise.all in JavaScript is to break the full promise execution chain when one of the promises fails.

As you know, Promise.all takes in an array of promises and then returns a promise when all of the promises resolve successfully.

OR

it returns throws an error whenever one of the promises reject.

This is apparent that Promise.all does not handle all the use cases we handle in real life.

Sometimes, you might want to just continue executing the other promises even when one of the promises fail. And, the default behavior of Promise.all will definitely not work for you.

Here’s what we can do to mitigate that.

const promiseHandler = async promise => {
  try {
    const result = await promise;
    return { success: true, data, error: null };
  } catch(error) {
    return { success: false, error, data: null };
  }
};

const runTasks = () => {
  try {
    const task1 = Promise.resolve('task1 successful');
    const task2 = Promise.reject('Oops. We messed up :(');
    const task3 = Promise.resolve('task3 successful');

    const tasks = [task1, task2, task3];
    const promises = tasks.map(promiseHandler);

    return Promise.all(promises);
  } catch(error) {
    console.error(error);

    return null;
  }
};

runTasks()
  .then(console.log)
  .catch(console.error);

This is what the result will look like.

0:
  error: null
  result: "task1 successful"
  success: true
1:
  error: "Oops. We messed up :("
  result: null
  success: false
2:
  error: null
  result: "task3 successful"
  success: true

As you can see, the code actually didn’t throw any error.

Our function resolved successfully with error field as a string with the message:

Oops. We messed up :(

And the other two promises task1 and task3 resolved without an error. The task2 failed, but our code executed gracefully.