Promise unwrapper to avoid nested try/catch blocks

promise-helper.ts

export const isAFunction = (e: unknown) => e && typeof e === "function";

export interface GenericObject {
  [key: string]: unknown;
}

export type ExecutedPromiseResponse<R> = [
  data: R | null,
  error: GenericObject | null
];

export const executePromise = async <R>(
  promiseFn: () => Promise<R>,
  finallyFn?: () => void
): Promise<ExecutedPromiseResponse<R>> => {
  try {
    const data = await promiseFn();

    return [data, null];
  } catch (error) {
    return [null, error];
  } finally {
    if (finallyFn && isAFunction(finallyFn)) {
      finallyFn();
    }
  }
};

// Usage:

const test = async () => {
  const requestSomething = () =>
    new Promise((resolve) => resolve("Hey friend!"));

  const [result, error] = await executePromise(requestSomething);
  
  if (!error) {
    // :) happiness
  }
};

test();