alepha 0.14.2 → 0.14.4

package/src/retry/primitives/$retry.spec.ts

@@ -0,0 +1,234 @@
+import { Alepha } from "alepha";
+import { DateTimeProvider } from "alepha/datetime";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { $retry } from "../index.ts";
+
+describe("$retry", () => {
+  let alepha: Alepha;
+  let time: DateTimeProvider;
+
+  beforeEach(() => {
+    alepha = Alepha.create();
+    time = alepha.inject(DateTimeProvider);
+  });
+
+  afterEach(async () => {
+    await alepha.stop();
+  });
+
+  test("should retry handler up to max retries", async () => {
+    class Dummy {
+      inc = 0;
+      workRetry = $retry({
+        max: 3,
+        handler: (n: number, end: number) => {
+          this.inc += n;
+          if (this.inc < end) {
+            throw new Error("Retry");
+          }
+          return this.inc;
+        },
+      });
+
+      work = async (n: number, end: number) => {
+        this.inc = 0;
+        return await this.workRetry(n, end);
+      };
+    }
+
+    const basic = alepha.inject(Dummy);
+
+    expect(await basic.work(1, 2)).toBe(2);
+    expect(await basic.work(1, 3)).toBe(3);
+    await expect(() => basic.work(1, 4)).rejects.toThrow(Error);
+  });
+
+  test("should only retry when condition matches", async () => {
+    class Dummy {
+      inc = 0;
+      workRetry = $retry({
+        max: 10,
+        when: (err: Error) => err.message === "Retry1",
+        handler: (n: number, end: number) => {
+          this.inc += n;
+          if (this.inc < end) {
+            throw new Error(`Retry${this.inc}`);
+          }
+          return this.inc;
+        },
+      });
+
+      async work(n: number, end: number) {
+        this.inc = 0;
+        return await this.workRetry(n, end);
+      }
+    }
+
+    const basic = alepha.inject(Dummy);
+
+    expect(await basic.work(1, 2)).toBe(2);
+    await expect(() => basic.work(1, 3)).rejects.toThrow(Error);
+  });
+
+  test("should succeed on the first attempt", async () => {
+    const handler = vi.fn().mockResolvedValue("success");
+    const retryFunc = alepha.inject(
+      class {
+        retry = $retry({ handler });
+      },
+    ).retry;
+
+    await expect(retryFunc()).resolves.toBe("success");
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  test("should retry up to max attempts and then fail", async () => {
+    const handler = vi.fn().mockRejectedValue(new Error("Failed"));
+    const onError = vi.fn();
+
+    const retryFunc = alepha.inject(
+      class {
+        retry = $retry({ handler, max: 3, backoff: 0, onError });
+      },
+    ).retry;
+
+    await expect(retryFunc()).rejects.toThrow("Failed");
+    expect(handler).toHaveBeenCalledTimes(3);
+    expect(onError).toHaveBeenCalledTimes(3); // onError is called for ALL failed attempts, including the last one
+    expect(onError).toHaveBeenCalledWith(expect.any(Error), 1);
+    expect(onError).toHaveBeenCalledWith(expect.any(Error), 2);
+    expect(onError).toHaveBeenCalledWith(expect.any(Error), 3);
+  });
+
+  test("should succeed after a few failed attempts", async () => {
+    let attempt = 0;
+    const handler = vi.fn(() => {
+      attempt++;
+      if (attempt < 3) {
+        return Promise.reject(new Error("Try again"));
+      }
+      return Promise.resolve("success");
+    });
+
+    const retryFunc = alepha.inject(
+      class {
+        retry = $retry({ handler, max: 4, backoff: 0 });
+      },
+    ).retry;
+
+    await expect(retryFunc()).resolves.toBe("success");
+    expect(handler).toHaveBeenCalledTimes(3);
+  });
+
+  test("should respect maxDuration and time out", async () => {
+    const handler = vi.fn(async () => {
+      await time.wait(200);
+      throw new Error("Failed");
+    });
+
+    const retryFunc = alepha.inject(
+      class {
+        retry = $retry({
+          handler,
+          max: 5,
+          maxDuration: [300, "ms"],
+          backoff: 0,
+        });
+      },
+    ).retry;
+
+    await expect(retryFunc()).rejects.toThrow(
+      "Retry operation timed out after 300ms.",
+    );
+    expect(handler).toHaveBeenCalledTimes(2);
+  });
+
+  test("should be cancellable with an AbortSignal", async () => {
+    const handler = vi.fn(async () => {
+      await time.wait(500); // Long delay
+      throw new Error("Failed");
+    });
+
+    const abortController = new AbortController();
+    const retryFunc = alepha.inject(
+      class {
+        retry = $retry({
+          handler,
+          max: 5,
+          backoff: 100,
+          signal: abortController.signal,
+        });
+      },
+    ).retry;
+
+    const promise = retryFunc();
+
+    // Let the first attempt start
+    await time.travel(100);
+
+    // Abort during the first handler execution
+    abortController.abort();
+
+    await expect(promise).rejects.toThrow("Retry operation was cancelled.");
+
+    // Handler was called once but never completed
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  test("should be cancellable by application shutdown", async () => {
+    // Create a fresh alepha instance for this test
+    const testAlepha = Alepha.create();
+    const testTime = testAlepha.inject(DateTimeProvider);
+
+    const handler = vi.fn(async () => {
+      // Throw immediately to trigger retry
+      throw new Error("Failed");
+    });
+
+    const retryFunc = testAlepha.inject(
+      class {
+        retry = $retry({ handler, max: 10, backoff: 100 });
+      },
+    ).retry;
+
+    await testAlepha.start();
+
+    // Start the retry operation
+    const promise = retryFunc();
+
+    // Give it a moment to start
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Stop the application which should abort all retries
+    await testAlepha.stop();
+
+    // The promise should reject with cancellation error
+    await expect(promise).rejects.toThrow("Retry operation was cancelled.");
+
+    // Handler should have been called at least once but not 10 times
+    expect(handler).toHaveBeenCalled();
+    expect(handler.mock.calls.length).toBeLessThan(10);
+  });
+
+  test("should not retry if `when` condition returns false", async () => {
+    class CustomError extends Error {}
+    const handler = vi
+      .fn()
+      .mockRejectedValueOnce(new CustomError("Do not retry me"))
+      .mockRejectedValue(new Error("Retry me"));
+
+    const retryFunc = alepha.inject(
+      class {
+        retry = $retry({
+          handler,
+          max: 3,
+          backoff: 0,
+          when: (error) => !(error instanceof CustomError),
+        });
+      },
+    ).retry;
+
+    await expect(retryFunc()).rejects.toThrow(CustomError);
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+});

package/src/retry/providers/RetryProvider.spec.ts

@@ -0,0 +1,438 @@
+import { Alepha } from "alepha";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { RetryCancelError } from "../errors/RetryCancelError.ts";
+import { RetryTimeoutError } from "../errors/RetryTimeoutError.ts";
+import { RetryProvider } from "../providers/RetryProvider.ts";
+
+describe("RetryProvider", () => {
+  let alepha: Alepha;
+  let retryProvider: RetryProvider;
+
+  beforeEach(async () => {
+    alepha = Alepha.create();
+    retryProvider = alepha.inject(RetryProvider);
+    await alepha.start();
+  });
+
+  test("should retry handler up to max retries", async () => {
+    let attempts = 0;
+    const handler = vi.fn(() => {
+      attempts++;
+      if (attempts < 3) {
+        throw new Error("Retry");
+      }
+      return "success";
+    });
+
+    const result = await retryProvider.retry({ handler, max: 3 });
+
+    expect(result).toBe("success");
+    expect(handler).toHaveBeenCalledTimes(3);
+  });
+
+  test("should throw error after max retries exceeded", async () => {
+    const handler = vi.fn(() => {
+      throw new Error("Always fails");
+    });
+
+    await expect(retryProvider.retry({ handler, max: 3 })).rejects.toThrowError(
+      "Always fails",
+    );
+
+    expect(handler).toHaveBeenCalledTimes(3);
+  });
+
+  test("should only retry when condition matches", async () => {
+    let attempts = 0;
+    const handler = vi.fn(() => {
+      attempts++;
+      throw new Error(`Error${attempts}`);
+    });
+
+    const when = (error: Error) => error.message === "Error1";
+
+    await expect(
+      retryProvider.retry({ handler, max: 10, when }),
+    ).rejects.toThrowError("Error2");
+
+    // Should fail on second attempt because when() returns false
+    expect(handler).toHaveBeenCalledTimes(2);
+  });
+
+  test("should use fixed backoff delay", async () => {
+    const handler = vi.fn(() => {
+      throw new Error("Retry");
+    });
+
+    const startTime = Date.now();
+
+    await expect(
+      retryProvider.retry({ handler, max: 3, backoff: 100 }),
+    ).rejects.toThrowError("Retry");
+
+    const duration = Date.now() - startTime;
+
+    // Should have waited ~200ms total (2 retries × 100ms)
+    expect(duration).toBeGreaterThanOrEqual(190);
+    expect(duration).toBeLessThan(300);
+  });
+
+  test("should use exponential backoff with jitter", async () => {
+    const handler = vi.fn(() => {
+      throw new Error("Retry");
+    });
+
+    const startTime = Date.now();
+
+    await expect(
+      retryProvider.retry({
+        handler,
+        max: 3,
+        backoff: { initial: 100, factor: 2, jitter: true },
+      }),
+    ).rejects.toThrowError("Retry");
+
+    const duration = Date.now() - startTime;
+
+    // First retry: ~100ms, Second retry: ~200ms
+    // With jitter, expect at least base delays
+    expect(duration).toBeGreaterThanOrEqual(280);
+  });
+
+  test("should respect maxDuration timeout", { retry: 3 }, async () => {
+    const handler = vi.fn(() => {
+      throw new Error("Retry");
+    });
+
+    await expect(
+      retryProvider.retry({
+        handler,
+        max: 10,
+        maxDuration: [100, "milliseconds"],
+        backoff: 50,
+      }),
+    ).rejects.toThrowError(RetryTimeoutError);
+
+    // Should not reach max retries due to timeout
+    expect(handler).toHaveBeenCalledTimes(2);
+  });
+
+  test("should respect AbortSignal cancellation", async () => {
+    const handler = vi.fn(() => {
+      throw new Error("Retry");
+    });
+
+    const abortController = new AbortController();
+
+    // Abort after first attempt
+    setTimeout(() => abortController.abort(), 50);
+
+    await expect(
+      retryProvider.retry({
+        handler,
+        max: 10,
+        backoff: 100,
+        signal: abortController.signal,
+      }),
+    ).rejects.toThrowError(RetryCancelError);
+
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  test("should call onError callback on each failure", async () => {
+    let attempts = 0;
+    const handler = vi.fn(() => {
+      attempts++;
+      if (attempts < 3) {
+        throw new Error(`Attempt ${attempts}`);
+      }
+      return "success";
+    });
+
+    const onError = vi.fn();
+
+    await retryProvider.retry({ handler, max: 3, onError });
+
+    expect(onError).toHaveBeenCalledTimes(2);
+    expect(onError).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ message: "Attempt 1" }),
+      1,
+    );
+    expect(onError).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ message: "Attempt 2" }),
+      2,
+    );
+  });
+
+  test("should pass arguments to handler", async () => {
+    const handler = vi.fn((a: number, b: string) => {
+      return `${a}-${b}`;
+    });
+
+    const result = await retryProvider.retry({ handler, max: 1 }, 42, "test");
+
+    expect(result).toBe("42-test");
+    expect(handler).toHaveBeenCalledWith(42, "test");
+  });
+
+  test("should log warnings on retry failures", async () => {
+    const handler = vi.fn(() => {
+      throw new Error("Test error");
+    });
+
+    // Spy on the log method
+    // @ts-expect-error - accessing protected property for testing
+    const logSpy = vi.spyOn(retryProvider.log, "warn");
+
+    await expect(retryProvider.retry({ handler, max: 2 })).rejects.toThrowError(
+      "Test error",
+    );
+
+    expect(logSpy).toHaveBeenCalledTimes(2);
+    expect(logSpy).toHaveBeenCalledWith(
+      "Retry attempt failed",
+      expect.objectContaining({
+        attempt: 1,
+        maxAttempts: 2,
+        remainingAttempts: 1,
+        error: "Test error",
+        errorName: "Error",
+      }),
+    );
+  });
+
+  test("should support additionalSignal for combined cancellation", async () => {
+    const handler = vi.fn(() => {
+      throw new Error("Retry");
+    });
+
+    const additionalController = new AbortController();
+
+    // Abort the additional signal
+    setTimeout(() => additionalController.abort(), 50);
+
+    await expect(
+      retryProvider.retry({
+        handler,
+        max: 10,
+        backoff: 100,
+        additionalSignal: additionalController.signal,
+      }),
+    ).rejects.toThrowError(RetryCancelError);
+
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  test("should not retry on non-Error throws", async () => {
+    const handler = vi.fn(() => {
+      throw "string error";
+    });
+
+    await expect(retryProvider.retry({ handler, max: 3 })).rejects.toBe(
+      "string error",
+    );
+
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  test("should succeed on first attempt without retries", async () => {
+    const handler = vi.fn(() => "immediate success");
+
+    const result = await retryProvider.retry({ handler, max: 3 });
+
+    expect(result).toBe("immediate success");
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  test("should use default max of 3 when not specified", async () => {
+    const handler = vi.fn(() => {
+      throw new Error("Retry");
+    });
+
+    await expect(retryProvider.retry({ handler })).rejects.toThrowError(
+      "Retry",
+    );
+
+    expect(handler).toHaveBeenCalledTimes(3);
+  });
+
+  // Bug #1 (Red/Critical): Signal precedence issue
+  // When both signal and additionalSignal are provided, ONLY signal is respected during backoff
+  // This means additionalSignal (app lifecycle) cannot cancel during backoff if user signal exists
+  test("should respect both user signal and additionalSignal during backoff waits", async () => {
+    const handler = vi.fn(() => {
+      throw new Error("Retry");
+    });
+
+    const userController = new AbortController();
+    const additionalController = new AbortController();
+
+    // Start retry with both signals provided
+    const promise = retryProvider.retry({
+      handler,
+      max: 10,
+      backoff: 200, // Long backoff to ensure we have time to abort
+      signal: userController.signal,
+      additionalSignal: additionalController.signal,
+    });
+
+    // Wait for first attempt to fail and backoff to start
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Abort additionalSignal during backoff (user signal still active)
+    additionalController.abort();
+
+    // BUG: This currently does NOT throw RetryCancelError because line 169 only uses signal
+    // The additionalSignal abort is ignored during wait
+    // EXPECTED: Should throw RetryCancelError
+    // ACTUAL: Continues retrying until user signal aborts
+    const startTime = Date.now();
+
+    try {
+      await promise;
+      // If we reach here, the bug exists - additionalSignal was ignored
+      throw new Error("Should have thrown RetryCancelError");
+    } catch (error) {
+      const duration = Date.now() - startTime;
+
+      // If bug exists: continues for ~200ms+ (full backoff)
+      // If fixed: cancels immediately (~10-30ms)
+      if (error instanceof RetryCancelError) {
+        // Fixed: should cancel quickly when additionalSignal aborts
+        expect(duration).toBeLessThan(100);
+      } else {
+        // Bug exists: keeps waiting for full backoff despite additionalSignal abort
+        expect(duration).toBeGreaterThanOrEqual(180);
+      }
+    }
+  });
+
+  // Bug #2 (Yellow/High): Abort race condition
+  test("should throw RetryCancelError when aborted after handler error", async () => {
+    let attempts = 0;
+    const handler = vi.fn(() => {
+      attempts++;
+      if (attempts === 1) {
+        throw new Error("Handler failed");
+      }
+      throw new Error("Should not reach here");
+    });
+
+    const abortController = new AbortController();
+
+    // Abort immediately after first error (before backoff wait)
+    setTimeout(() => abortController.abort(), 10);
+
+    await expect(
+      retryProvider.retry({
+        handler,
+        max: 10,
+        backoff: 100,
+        signal: abortController.signal,
+      }),
+    ).rejects.toThrowError(RetryCancelError);
+
+    // Should have attempted once, then aborted
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  // Bug #3 (Yellow/High): Timeout check timing
+  test("should not allow handler to complete after maxDuration", async () => {
+    const handler = vi.fn(async () => {
+      // Handler takes 150ms
+      await new Promise((resolve) => setTimeout(resolve, 150));
+      throw new Error("Retry");
+    });
+
+    const startTime = Date.now();
+
+    await expect(
+      retryProvider.retry({
+        handler,
+        max: 10,
+        maxDuration: [100, "milliseconds"],
+        backoff: 10,
+      }),
+    ).rejects.toThrowError(RetryTimeoutError);
+
+    const duration = Date.now() - startTime;
+
+    // Should timeout around 100ms, not wait for handler to complete (150ms)
+    // With current bug, this will fail because handler completes at ~150ms
+    expect(duration).toBeLessThan(200);
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  // Bug #7 (Medium): onError not called on final attempt
+  test("should call onError on the final failed attempt", async () => {
+    const handler = vi.fn(() => {
+      throw new Error("Always fails");
+    });
+
+    const onError = vi.fn();
+
+    await expect(
+      retryProvider.retry({
+        handler,
+        max: 3,
+        backoff: 0,
+        onError,
+      }),
+    ).rejects.toThrowError("Always fails");
+
+    // Should call onError for ALL attempts, including the final one
+    // BUG: Currently only called 2 times (attempts 1-2), not 3 times
+    expect(onError).toHaveBeenCalledTimes(3);
+    expect(onError).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ message: "Always fails" }),
+      1,
+    );
+    expect(onError).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ message: "Always fails" }),
+      2,
+    );
+    expect(onError).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({ message: "Always fails" }),
+      3,
+    );
+  });
+
+  // Bug #8 (Critical): AbortSignal.any() memory leak
+  test("should not create multiple AbortSignal instances during retries", async () => {
+    const handler = vi.fn(() => {
+      throw new Error("Retry");
+    });
+
+    const userController = new AbortController();
+    const additionalController = new AbortController();
+
+    // Track how many times AbortSignal.any is called
+    const originalAny = AbortSignal.any;
+    const anySpy = vi.fn(originalAny);
+    AbortSignal.any = anySpy as any;
+
+    try {
+      await expect(
+        retryProvider.retry({
+          handler,
+          max: 5,
+          backoff: 10,
+          signal: userController.signal,
+          additionalSignal: additionalController.signal,
+        }),
+      ).rejects.toThrowError("Retry");
+
+      // BUG: Currently creates a NEW signal for each backoff (4 times for 5 attempts)
+      // EXPECTED: Should only create ONE combined signal at the start
+      expect(anySpy).toHaveBeenCalledTimes(1);
+    } finally {
+      // Restore original
+      AbortSignal.any = originalAny;
+    }
+  });
+});