Handling try/catch in TypeScript

try-catch.ts

// Types for the result object with discriminated union
type Success<T> = [null, T];
type Failure<E> = [E, null];
type Result<T, E = Error> = Success<T> | Failure<E>;

export async function tryCatch<T, E extends Error = Error>(
  promise: Promise<T>
): Promise<Result<T, E> {
  try {
    const result = await promise;
    return [null, result];
  } catch (error) {
    return [error as E, null];
  }
}

// improved version with optional param to only catch specified errors
async function catchError<T, E extends new (message?: string) => Error>(
  promise: Promise<T>,
  errorsToCatch?: E[]
): Promise<[undefined, T] | [InstanceType<E>, undefined]> {
  return promise
    .then((data): [undefined, T] => {
      return [undefined, data];
    })
    .catch((error): [InstanceType<E>, undefined] => {
      if (errorsToCatch === undefined) {
        return [error, undefined];
      }

      if (errorsToCatch.some((e) => error instanceof e)) {
        return [error, undefined];
      }

      throw error;
    });
}

/**
 * Ex to only catch CustomError:
 * class CustomError extends Error {
 *   name = 'CustomError';
 *   message = 'ERROR: Custom message';
 *   extraProp = false;
 * }
 *
 * const [error, resp] = await catchError(somePromise, [CustomError]);
 */