fetch-retrier 0.1.8 → 0.2.0

package/README.md

@@ -2,12 +2,18 @@
 
 A lightweight wrapper around `fetch` that adds **retries**, **timeout**, and **full jitter** backoff. Useful for calling HTTP APIs that may be rate-limited (429) or temporarily unavailable (5xx).
 
+[![npm version](https://img.shields.io/npm/v/fetch-retrier.svg)](https://www.npmjs.com/package/fetch-retrier)
+[![npm downloads](https://img.shields.io/npm/dm/fetch-retrier.svg)](https://www.npmjs.com/package/fetch-retrier)
+[![build](https://github.com/gammarers-labs/fetch-retrier/actions/workflows/build.yml/badge.svg)](https://github.com/gammarers-labs/fetch-retrier/actions/workflows/build.yml)
+[![release](https://github.com/gammarers-labs/fetch-retrier/actions/workflows/release.yml/badge.svg)](https://github.com/gammarers-labs/fetch-retrier/actions/workflows/release.yml)
+
 ## Features
 
 - **Configurable retries** – Set the maximum number of attempts per request.
 - **Per-request timeout** – Abort requests that exceed a given duration.
 - **Full jitter backoff** – Exponential backoff with random jitter (AWS-style) between retries.
 - **Custom retry predicate** – Control which status codes trigger a retry (default: 429, 500, 502, 503, 504).
+- **External cancellation** – Pass an `AbortSignal` to cancel an in-flight request.
 - **TypeScript** – Exported types for `RequestOptions` and usage in TS/JS.
 
 ## Installation
@@ -54,6 +60,7 @@ if (response.ok) {
 | `timeoutMs` | `number` | Yes | Timeout in milliseconds for each request. Requests are aborted when this is exceeded. |
 | `baseBackoffMs` | `number` | Yes | Base delay in milliseconds for backoff. Delay is capped at `baseBackoffMs * 2^attempt` and randomized (full jitter). |
 | `headers` | `Record<string, string>` | No | Headers to send with the request. |
+| `signal` | `AbortSignal` | No | Optional external abort signal. If already aborted, `FetchRetrierAlreadyAbortedError` is thrown. If aborted during an attempt, the request is aborted and retried until `retries` is exhausted. |
 | `shouldRetry` | `(response: Response, body: string) => boolean` | No | Custom predicate. Return `true` to retry on this response. Default: retry on status 429, 500, 502, 503, 504. |
 
 ### Custom retry logic
@@ -72,13 +79,29 @@ const response = await fetchRetrier('https://api.example.com/data', {
 });
 ```
 
+### Cancellation with `AbortController`
+
+```typescript
+const controller = new AbortController();
+
+setTimeout(() => controller.abort(), 250);
+
+await fetchRetrier('https://api.example.com/data', {
+  retries: 3,
+  timeoutMs: 5000,
+  baseBackoffMs: 250,
+  signal: controller.signal,
+});
+```
+
 ## Retry and error behavior
 
 - **Success** – If `response.ok` is true, the response is returned immediately.
-- **Retriable failure** – If the response is not OK and `shouldRetry(response, body)` returns true, the client waits (full jitter backoff) and retries until `retries` is exhausted. On the last attempt, an error is thrown with the HTTP status.
-- **Non-retriable failure** – If `shouldRetry` returns false, an error is thrown immediately (e.g. `Non-retriable HTTP error: 404`).
-- **Timeout** – If a request exceeds `timeoutMs`, it is aborted and retried (same backoff) until `retries` is exhausted.
-- **Network/TypeError** – Network errors and related `TypeError`s are retried with backoff; after the last attempt, the error is rethrown.
+- **Retriable failure** – If the response is not OK and `shouldRetry(response, body)` returns true, the client waits (full jitter backoff) and retries until `retries` is exhausted. On the last attempt, `FetchRetrierHttpError` is thrown (includes `status`).
+- **Non-retriable failure** – If `shouldRetry` returns false, `FetchRetrierHttpError` is thrown immediately (e.g. message `Non-retriable HTTP error: 404`).
+- **Timeout** – If a request exceeds `timeoutMs`, it is aborted and retried (same backoff) until `retries` is exhausted; the final failure is `FetchRetrierAbortError`.
+- **Network/TypeError** – Network errors and related `TypeError`s are retried with backoff; after the last attempt, `FetchRetrierNetworkError` is thrown with the original error as `cause`.
+- **Already aborted signal** – If `signal` is already aborted before an attempt starts, `FetchRetrierAlreadyAbortedError` is thrown immediately (no attempt is made).
 
 ## Requirements
 
@@ -87,4 +110,4 @@ const response = await fetchRetrier('https://api.example.com/data', {
 
 ## License
 
-This project is licensed under the Apache-2.0 License.
+This project is licensed under the (Apache-2.0) License.

package/lib/index.d.ts

@@ -1,21 +1,88 @@
 /**
- * request Options
+ * Configuration for {@link fetchRetrier}.
  */
 export interface RequestOptions {
+    /** Optional HTTP headers sent with each attempt. */
     headers?: Record<string, string>;
+    /** Maximum number of attempts, including the first. */
     retries: number;
+    /** Per-attempt timeout in milliseconds; uses an internal {@link AbortController} when exceeded. */
     timeoutMs: number;
+    /**
+     * Base backoff in milliseconds for full jitter. The cap for attempt `n` is `baseBackoffMs * 2^n`.
+     */
     baseBackoffMs: number;
     /**
-     * Custom predicate: return true to retry on this response.
-     * Default: retry on 429, 500, 502, 503, 504
+     * Optional external {@link AbortSignal}. When aborted, the in-flight request is aborted; on the
+     * final attempt, cancellation surfaces as {@link FetchRetrierAbortError}.
+     */
+    signal?: AbortSignal;
+    /**
+     * Return `true` to schedule another attempt for this non-OK response.
+     * Default: retry on status 429, 500, 502, 503, or 504.
      */
     shouldRetry?: (response: Response, body: string) => boolean;
 }
+/** Error thrown when a request is cancelled by timeout or an external {@link AbortSignal}. */
+export declare class FetchRetrierAbortError extends Error {
+    readonly name: string;
+    /**
+     * @param message - Human-readable reason (default: `'Aborted'`)
+     */
+    constructor(message?: string);
+}
+/**
+ * Error thrown when {@link RequestOptions.signal} is already aborted before an attempt starts.
+ */
+export declare class FetchRetrierAlreadyAbortedError extends FetchRetrierAbortError {
+    readonly name: string;
+    /**
+     * @param message - Human-readable reason (default: `'Signal was already aborted'`)
+     */
+    constructor(message?: string);
+}
+/** Error thrown when the server returns a non-OK HTTP status and no further retry is performed. */
+export declare class FetchRetrierHttpError extends Error {
+    readonly status: number;
+    readonly name: string;
+    /**
+     * @param message - Error description
+     * @param status - HTTP status code from the response
+     */
+    constructor(message: string, status: number);
+}
+/**
+ * Error thrown when a fetch fails with a network-level error (e.g. DNS failure, connection refused).
+ */
+export declare class FetchRetrierNetworkError extends Error {
+    readonly cause?: unknown | undefined;
+    readonly name: string;
+    /**
+     * @param message - Human-readable reason (default: `'Network error'`)
+     * @param cause - Original error, if any
+     */
+    constructor(message?: string, cause?: unknown | undefined);
+}
+/** Error thrown when an internal invariant fails (should not happen in normal use). */
+export declare class FetchRetrierUnreachableError extends Error {
+    readonly name: string;
+    /**
+     * @param message - Human-readable reason (default: `'Unreachable'`)
+     */
+    constructor(message?: string);
+}
 /**
- * retry + timeout + Full Jitter
- * @param url - The URL to fetch
- * @param options - The options for the fetch
- * @returns The response
+ * Performs `fetch` with retries, a per-attempt timeout, exponential backoff with full jitter,
+ * optional {@link RequestOptions.signal} cancellation, and a configurable retry predicate for
+ * non-OK responses.
+ *
+ * @param url - Request URL
+ * @param options - Retries, backoff, timeout, optional abort signal, and optional retry predicate
+ * @returns The first successful (OK) {@link Response}
+ * @throws {FetchRetrierAlreadyAbortedError} If `options.signal` is already aborted before an attempt
+ * @throws {FetchRetrierHttpError} On a non-OK response that is not retried or after the last attempt
+ * @throws {FetchRetrierNetworkError} On a network error on the final attempt
+ * @throws {FetchRetrierAbortError} On timeout or external abort on the final attempt
+ * @throws {FetchRetrierUnreachableError} If the retry loop exits without returning (internal bug)
  */
 export declare const fetchRetrier: (url: string, options: RequestOptions) => Promise<Response>;

package/lib/index.js

@@ -1,26 +1,116 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchRetrier = void 0;
+exports.fetchRetrier = exports.FetchRetrierUnreachableError = exports.FetchRetrierNetworkError = exports.FetchRetrierHttpError = exports.FetchRetrierAlreadyAbortedError = exports.FetchRetrierAbortError = void 0;
+/** Error thrown when a request is cancelled by timeout or an external {@link AbortSignal}. */
+class FetchRetrierAbortError extends Error {
+    /**
+     * @param message - Human-readable reason (default: `'Aborted'`)
+     */
+    constructor(message = 'Aborted') {
+        super(message);
+        this.name = 'FetchRetrierAbortError';
+        Object.setPrototypeOf(this, FetchRetrierAbortError.prototype);
+    }
+}
+exports.FetchRetrierAbortError = FetchRetrierAbortError;
+/**
+ * Error thrown when {@link RequestOptions.signal} is already aborted before an attempt starts.
+ */
+class FetchRetrierAlreadyAbortedError extends FetchRetrierAbortError {
+    /**
+     * @param message - Human-readable reason (default: `'Signal was already aborted'`)
+     */
+    constructor(message = 'Signal was already aborted') {
+        super(message);
+        this.name = 'FetchRetrierAlreadyAbortedError';
+        Object.setPrototypeOf(this, FetchRetrierAlreadyAbortedError.prototype);
+    }
+}
+exports.FetchRetrierAlreadyAbortedError = FetchRetrierAlreadyAbortedError;
+/** Error thrown when the server returns a non-OK HTTP status and no further retry is performed. */
+class FetchRetrierHttpError extends Error {
+    /**
+     * @param message - Error description
+     * @param status - HTTP status code from the response
+     */
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = 'FetchRetrierHttpError';
+        Object.setPrototypeOf(this, FetchRetrierHttpError.prototype);
+    }
+}
+exports.FetchRetrierHttpError = FetchRetrierHttpError;
+/**
+ * Error thrown when a fetch fails with a network-level error (e.g. DNS failure, connection refused).
+ */
+class FetchRetrierNetworkError extends Error {
+    /**
+     * @param message - Human-readable reason (default: `'Network error'`)
+     * @param cause - Original error, if any
+     */
+    constructor(message = 'Network error', cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'FetchRetrierNetworkError';
+        Object.setPrototypeOf(this, FetchRetrierNetworkError.prototype);
+    }
+}
+exports.FetchRetrierNetworkError = FetchRetrierNetworkError;
+/** Error thrown when an internal invariant fails (should not happen in normal use). */
+class FetchRetrierUnreachableError extends Error {
+    /**
+     * @param message - Human-readable reason (default: `'Unreachable'`)
+     */
+    constructor(message = 'Unreachable') {
+        super(message);
+        this.name = 'FetchRetrierUnreachableError';
+        Object.setPrototypeOf(this, FetchRetrierUnreachableError.prototype);
+    }
+}
+exports.FetchRetrierUnreachableError = FetchRetrierUnreachableError;
+/**
+ * Default {@link RequestOptions.shouldRetry} implementation: retry on HTTP 429, 500, 502, 503, 504.
+ */
 const defaultShouldRetry = (res) => {
     return [429, 500, 502, 503, 504].includes(res.status);
 };
 /**
- * retry + timeout + Full Jitter
- * @param url - The URL to fetch
- * @param options - The options for the fetch
- * @returns The response
+ * Performs `fetch` with retries, a per-attempt timeout, exponential backoff with full jitter,
+ * optional {@link RequestOptions.signal} cancellation, and a configurable retry predicate for
+ * non-OK responses.
+ *
+ * @param url - Request URL
+ * @param options - Retries, backoff, timeout, optional abort signal, and optional retry predicate
+ * @returns The first successful (OK) {@link Response}
+ * @throws {FetchRetrierAlreadyAbortedError} If `options.signal` is already aborted before an attempt
+ * @throws {FetchRetrierHttpError} On a non-OK response that is not retried or after the last attempt
+ * @throws {FetchRetrierNetworkError} On a network error on the final attempt
+ * @throws {FetchRetrierAbortError} On timeout or external abort on the final attempt
+ * @throws {FetchRetrierUnreachableError} If the retry loop exits without returning (internal bug)
  */
 const fetchRetrier = async (url, options) => {
-    const { headers, retries, timeoutMs, baseBackoffMs, shouldRetry = defaultShouldRetry } = options;
+    const { headers, retries, timeoutMs, baseBackoffMs, signal: externalSignal, shouldRetry = defaultShouldRetry } = options;
     for (let attempt = 1; attempt <= retries; attempt++) {
+        if (externalSignal?.aborted) {
+            throw new FetchRetrierAlreadyAbortedError();
+        }
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), timeoutMs);
+        const onExternalAbort = () => {
+            clearTimeout(timer);
+            controller.abort();
+        };
+        if (externalSignal) {
+            externalSignal.addEventListener('abort', onExternalAbort);
+        }
         try {
             const res = await fetch(url, {
                 headers,
                 signal: controller.signal,
             });
             clearTimeout(timer);
+            externalSignal?.removeEventListener('abort', onExternalAbort);
             if (res.ok) {
                 return res;
             }
@@ -28,45 +118,51 @@ const fetchRetrier = async (url, options) => {
             const isContinue = shouldRetry(res, text);
             if (isContinue) {
                 if (attempt === retries) {
-                    throw new Error(`HTTP ${res.status}`);
+                    throw new FetchRetrierHttpError(`HTTP ${res.status}`, res.status);
                 }
                 await wait(fullJitter(baseBackoffMs, attempt));
             }
             else {
-                throw new Error(`Non-retriable HTTP error: ${res.status}`);
+                throw new FetchRetrierHttpError(`Non-retriable HTTP error: ${res.status}`, res.status);
             }
         }
         catch (err) {
             clearTimeout(timer);
+            externalSignal?.removeEventListener('abort', onExternalAbort);
             if (err instanceof Error && err.name === 'AbortError') {
                 if (attempt === retries)
-                    throw err;
+                    throw err instanceof FetchRetrierAbortError ? err : new FetchRetrierAbortError();
                 await wait(fullJitter(baseBackoffMs, attempt));
                 continue;
             }
             if (err instanceof TypeError) {
                 if (attempt === retries)
-                    throw err;
+                    throw new FetchRetrierNetworkError('Network error', err);
                 await wait(fullJitter(baseBackoffMs, attempt));
                 continue;
             }
             throw err;
         }
     }
-    throw new Error('Unreachable');
+    throw new FetchRetrierUnreachableError();
 };
 exports.fetchRetrier = fetchRetrier;
+/**
+ * @param ms - Delay in milliseconds
+ * @returns A promise that resolves after `ms`
+ */
 const wait = (ms) => {
     return new Promise((resolve) => setTimeout(resolve, ms));
 };
 /**
- * AWS recommended Full Jitter
- * @param base - The base time in milliseconds
- * @param attempt - The attempt number
- * @returns The time to wait in milliseconds
+ * Full jitter backoff: random delay in `[0, base * 2^attempt)` ms (AWS-recommended pattern).
+ *
+ * @param base - Base backoff in milliseconds
+ * @param attempt - 1-based attempt index (first retry uses `attempt === 1`)
+ * @returns Wait duration in milliseconds before the next attempt
  */
 const fullJitter = (base, attempt) => {
     const cap = base * Math.pow(2, attempt);
     return Math.floor(Math.random() * cap);
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Configuration for {@link fetchRetrier}.\n */\nexport interface RequestOptions {\n  /** Optional HTTP headers sent with each attempt. */\n  headers?: Record<string, string>;\n  /** Maximum number of attempts, including the first. */\n  retries: number;\n  /** Per-attempt timeout in milliseconds; uses an internal {@link AbortController} when exceeded. */\n  timeoutMs: number;\n  /**\n   * Base backoff in milliseconds for full jitter. The cap for attempt `n` is `baseBackoffMs * 2^n`.\n   */\n  baseBackoffMs: number;\n  /**\n   * Optional external {@link AbortSignal}. When aborted, the in-flight request is aborted; on the\n   * final attempt, cancellation surfaces as {@link FetchRetrierAbortError}.\n   */\n  signal?: AbortSignal;\n  /**\n   * Return `true` to schedule another attempt for this non-OK response.\n   * Default: retry on status 429, 500, 502, 503, or 504.\n   */\n  shouldRetry?: (response: Response, body: string) => boolean;\n}\n\n/** Error thrown when a request is cancelled by timeout or an external {@link AbortSignal}. */\nexport class FetchRetrierAbortError extends Error {\n  override readonly name: string = 'FetchRetrierAbortError';\n  /**\n   * @param message - Human-readable reason (default: `'Aborted'`)\n   */\n  constructor(message = 'Aborted') {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierAbortError.prototype);\n  }\n}\n\n/**\n * Error thrown when {@link RequestOptions.signal} is already aborted before an attempt starts.\n */\nexport class FetchRetrierAlreadyAbortedError extends FetchRetrierAbortError {\n  override readonly name: string = 'FetchRetrierAlreadyAbortedError';\n  /**\n   * @param message - Human-readable reason (default: `'Signal was already aborted'`)\n   */\n  constructor(message = 'Signal was already aborted') {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierAlreadyAbortedError.prototype);\n  }\n}\n\n/** Error thrown when the server returns a non-OK HTTP status and no further retry is performed. */\nexport class FetchRetrierHttpError extends Error {\n  override readonly name: string = 'FetchRetrierHttpError';\n  /**\n   * @param message - Error description\n   * @param status - HTTP status code from the response\n   */\n  constructor(\n    message: string,\n    public readonly status: number,\n  ) {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierHttpError.prototype);\n  }\n}\n\n/**\n * Error thrown when a fetch fails with a network-level error (e.g. DNS failure, connection refused).\n */\nexport class FetchRetrierNetworkError extends Error {\n  override readonly name: string = 'FetchRetrierNetworkError';\n  /**\n   * @param message - Human-readable reason (default: `'Network error'`)\n   * @param cause - Original error, if any\n   */\n  constructor(message = 'Network error', public readonly cause?: unknown) {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierNetworkError.prototype);\n  }\n}\n\n/** Error thrown when an internal invariant fails (should not happen in normal use). */\nexport class FetchRetrierUnreachableError extends Error {\n  override readonly name: string = 'FetchRetrierUnreachableError';\n  /**\n   * @param message - Human-readable reason (default: `'Unreachable'`)\n   */\n  constructor(message = 'Unreachable') {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierUnreachableError.prototype);\n  }\n}\n\n/**\n * Default {@link RequestOptions.shouldRetry} implementation: retry on HTTP 429, 500, 502, 503, 504.\n */\nconst defaultShouldRetry = (res: Response): boolean => {\n  return [429, 500, 502, 503, 504].includes(res.status);\n};\n\n/**\n * Performs `fetch` with retries, a per-attempt timeout, exponential backoff with full jitter,\n * optional {@link RequestOptions.signal} cancellation, and a configurable retry predicate for\n * non-OK responses.\n *\n * @param url - Request URL\n * @param options - Retries, backoff, timeout, optional abort signal, and optional retry predicate\n * @returns The first successful (OK) {@link Response}\n * @throws {FetchRetrierAlreadyAbortedError} If `options.signal` is already aborted before an attempt\n * @throws {FetchRetrierHttpError} On a non-OK response that is not retried or after the last attempt\n * @throws {FetchRetrierNetworkError} On a network error on the final attempt\n * @throws {FetchRetrierAbortError} On timeout or external abort on the final attempt\n * @throws {FetchRetrierUnreachableError} If the retry loop exits without returning (internal bug)\n */\nexport const fetchRetrier = async (url: string, options: RequestOptions): Promise<Response> => {\n  const { headers, retries, timeoutMs, baseBackoffMs, signal: externalSignal, shouldRetry = defaultShouldRetry } = options;\n\n  for (let attempt = 1; attempt <= retries; attempt++) {\n    if (externalSignal?.aborted) {\n      throw new FetchRetrierAlreadyAbortedError();\n    }\n\n    const controller = new AbortController();\n    const timer = setTimeout(() => controller.abort(), timeoutMs);\n\n    const onExternalAbort = (): void => {\n      clearTimeout(timer);\n      controller.abort();\n    };\n\n    if (externalSignal) {\n      externalSignal.addEventListener('abort', onExternalAbort);\n    }\n\n    try {\n      const res = await fetch(url, {\n        headers,\n        signal: controller.signal,\n      });\n\n      clearTimeout(timer);\n      externalSignal?.removeEventListener('abort', onExternalAbort);\n\n      if (res.ok) {\n        return res;\n      }\n\n      const text = await res.text();\n      const isContinue = shouldRetry(res, text);\n\n      if (isContinue) {\n        if (attempt === retries) {\n          throw new FetchRetrierHttpError(`HTTP ${res.status}`, res.status);\n        }\n        await wait(fullJitter(baseBackoffMs, attempt));\n      } else {\n        throw new FetchRetrierHttpError(`Non-retriable HTTP error: ${res.status}`, res.status);\n      }\n    } catch (err: unknown) {\n      clearTimeout(timer);\n      externalSignal?.removeEventListener('abort', onExternalAbort);\n\n      if (err instanceof Error && err.name === 'AbortError') {\n        if (attempt === retries) throw err instanceof FetchRetrierAbortError ? err : new FetchRetrierAbortError();\n        await wait(fullJitter(baseBackoffMs, attempt));\n        continue;\n      }\n\n      if (err instanceof TypeError) {\n        if (attempt === retries) throw new FetchRetrierNetworkError('Network error', err);\n        await wait(fullJitter(baseBackoffMs, attempt));\n        continue;\n      }\n\n      throw err;\n    }\n  }\n\n  throw new FetchRetrierUnreachableError();\n};\n\n/**\n * @param ms - Delay in milliseconds\n * @returns A promise that resolves after `ms`\n */\nconst wait = (ms: number): Promise<void> => {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n};\n\n/**\n * Full jitter backoff: random delay in `[0, base * 2^attempt)` ms (AWS-recommended pattern).\n *\n * @param base - Base backoff in milliseconds\n * @param attempt - 1-based attempt index (first retry uses `attempt === 1`)\n * @returns Wait duration in milliseconds before the next attempt\n */\nconst fullJitter = (base: number, attempt: number): number => {\n  const cap = base * Math.pow(2, attempt);\n  return Math.floor(Math.random() * cap);\n};\n"]}

package/package.json

@@ -42,7 +42,7 @@
     "eslint-plugin-import": "^2.32.0",
     "jest": "^30.3.0",
     "jest-junit": "^16",
-    "projen": "^0.99.20",
+    "projen": "^0.99.21",
     "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
     "typescript": "5.9.x"
@@ -55,7 +55,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.8",
+  "version": "0.2.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [