attempt.ts

interface Success<T> {
  data: T
  success: true
}

interface Failure<E extends Error = Error> {
  error: E
  success: false
}

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

function success<T>(data: T): Success<T> {
  return {
    data,
    success: true,
  }
}

function failure<E extends Error = Error>(error: E): Failure<E> {
  return {
    error,
    success: false,
  }
}

function transformError(value: unknown): Error {
  if (value instanceof Error)
    return value

  return new Error(String(value))
}

async function tryResolve<T, E extends Error = Error>(
  value: T | Promise<T>
): Promise<Result<Awaited<T>, E>> {
  try {
    const data = await Promise.resolve(value)

    return success(data)
  }
  catch (error) {
    return failure(transformError(error) as E)
  }
}

async function tryCall<T, E extends Error = Error>(
  fn: () => T | Promise<T>
): Promise<Result<Awaited<T>, E>> {
  try {
    const data = await Promise.resolve(fn())

    return success(data)
  }
  catch (error) {
    return failure(transformError(error) as E)
  }
}

export async function attempt<T, E extends Error = Error>(
  value: T | Promise<T> | (() => T | Promise<T>)
): Promise<Result<Awaited<T>, E>> {
  return typeof value === 'function'
    ? tryCall(value as () => T | Promise<T>)
    : tryResolve(value)
}