Try-catch helper for promises and async/await

try-catch.ts

export default async function tryCatch<Data>(
  promise: Promise<Data>,
): Promise<{ error: Error } | { data: Data }> {
  try {
    return { data: await promise };
  } catch (error) {
    return { error };
  }
}

Here you go, destructuring works like a charm now 🎉
Try in TS Playground

export default async function tryCatch<T>(
  promise: Promise<T>
): Promise<{ error?: Error; data?: T }> {
  try {
    return { data: await promise };
  } catch (error) {
    return { error };
  }
}

(async function a() {
  const {error, data} = await tryCatch(fetch(""));

 console.log(error, data);
})();

Nice, good job! 🎉

The only reason that I tend to avoid this pattern is because then you cannot properly narrow the type of data.

As soon as you destructure, TypeScript "forgets" the association between error and data, meaning that you'll need to check whether data exists every time (see the | undefined part?):

Drat! you are spot on.

I'm just debating with myself if I can live with the following? What do you reckon @karlhorky?

const fn = async () => {
  const promise = fetch(`https://cdn2.thecatapi.com/images/lm.jpg`);

  const { error, data } = await tryCatch(promise);

  if (error) return handleError(error);

  const stuff = await data?.json();

  doSomethingWith(stuff);
};

Yeah, I started with this pattern too, using the optional chaining. I think it's not so bad for one usage!

But if you've got a long file where you're using data in a lot of places, then it may be worth it to consider avoiding the destructuring in the first step. That's where I ended up with most of my code.

I'm going to go with optional chaining as I tend to keep my functions small, let's see how it goes.

Great chatting to you.

Thanks, I enjoyed the journey too! 🙌

Hi @karlhorky, is it okay if I create an npm package for that with tests?

You're free to take the code and publish a package :) Just be aware, there are a number of very similar packages already:

• https://www.npmjs.com/package/try-to-catch
• https://www.npmjs.com/package/@casperengl/try-catch
• https://www.npmjs.com/package/try-catch-js
• https://www.npmjs.com/package/trycatch (closest to ES Proposal, also supports synchronous mode)
• https://www.npmjs.com/package/await-to-js
• https://www.npmjs.com/package/try-catch-expression
• https://www.npmjs.com/package/try-catch
• https://www.npmjs.com/package/try.catch

TS 4.4 may no longer "forget" the type information after destructuring: https://twitter.com/sebastienlorber/status/1409543348461965314?s=19

Ok, this is true for a single variable, but it doesn't apply for multiple variables being destructured: https://stackoverflow.com/a/59786171/1268612

It looks like this is actually a separate feature request called "Correlated Unions" by jcalz here: microsoft/TypeScript#30581

Seems like this may be in TypeScript 4.6, since this PR got merged:

microsoft/TypeScript#46266

Thanks @karlhorky