Promises are resolved using a then/catch block like so:

myPromise
  .then((data) => {
    // promise resolved
    doStuff(data);
  })
  .catch((error) => {
    // promise rejected
    throw error;
  });

The async/await keywords came along, and handling promises became a little easier, the code above can now be written like this:

try {
  const data = await myPromise;
  // promise resolved
  doStuff(data);
} catch (error) {
  // promise rejected
  throw error;
}

While this is arguably better, the try/catch block becomes really tiring to write after a while, so I've taken some inspiration from node to simplify this code a little bit. Node uses an idiomatic pattern called Error-first callbacks. By convention, callbacks get two parameters: the first one is the error, and the second one is the data. Our examples above also have an error and a data, so let's see how we can rewrite this:

const doAwait = async (promise) => {
  try {
    const data = await promise;
    return [undefined, data];
  } catch (error) {
    return [error, undefined];
  }
};

The doAwait function takes a promise, and returns an array with two elements, the first one is the error, and the second one is the data.

Using this simple function spares developers from writing try/catch blocks over and over again, and can just destructure the returned value into an array, and handle the error in a way that is similar to how callbacks are written in node:

const [error, result] = await doAwait(myPromise);

if (error) {
  throw error;
}

doStuff(result);

I find this little function quite handy, and the npm package to-await actually does just that, and it also provides a handy utility to resolve an array of promises! Visit its README for more code examples.