simplify asyncmutex definition -- don't support generic operations

anymore

Author: pujitm

packages/unraid-shared/src/util/__tests__/processing.test.ts

@@ -291,21 +291,5 @@ describe('AsyncMutex', () => {
       expect(result).toBe('outer');
       expect(outerOp).toHaveBeenCalledTimes(1);
     });
-
-    it('should maintain type safety with generic operations', async () => {
-      const mutex = new AsyncMutex<string>();
-      
-      const stringOp = vi.fn().mockResolvedValue('string');
-      const numberOp = vi.fn().mockResolvedValue(42);
-      const booleanOp = vi.fn().mockResolvedValue(true);
-
-      const stringResult: string = await mutex.do(stringOp);
-      const numberResult: number = await mutex.do(numberOp);
-      const booleanResult: boolean = await mutex.do(booleanOp);
-
-      expect(stringResult).toBe('string');
-      expect(numberResult).toBe(42);
-      expect(booleanResult).toBe(true);
-    });
   });
-});
+});

packages/unraid-shared/src/util/processing.ts

@@ -66,7 +66,7 @@ type AsyncOperation<T> = () => Promise<T>;
  * const data2 = await dataLoader.do(); // If first promise is finished, a new fetch is executed
  */
 export class AsyncMutex<T = unknown> {
-  private currentOperation: Promise<any> | null = null;
+  private currentOperation: Promise<T> | null = null;
   private defaultOperation?: AsyncOperation<T>;
 
   /**
@@ -97,12 +97,6 @@ export class AsyncMutex<T = unknown> {
     this.defaultOperation = operation;
   }
 
-  /**
-   * Executes the default operation if one was provided in the constructor.
-   * @returns Promise that resolves with the result of the default operation
-   * @throws Error if no default operation was set in the constructor
-   */
-  do(): Promise<T>;
   /**
    * Executes the provided operation, ensuring only one runs at a time.
    *
@@ -126,32 +120,29 @@ export class AsyncMutex<T = unknown> {
    * await promise1;
    * const newPromise = mutex.do(() => fetch('/api/new')); // This will execute
    */
-  do<U>(operation: AsyncOperation<U>): Promise<U>;
-  do<U = T>(operation?: AsyncOperation<U>): Promise<U | T> {
-    if (!operation && !this.defaultOperation) {
+  do(operation?: AsyncOperation<T>): Promise<T> {
+    if (this.currentOperation) {
+      return this.currentOperation;
+    }
+    const op = operation ?? this.defaultOperation;
+    if (!op) {
       return Promise.reject(
         new Error("No operation provided and no default operation set")
       );
     }
-
-    if (this.currentOperation) {
-      return this.currentOperation;
-    }
-
-    const op = (operation || this.defaultOperation) as AsyncOperation<U | T>;
     const safeOp = () => {
       try {
         return op();
       } catch (error) {
         return Promise.reject(error);
       }
     };
+
     const promise = safeOp().finally(() => {
       if (this.currentOperation === promise) {
         this.currentOperation = null;
       }
     });
-
     this.currentOperation = promise;
     return promise;
   }