feat: fixed issues #1,#2,#3 and #4

Author: navdeepm20

package.json

@@ -1,6 +1,6 @@
 {
   "name": "redo.js",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "A simple but powerful library for your retrying operations.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/index.ts

@@ -1,6 +1 @@
-export {
-  retryOperation,
-  retryAsyncOperation,
-  RetryAsyncOperation,
-  RetryOperation,
-} from "./lib/retryOperation";
+export { retryOperation, RetryOperation } from "./lib/retryOperation";

src/lib/retryOperation.ts

@@ -1,103 +1,119 @@
-interface RetryOperation {
-  retryCount: number | "infinite";
-  retryDelay: number;
-  retryCallback: (payload?: any) => any;
-  onErrorCallback: (error?: Error, currentRetryCount?: number) => void;
-  onSuccessCallback: (response?: any) => void;
-  afterLastAttemptErrorCallback?: (error?: any) => void;
+interface RetryOperation<TResponse> {
+  retryCount?: number | "infinite";
+  retryDelay?: number;
+  retryCallback?: (payload?: any) => TResponse | Promise<TResponse>;
+  onErrorCallback?: (
+    error?: Error,
+    currentRetryCount?: number
+  ) => void | Promise<void>;
+  onSuccessCallback?: (response: TResponse) => void | Promise<void>;
+  afterLastAttemptErrorCallback?: (error?: any) => void | Promise<void>;
   incrementalDelayFactor?: number; // Optional factor to increase the delay
+  logCallback?: (message: string) => void; // Optional logging mechanism
+  enableLogging?: boolean; // Enable or disable logging
+  retryCondition?: RetryCondition; // Custom condition to decide retry continuation
 }
 
-interface RetryAsyncOperationExtended extends RetryOperation {
-  retryAsyncCallback: () => Promise<void>;
-}
+type RetryCondition = (currentRetryCount: number, lastError: any) => boolean;
 
-type RetryAsyncOperation = Omit<RetryAsyncOperationExtended, "retryCallback">;
+const MAX_DELAY = 30000; // Maximum delay in milliseconds
 
 // Utility function to introduce a delay
 const sleep = (delay: number): Promise<void> => {
   return new Promise((resolve) => setTimeout(resolve, delay));
 };
 
-// Synchronous retry operation with error handling and exponential delay
-async function retryOperation({
+/**
+ * Retries a callback function with error handling and exponential delay.
+ * Supports both synchronous and asynchronous functions.
+ *
+ * @param retryCallback - The function to retry (sync/async).
+ * @param onErrorCallback - Called on each retry failure.
+ * @param onSuccessCallback - Called on successful retry.
+ * @param retryCount - Maximum retry attempts or "infinite".
+ * @param retryDelay - Initial retry delay in milliseconds.
+ * @param incrementalDelayFactor - Multiplier for delay after each retry.
+ * @param afterLastAttemptErrorCallback - Called after the last failed attempt.
+ * @param logCallback - Optional logging mechanism for debugging.
+ * @param enableLogging - Enables/disables logging (default: true).
+ * @param retryCondition - Custom condition to decide if retry should continue.
+ */
+async function retryOperation<TResponse>({
   retryCallback,
   onErrorCallback,
   onSuccessCallback,
   afterLastAttemptErrorCallback,
   retryCount = 3, // Default retry count is 3
   retryDelay = 1000, // Default is 1 second
   incrementalDelayFactor = 1.5, // Default factor is 1.5
-}: RetryOperation): Promise<void> {
+  logCallback,
+  enableLogging = true, // Default to true
+  retryCondition,
+}: RetryOperation<TResponse>): Promise<void> {
   let currentRetryCount = 0;
   let lastError: any = null;
   let currentDelay = retryDelay;
 
-  // Loop until retries are exhausted or successful
-  while (retryCount === "infinite" || currentRetryCount <= retryCount) {
-    try {
-      if (currentDelay > 0 && currentRetryCount > 0) {
-        await sleep(currentDelay); // Wait for the delay if it's not the first attempt
-      }
-
-      const response = retryCallback();
-      onSuccessCallback(response); // Call success callback on success
-      return;
-    } catch (error) {
-      lastError = error;
-      onErrorCallback(error as Error, currentRetryCount); // Handle error with retry count
-      currentDelay *= incrementalDelayFactor; // Increase the delay for the next retry
-      currentRetryCount++;
+  // Helper function to log messages if logging is enabled
+  const log = (message: string) => {
+    if (enableLogging && logCallback) {
+      logCallback(message);
     }
-  }
-
-  // Call the final error callback if retries are exhausted
-  if (afterLastAttemptErrorCallback) {
-    afterLastAttemptErrorCallback(lastError);
-  }
-}
-
-// Asynchronous retry operation with error handling and exponential delay
-async function retryAsyncOperation({
-  retryAsyncCallback,
-  onErrorCallback,
-  onSuccessCallback,
-  afterLastAttemptErrorCallback,
-  retryCount = 3, // Default retry count is 3
-  retryDelay = 1000, // Default is 1 second
-  incrementalDelayFactor = 1.5, // Default factor is 1.5
-}: RetryAsyncOperation): Promise<void> {
-  let currentRetryCount = 0;
-  let lastError: any = null;
-  let currentDelay = retryDelay;
+  };
 
   // Loop until retries are exhausted or successful
-  while (retryCount === "infinite" || currentRetryCount <= retryCount) {
+  while (
+    (retryCount === "infinite" || currentRetryCount <= retryCount) &&
+    (!retryCondition || retryCondition(currentRetryCount, lastError))
+  ) {
     try {
       if (currentDelay > 0 && currentRetryCount > 0) {
+        log(`Attempt ${currentRetryCount}: Waiting for ${currentDelay} ms`);
         await sleep(currentDelay); // Wait for the delay if it's not the first attempt
       }
 
-      const response = await retryAsyncCallback();
-      onSuccessCallback(response); // Call success callback on success
+      log(`Attempt ${currentRetryCount}: Executing callback`);
+      const response = await retryCallback();
+
+      log(`Attempt ${currentRetryCount}: Success`);
+      if (onSuccessCallback) {
+        try {
+          const successResponse = onSuccessCallback(response);
+          if (successResponse instanceof Promise) await successResponse;
+        } catch (successCallbackError) {
+          log(`Error in onSuccessCallback: ${successCallbackError}`);
+        }
+      }
       return;
     } catch (error) {
       lastError = error;
-      onErrorCallback(error as Error, currentRetryCount); // Handle error with retry count
-      currentDelay *= incrementalDelayFactor; // Increase the delay for the next retry
+      log(`Attempt ${currentRetryCount}: Failed with error: ${error}`);
+      if (onErrorCallback) {
+        try {
+          const errorResponse = onErrorCallback(
+            error as Error,
+            currentRetryCount
+          );
+          if (errorResponse instanceof Promise) await errorResponse;
+        } catch (callbackError) {
+          log(`Error in onErrorCallback: ${callbackError}`);
+        }
+      }
+      currentDelay = Math.min(currentDelay * incrementalDelayFactor, MAX_DELAY); // Increase delay
       currentRetryCount++;
     }
   }
 
   // Call the final error callback if retries are exhausted
   if (afterLastAttemptErrorCallback) {
-    afterLastAttemptErrorCallback(lastError);
+    try {
+      log(`Retries exhausted. Invoking afterLastAttemptErrorCallback`);
+      const finalErrorResponse = afterLastAttemptErrorCallback(lastError);
+      if (finalErrorResponse instanceof Promise) await finalErrorResponse;
+    } catch (finalCallbackError) {
+      log(`Error in afterLastAttemptErrorCallback: ${finalCallbackError}`);
+    }
   }
 }
 
-export {
-  retryOperation,
-  retryAsyncOperation,
-  RetryOperation,
-  RetryAsyncOperation,
-};
+export { retryOperation, RetryOperation, RetryCondition };