fetch-retrier 0.2.10 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # Fetch Retrier
 
-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).
+A lightweight wrapper around `fetch` that adds **retries**, **per-attempt timeout**, and **full jitter** backoff. Pass standard `RequestInit` options (`method`, `body`, `credentials`, and more) for POST/PUT APIs and other HTTP calls 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)
@@ -10,11 +10,14 @@ A lightweight wrapper around `fetch` that adds **retries**, **timeout**, and **f
 ## Features
 
 - **Configurable retries** – Set the maximum number of attempts per request.
-- **Per-request timeout** – Abort requests that exceed a given duration.
+- **Per-attempt timeout** – Abort each attempt when it exceeds 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.
+- **RequestInit forwarding** – Pass `method`, `body`, `credentials`, `redirect`, and other `fetch` options via `init` on every attempt.
+- **Header shorthand** – Optional top-level `headers` override `init.headers` when both are set.
+- **Custom retry predicate** – Control which responses trigger a retry (default: 429, 500, 502, 503, 504).
+- **External cancellation** – Pass an `AbortSignal` to cancel in-flight requests.
+- **Typed errors** – `FetchRetrierHttpError`, `FetchRetrierNetworkError`, `FetchRetrierAbortError`, and related classes.
+- **TypeScript** – Exported types including `RequestOptions` and `FetchInitOptions`.
 
 ## Installation
 
@@ -32,6 +35,8 @@ yarn add fetch-retrier
 
 ## Usage
 
+### GET request
+
 ```typescript
 import { fetchRetrier, RequestOptions } from 'fetch-retrier';
 
@@ -40,7 +45,7 @@ const options: RequestOptions = {
   timeoutMs: 5000,
   baseBackoffMs: 1000,
   headers: {
-    'Authorization': 'Bearer token',
+    Authorization: 'Bearer token',
   },
 };
 
@@ -48,20 +53,30 @@ const response = await fetchRetrier('https://api.example.com/data', options);
 
 if (response.ok) {
   const data = await response.json();
-  // ...
 }
 ```
 
-### Options
+### POST with JSON body (`init`)
 
-| Option | Type | Required | Description |
-|--------|------|----------|-------------|
-| `retries` | `number` | Yes | Maximum number of attempts (including the first request). |
-| `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. |
+```typescript
+import { fetchRetrier } from 'fetch-retrier';
+
+const response = await fetchRetrier('https://api.example.com/items', {
+  retries: 3,
+  timeoutMs: 5000,
+  baseBackoffMs: 1000,
+  init: {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ name: 'example' }),
+    credentials: 'include',
+  },
+});
+
+const item = await response.json();
+```
+
+The same `init` (including `body`) is applied on every retry attempt. Per-attempt `signal` and timeout are managed internally.
 
 ### Custom retry logic
 
@@ -71,7 +86,6 @@ const response = await fetchRetrier('https://api.example.com/data', {
   timeoutMs: 10000,
   baseBackoffMs: 500,
   shouldRetry: (res, body) => {
-    // Retry on rate limit or server errors, or when body indicates "retry later"
     if ([429, 500, 502, 503].includes(res.status)) return true;
     if (res.status === 200 && body.includes('"retry": true')) return true;
     return false;
@@ -94,19 +108,31 @@ await fetchRetrier('https://api.example.com/data', {
 });
 ```
 
-## Retry and error behavior
+### 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, `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).
+- **Non-retriable failure** – If `shouldRetry` returns false, `FetchRetrierHttpError` is thrown immediately (e.g. `Non-retriable HTTP error: 404`).
+- **Timeout** – If a request exceeds `timeoutMs`, it is aborted and retried until `retries` is exhausted; the final failure is `FetchRetrierAbortError`.
+- **Network / TypeError** – Network errors 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 (no attempt is made).
+
+## Options
+
+| Option | Type | Required | Description |
+|--------|------|----------|-------------|
+| `retries` | `number` | Yes | Maximum number of attempts (including the first request). |
+| `timeoutMs` | `number` | Yes | Timeout in milliseconds for each attempt. Exceeded attempts are aborted and retried. |
+| `baseBackoffMs` | `number` | Yes | Base delay in milliseconds for backoff. Delay is capped at `baseBackoffMs * 2^attempt` and randomized (full jitter). |
+| `init` | `FetchInitOptions` | No | `fetch` options forwarded to every attempt: `method`, `body`, `credentials`, `redirect`, `mode`, `cache`, etc. `signal` is reserved for internal timeout and cancellation. |
+| `headers` | `Record<string, string>` | No | Headers sent on every attempt. Overrides `init.headers` when both are set. |
+| `signal` | `AbortSignal` | No | 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 | Called after `response.text()` when `response.ok` is false. Return `true` to retry. Default: 429, 500, 502, 503, 504. |
 
 ## Requirements
 
 - **Node.js** >= 20.0.0
