Theo's preferred way of handling try/catch in TypeScript

try-catch.ts

// Types for the result object with discriminated union
type Success<T> = {
  data: T;
  error: null;
};

type Failure<E> = {
  data: null;
  error: E;
};

type Result<T, E = Error> = Success<T> | Failure<E>;

// Main wrapper function
export async function tryCatch<T, E = Error>(
  promise: Promise<T>,
): Promise<Result<T, E>> {
  try {
    const data = await promise;
    return { data, error: null };
  } catch (error) {
    return { data: null, error: error as E };
  }
}

Check out safe-wrapper on github or npm, it takes a slightly different approach by returning a [error, result] tuple that works with both synchronous and asynchronous functions.

You can implement the wrapper by simply wrapping your existing functions directly or creating safe versions of them. Additionally, it lets you specify which error types to handle and even supports custom handlers or transformers for more tailored error responses.

import { safe } from 'safe-wrapper';

// ? custom error for specific error handling
class CustomError extends Error {
  constructor(message) {
    super(message);
    this.name = 'CustomError';
  }
}

// ? optional transformer function to format error
const transformer = (error) => ({
  code: error.name,
  message: error.message,
  timestamp: new Date().toISOString()
});

/**
 * safe() accepts three parameters:
 * - a function to wrap (required).
 * - an array of arguments to pass to the function (optional).
 *   - only errors matching these types will be caught and returned. anything else will be thrown.
 *   - if no arguments are provided, all errors will be caught.
 * - a callback function (transformer) to run if an error is caught (optional).
 *   - if provided, the transformer will be called with the error as its only argument.
 *   - if not provided, the error will be returned as-is.
*/

const safeAction = safe((input) => { // ? for async simply safe(async (input) => { ... });
  if (typeof input === 'undefined') {
    throw new CustomError('input cannot be undefined');
  }

  if (typeof input !== 'string') {
    throw new TypeError('input must be a string');
  }

  if (input === '') {
    // ? this error will throw as it is not in the array of errors to catch
    throw new NonExistentError('input cannot be empty');
  }
  
  return input.toUpperCase();
}, [TypeError, CustomError], transformer);

const usage = () => {
  const [error, result] = safeAction('hello world');
  if (error) {
    return handler(error);
  }

  return result;
};

This project started out as something I really needed, and since I'm primarily a JS dev, it was originally written in JavaScript. Then a friend needed a similar solution for his TypeScript codebase, so I added types via JSDoc—which made it mostly usable except for some real edge-case scenarios.

Now I'm in the process of migrating the entire thing to TypeScript. I'm still learning, so any help—be it PRs, code reviews, or suggestions—would be hugely appreciated!

Alright folks, good news for everyone using or interested in this safe-wrapper package! I've migrated the library to TypeScript for better type safety and developer experience. Quick shoutout to @t3dotgg for creating t3-chat (powered by Claude 4 Opus) which pretty much did all the heavy lifting on the migration 😶‍🌫️

It works with both async and sync functions, supports custom error types, and lets you plug in transformers to format errors just the way you need.

Check it out on github and do suggest improvements, open issues or create PRs. All contributions are welcome!

Not everything needs to be a monad like rust.
This is js where u have the power to return unions.