retryOnFailure.ts

export type RetryConfig = {
  maxAttempts?: number;
  initialDelay?: number;
  maxDelay?: number;
  backoffFactor?: number;
  onRetry?: (error: Error, attempt: number) => void;
};

export async function retryOnFailure<T>(
  operation: () => Promise<T>,
  config: RetryConfig = {},
): Promise<T> {
  const {
    maxAttempts = 3,
    initialDelay = 1000,
    maxDelay = 5000,
    backoffFactor = 2,
    onRetry = () => {},
  } = config;

  let lastError: Error;
  let delay = initialDelay;

  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      return await operation();
    } catch (error) {
      lastError = error as Error;

      if (attempt === maxAttempts) {
        throw lastError;
      }

      // call the onRetry callback
      onRetry(lastError, attempt);

      // sleep before retrying
      await new Promise((resolve) => setTimeout(resolve, delay));

      // calculate next delay with exponential backoff
      delay = Math.min(delay * backoffFactor, maxDelay);
    }
  }

  throw lastError!;
}

how to use:

    const response = await retryOnFailure(
      async () => {
        return await asyncFunction()
      },
      {
        maxAttempts: 3,
        initialDelay: 500,
        onRetry: (error, attempt) => {
          console.warn(
            `Retry attempt ${attempt} for getOnDemandIxn failed:`,
            error.message,
          );
        },
      },
    );
    ```