-- Uses the global `fetch` (available in Node 18+).
+- Uses the global `fetch` (available in Node 18+)
 
 ## License
 

package/lib/index.d.ts

@@ -1,9 +1,33 @@
 /**
- * Configuration for {@link fetchRetrier}.
+ * Retry-enabled `fetch` wrapper with per-attempt timeout, full-jitter backoff, and typed errors.
+ *
+ * @module fetch-retrier
+ */
+/**
+ * `fetch` options forwarded to every attempt, excluding `signal`.
+ *
+ * Use for `method`, `body`, `credentials`, `redirect`, `mode`, `cache`, and other
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/RequestInit | RequestInit} fields.
+ * Per-attempt abort and timeout are handled internally via `signal` and must not be set here.
+ */
+export type FetchInitOptions = Omit<RequestInit, 'signal'>;
+/**
+ * Options for {@link fetchRetrier}: retry policy, timeout, backoff, request payload, and cancellation.
+ *
+ * Request shape is built as `{ ...init, headers?, signal }` on each attempt. Top-level `headers`
+ * override `init.headers` when both are provided.
  */
 export interface RequestOptions {
-    /** Optional HTTP headers sent with each attempt. */
+    /**
+     * HTTP headers sent on every attempt.
+     * When `init.headers` is also set, these values take precedence for duplicate keys.
+     */
     headers?: Record<string, string>;
+    /**
+     * Additional {@link FetchInitOptions} merged into each `fetch` call (e.g. POST `method` and JSON `body`).
+     * The same `init` is reused across retries.
+     */
+    init?: FetchInitOptions;
     /** Maximum number of attempts, including the first. */
     retries: number;
     /** Per-attempt timeout in milliseconds; uses an internal {@link AbortController} when exceeded. */
@@ -18,12 +42,18 @@ export interface RequestOptions {
      */
     signal?: AbortSignal;
     /**
-     * Return `true` to schedule another attempt for this non-OK response.
+     * Invoked after `response.text()` when `response.ok` is false.
+     * Return `true` to schedule another attempt (until `retries` is exhausted).
      * Default: retry on status 429, 500, 502, 503, or 504.
+     *
+     * @param response - Non-OK response from the current attempt
+     * @param body - Response body text from `response.text()`
      */
     shouldRetry?: (response: Response, body: string) => boolean;
 }
-/** Error thrown when a request is cancelled by timeout or an external {@link AbortSignal}. */
+/**
+ * Error thrown when a request is cancelled by timeout or an external {@link AbortSignal}.
+ */
 export declare class FetchRetrierAbortError extends Error {
     readonly name: string;
     /**
@@ -41,29 +71,37 @@ export declare class FetchRetrierAlreadyAbortedError extends FetchRetrierAbortEr
      */
     constructor(message?: string);
 }
-/** Error thrown when the server returns a non-OK HTTP status and no further retry is performed. */
+/**
+ * Error thrown when the server returns a non-OK HTTP status and no further retry is performed.
+ *
+ * @property status - HTTP status code from the last non-OK response
+ */
 export declare class FetchRetrierHttpError extends Error {
     readonly status: number;
     readonly name: string;
     /**
      * @param message - Error description
-     * @param status - HTTP status code from the response
+     * @param status - HTTP status code from the last non-OK response
      */
     constructor(message: string, status: number);
 }
 /**
  * Error thrown when a fetch fails with a network-level error (e.g. DNS failure, connection refused).
+ *
+ * @property cause - Original error from the underlying `fetch`, when available
  */
 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
+     * @param cause - Original error from the underlying `fetch`, when available
      */
     constructor(message?: string, cause?: unknown | undefined);
 }
