A better way to handle errors

• File structure remains flat, unlike with nested try...catch
• Both data and errors are declared with const, unlike with non-nested try...catch
• Both data and errors are non-nullable, once an early return occurs if the other is null
• Both data and errors are available at the top level, unlike with try...catch or promises
• Work with errors that are always Error objects by default, without compromising type-safety, unlike with try...catch or promises
• TypeScript support with optional generic parameters for data and error types

$ npm install betterr

import { betterr, betterrSync } from 'betterr';
// const { betterr, betterrSync } = require('betterr');

const { data: user, err } = await betterr(() => getRandomUser());
//            ^?    ^? user: User | null, err: Error | null

if (err) {
  // ^? err: Error
  return;
}

return user;
//     ^? user: User

• betterr can be used with both asynchronous and synchronous callbacks
• betterrSync can only be used with synchronous callbacks, but avoids wrapping the data in a promise, so await is not necessary

Both betterr and betterrSync are generic.

• The callback return type must be assignable to the first generic parameter (for data). It defaults to the callback return type
• The second generic parameter (for error) must extend the Error object. It defaults to Error.

/**
 * const betterrSync: <TData, TError = Error>(callback: () => TData) =>
 * | { data: TData; err: null }
 * | { data: null; err: TError }
 */

const { data, err } = betterrSync<User, MyError>(() => ({
  //    ^?    ^? data: User | null, err: MyError | null
  userId: 1,
}));