retryable-operation/src/lib/retry.ts

a simple package that allow executing retryable operation and providing retry options

import {
  AttemptedFunction,
  RetryableOperation,
  RetryOptions,
  OperationResult,
} from "./retryable-operation";

export function operation<T = unknown, E = unknown>(options: RetryOptions<T>) {
  return new RetryableOperation<T, E>(options);
}

type BaseWrapOptions<T> = Omit<RetryOptions<T>, "fn">;

export interface AutoWrapOptions<T> extends BaseWrapOptions<T> {
  autoAttempt?: true;
}
export type WrapOptions<T> = BaseWrapOptions<T> | AutoWrapOptions<T>;

export function wrap<T = unknown, E = unknown>(
  fn: AttemptedFunction<T>,
  options: BaseWrapOptions<T>
): RetryableOperation<T, E>;

export function wrap<T = unknown, E = unknown>(
  fn: AttemptedFunction<T>,
  options: AutoWrapOptions<T>
): Promise<OperationResult<T, E>>;

export function wrap<T = unknown, E = unknown>(
  fn: AttemptedFunction<T>,
  options: WrapOptions<T>
) {
  const op = operation<T, E>({ ...options, fn });
  if ("autoAttempt" in options) return op.attempt();
  return op;
}

export function retryable<T>(options?: BaseWrapOptions<T>) {
  return function (_: any, _1: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;
    descriptor.value = function (...args: any[]) {
      const op = operation({
        fn: originalMethod as AttemptedFunction<T>,
        ...(options ?? {}),
        args,
      });
      return op.attempt();
    };
    return descriptor;
  };
}

export { RetryableOperation, RetryOptions };