-/** Error thrown when an internal invariant fails (should not happen in normal use). */
+/**
+ * Error thrown when an internal invariant fails (should not happen in normal use).
+ */
 export declare class FetchRetrierUnreachableError extends Error {
     readonly name: string;
     /**
@@ -72,17 +110,20 @@ export declare class FetchRetrierUnreachableError extends Error {
     constructor(message?: string);
 }
 /**
- * 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.
+ * Wraps `fetch` with retries, per-attempt timeout, full-jitter backoff, and optional cancellation.
+ *
+ * Each attempt calls `fetch(url, { ...options.init, headers?, signal })` with an internal
+ * {@link AbortSignal} for `timeoutMs`. Non-OK responses are retried when `shouldRetry` returns
+ * `true` (default: 429 and 5xx). The same {@link FetchInitOptions} (including `body`) is reused
+ * on every attempt.
  *
- * @param url - Request URL
- * @param options - Retries, backoff, timeout, optional abort signal, and optional retry predicate
- * @returns The first successful (OK) {@link Response}
+ * @param url - Request URL passed to `fetch`
+ * @param options - {@link RequestOptions} controlling retries, timeout, request init, and cancellation
+ * @returns The first {@link Response} for which `ok` is `true`
  * @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 {FetchRetrierNetworkError} On a network `TypeError` after the last attempt
+ * @throws {FetchRetrierAbortError} On timeout or external abort after the last 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,7 +1,14 @@
 "use strict";
+/**
+ * Retry-enabled `fetch` wrapper with per-attempt timeout, full-jitter backoff, and typed errors.
+ *
+ * @module fetch-retrier
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 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}. */
+/**
+ * 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'`)
@@ -27,11 +34,15 @@ class FetchRetrierAlreadyAbortedError extends FetchRetrierAbortError {
     }
 }
 exports.FetchRetrierAlreadyAbortedError = FetchRetrierAlreadyAbortedError;
-/** Error thrown when the server returns a non-OK HTTP status and no further retry is performed. */
+/**
+ * Error thrown when the server returns a non-OK HTTP status and no further retry is performed.
+ *
+ * @property status - HTTP status code from the last non-OK response
+ */
 class FetchRetrierHttpError extends Error {
     /**
      * @param message - Error description
-     * @param status - HTTP status code from the response
+     * @param status - HTTP status code from the last non-OK response
      */
     constructor(message, status) {
         super(message);
@@ -43,11 +54,13 @@ class FetchRetrierHttpError extends Error {
 exports.FetchRetrierHttpError = FetchRetrierHttpError;
 /**
  * Error thrown when a fetch fails with a network-level error (e.g. DNS failure, connection refused).
+ *
+ * @property cause - Original error from the underlying `fetch`, when available
  */
 class FetchRetrierNetworkError extends Error {
     /**
      * @param message - Human-readable reason (default: `'Network error'`)
-     * @param cause - Original error, if any
+     * @param cause - Original error from the underlying `fetch`, when available
      */
     constructor(message = 'Network error', cause) {
         super(message);
@@ -57,7 +70,9 @@ class FetchRetrierNetworkError extends Error {
     }
 }
 exports.FetchRetrierNetworkError = FetchRetrierNetworkError;
-/** Error thrown when an internal invariant fails (should not happen in normal use). */
+/**
+ * Error thrown when an internal invariant fails (should not happen in normal use).
+ */
 class FetchRetrierUnreachableError extends Error {
     /**
      * @param message - Human-readable reason (default: `'Unreachable'`)
@@ -70,27 +85,33 @@ class FetchRetrierUnreachableError extends Error {
 }
 exports.FetchRetrierUnreachableError = FetchRetrierUnreachableError;
 /**
- * Default {@link RequestOptions.shouldRetry} implementation: retry on HTTP 429, 500, 502, 503, 504.
+ * Default {@link RequestOptions.shouldRetry}: retry on HTTP 429, 500, 502, 503, or 504.
+ *
+ * @param res - Response from the failed attempt
+ * @returns `true` when another attempt should be scheduled
  */
 const defaultShouldRetry = (res) => {
     return [429, 500, 502, 503, 504].includes(res.status);
 };
 /**
- * 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.
+ * Wraps `fetch` with retries, per-attempt timeout, full-jitter backoff, and optional cancellation.
+ *
+ * Each attempt calls `fetch(url, { ...options.init, headers?, signal })` with an internal
+ * {@link AbortSignal} for `timeoutMs`. Non-OK responses are retried when `shouldRetry` returns
+ * `true` (default: 429 and 5xx). The same {@link FetchInitOptions} (including `body`) is reused
+ * on every attempt.
  *
- * @param url - Request URL
- * @param options - Retries, backoff, timeout, optional abort signal, and optional retry predicate
- * @returns The first successful (OK) {@link Response}
+ * @param url - Request URL passed to `fetch`
+ * @param options - {@link RequestOptions} controlling retries, timeout, request init, and cancellation
+ * @returns The first {@link Response} for which `ok` is `true`
  * @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 {FetchRetrierNetworkError} On a network `TypeError` after the last attempt
+ * @throws {FetchRetrierAbortError} On timeout or external abort after the last attempt
  * @throws {FetchRetrierUnreachableError} If the retry loop exits without returning (internal bug)
  */
 const fetchRetrier = async (url, options) => {
-    const { headers, retries, timeoutMs, baseBackoffMs, signal: externalSignal, shouldRetry = defaultShouldRetry } = options;
+    const { headers, init, retries, timeoutMs, baseBackoffMs, signal: externalSignal, shouldRetry = defaultShouldRetry, } = options;
     for (let attempt = 1; attempt <= retries; attempt++) {
         if (externalSignal?.aborted) {
             throw new FetchRetrierAlreadyAbortedError();
@@ -106,7 +127,8 @@ const fetchRetrier = async (url, options) => {
         }
         try {
             const res = await fetch(url, {
-                headers,
+                ...init,
+                ...(headers !== undefined ? { headers } : {}),
                 signal: controller.signal,
             });
             clearTimeout(timer);
@@ -148,6 +170,8 @@ const fetchRetrier = async (url, options) => {
 };
 exports.fetchRetrier = fetchRetrier;
 /**
+ * Delays execution for the given duration (used between retry attempts).
+ *
  * @param ms - Delay in milliseconds
  * @returns A promise that resolves after `ms`
  */
@@ -165,4 +189,4 @@ const fullJitter = (base, attempt) => {
     const cap = base * Math.pow(2, attempt);
     return Math.floor(Math.random() * cap);
 };
-//# 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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Retry-enabled `fetch` wrapper with per-attempt timeout, full-jitter backoff, and typed errors.\n *\n * @module fetch-retrier\n */\n\n/**\n * `fetch` options forwarded to every attempt, excluding `signal`.\n *\n * Use for `method`, `body`, `credentials`, `redirect`, `mode`, `cache`, and other\n * {@link https://developer.mozilla.org/en-US/docs/Web/API/RequestInit | RequestInit} fields.\n * Per-attempt abort and timeout are handled internally via `signal` and must not be set here.\n */\nexport type FetchInitOptions = Omit<RequestInit, 'signal'>;\n\n/**\n * Options for {@link fetchRetrier}: retry policy, timeout, backoff, request payload, and cancellation.\n *\n * Request shape is built as `{ ...init, headers?, signal }` on each attempt. Top-level `headers`\n * override `init.headers` when both are provided.\n */\nexport interface RequestOptions {\n  /**\n   * HTTP headers sent on every attempt.\n   * When `init.headers` is also set, these values take precedence for duplicate keys.\n   */\n  headers?: Record<string, string>;\n  /**\n   * Additional {@link FetchInitOptions} merged into each `fetch` call (e.g. POST `method` and JSON `body`).\n   * The same `init` is reused across retries.\n   */\n  init?: FetchInitOptions;\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   * Invoked after `response.text()` when `response.ok` is false.\n   * Return `true` to schedule another attempt (until `retries` is exhausted).\n   * Default: retry on status 429, 500, 502, 503, or 504.\n   *\n   * @param response - Non-OK response from the current attempt\n   * @param body - Response body text from `response.text()`\n   */\n  shouldRetry?: (response: Response, body: string) => boolean;\n}\n\n/**\n * Error thrown when a request is cancelled by timeout or an external {@link AbortSignal}.\n */\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/**\n * Error thrown when the server returns a non-OK HTTP status and no further retry is performed.\n *\n * @property status - HTTP status code from the last non-OK response\n */\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 last non-OK 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 *\n * @property cause - Original error from the underlying `fetch`, when available\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 from the underlying `fetch`, when available\n   */\n  constructor(message = 'Network error', public readonly cause?: unknown) {\n    super(message);\n    Object.setPrototypeOf(this, FetchRetrierNetworkError.prototype);\n  }\n}\n\n/**\n * Error thrown when an internal invariant fails (should not happen in normal use).\n */\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}: retry on HTTP 429, 500, 502, 503, or 504.\n *\n * @param res - Response from the failed attempt\n * @returns `true` when another attempt should be scheduled\n */\nconst defaultShouldRetry = (res: Response): boolean => {\n  return [429, 500, 502, 503, 504].includes(res.status);\n};\n\n/**\n * Wraps `fetch` with retries, per-attempt timeout, full-jitter backoff, and optional cancellation.\n *\n * Each attempt calls `fetch(url, { ...options.init, headers?, signal })` with an internal\n * {@link AbortSignal} for `timeoutMs`. Non-OK responses are retried when `shouldRetry` returns\n * `true` (default: 429 and 5xx). The same {@link FetchInitOptions} (including `body`) is reused\n * on every attempt.\n *\n * @param url - Request URL passed to `fetch`\n * @param options - {@link RequestOptions} controlling retries, timeout, request init, and cancellation\n * @returns The first {@link Response} for which `ok` is `true`\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 `TypeError` after the last attempt\n * @throws {FetchRetrierAbortError} On timeout or external abort after the last 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 {\n    headers,\n    init,\n    retries,\n    timeoutMs,\n    baseBackoffMs,\n    signal: externalSignal,\n    shouldRetry = defaultShouldRetry,\n  } = 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        ...init,\n        ...(headers !== undefined ? { 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 * Delays execution for the given duration (used between retry attempts).\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

@@ -55,7 +55,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.2.10",
+  "version": "0.3.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [