refactor: retry logic

Author: LeonardoVieira1630

packages/anticapture-client/dist/with-retry-and-timeout.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withRetryAndTimeout = withRetryAndTimeout;
-function isRetryable(err) {
+function isRetryable(err, timedOut) {
+    if (timedOut)
+        return true;
     const e = err;
     if (!e)
         return false;
@@ -18,16 +20,17 @@ async function withRetryAndTimeout(fn, opts) {
     let lastErr;
     while (attempt <= retries) {
         const ac = new AbortController();
-        const timer = setTimeout(() => ac.abort(), timeoutMs);
+        let timedOut = false;
+        const timer = setTimeout(() => { timedOut = true; ac.abort(); }, timeoutMs);
         try {
             return await fn(ac.signal);
         }
         catch (err) {
             lastErr = err;
-            if (!isRetryable(err) || attempt === retries)
+            if (!isRetryable(err, timedOut) || attempt === retries)
                 throw err;
             const delay = baseDelayMs * 2 ** attempt;
-            console.warn(`[AnticaptureClient] Retry ${attempt + 1}/${retries} after error: ${err.message}`);
+            console.warn(`[AnticaptureClient] Retry ${attempt + 1}/${retries} after ${timedOut ? 'timeout' : 'error'}: ${err.message}`);
             await sleep(delay);
             attempt += 1;
         }

packages/anticapture-client/package.json

@@ -4,6 +4,16 @@
   "description": "Shared AnticaptureClient for REST SDK communication",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./test-doubles": {
+      "types": "./dist/test-doubles.d.ts",
+      "default": "./dist/test-doubles.js"
+    }
+  },
   "files": [
     "dist"
   ],

packages/anticapture-client/src/with-retry-and-timeout.ts

@@ -4,7 +4,8 @@ export interface RetryOptions {
   baseDelayMs?: number; // default 1000
 }
 
-function isRetryable(err: unknown): boolean {
+function isRetryable(err: unknown, timedOut: boolean): boolean {
+  if (timedOut) return true;
   const e = err as { status?: number; code?: string };
   if (!e) return false;
   if (e.code === 'ECONNRESET' || e.code === 'ETIMEDOUT' || e.code === 'ENETUNREACH') return true;
@@ -23,14 +24,15 @@ export async function withRetryAndTimeout<T>(
   let lastErr: unknown;
   while (attempt <= retries) {
     const ac = new AbortController();
-    const timer = setTimeout(() => ac.abort(), timeoutMs);
+    let timedOut = false;
+    const timer = setTimeout(() => { timedOut = true; ac.abort(); }, timeoutMs);
     try {
       return await fn(ac.signal);
     } catch (err) {
       lastErr = err;
-      if (!isRetryable(err) || attempt === retries) throw err;
+      if (!isRetryable(err, timedOut) || attempt === retries) throw err;
       const delay = baseDelayMs * 2 ** attempt;
-      console.warn(`[AnticaptureClient] Retry ${attempt + 1}/${retries} after error: ${(err as Error).message}`);
+      console.warn(`[AnticaptureClient] Retry ${attempt + 1}/${retries} after ${timedOut ? 'timeout' : 'error'}: ${(err as Error).message}`);
       await sleep(delay);
       attempt += 1;
     } finally {

packages/anticapture-client/tests/with-retry-and-timeout.test.ts

@@ -37,11 +37,26 @@ describe('withRetryAndTimeout', () => {
     expect(fn).toHaveBeenCalledTimes(3); // initial + 2 retries
   });
 
-  it('aborts and throws on timeout', async () => {
+  it('aborts and throws on timeout when no retries left', async () => {
     const fn = vi.fn((signal?: AbortSignal) => new Promise((_, reject) => {
       signal?.addEventListener('abort', () => reject(new Error('aborted')));
     }));
     await expect(withRetryAndTimeout(fn, { retries: 0, timeoutMs: 10 }))
       .rejects.toThrow();
   });
+
+  it('retries on timeout and eventually succeeds', async () => {
+    let attempts = 0;
+    const fn = vi.fn((signal?: AbortSignal) => new Promise<string>((resolve, reject) => {
+      attempts += 1;
+      if (attempts < 3) {
+        signal?.addEventListener('abort', () => reject(new Error('aborted')));
+        return;
+      }
+      resolve('ok');
+    }));
+    const result = await withRetryAndTimeout(fn, { retries: 4, timeoutMs: 10, baseDelayMs: 1 });
+    expect(result).toBe('ok');
+    expect(fn).toHaveBeenCalledTimes(3);
+  });
 });