@foundatiofx/fetchclient 1.1.0 → 1.2.0

package/esm/src/ResponsePromise.js

@@ -0,0 +1,163 @@
+/**
+ * A promise that resolves to a FetchClientResponse with additional helper methods
+ * for parsing the response body. This allows for a fluent API similar to ky:
+ *
+ * @example
+ * ```typescript
+ * // Await to get the full response
+ * const response = await client.get("/api/users");
+ *
+ * // Or use helper methods for direct access to parsed body
+ * const users = await client.get("/api/users").json<User[]>();
+ * const html = await client.get("/page").text();
+ * const file = await client.get("/file").blob();
+ * ```
+ */
+export class ResponsePromise {
+    #responsePromise;
+    #options;
+    constructor(responsePromise, options) {
+        this.#responsePromise = responsePromise;
+        this.#options = options;
+    }
+    /**
+     * Implements PromiseLike interface so the ResponsePromise can be awaited.
+     */
+    then(onfulfilled, onrejected) {
+        return this.#responsePromise.then(onfulfilled, onrejected);
+    }
+    /**
+     * Catches any errors from the response promise.
+     */
+    catch(onrejected) {
+        return this.#responsePromise.catch(onrejected);
+    }
+    /**
+     * Executes a callback when the promise settles (fulfilled or rejected).
+     */
+    finally(onfinally) {
+        return this.#responsePromise.finally(onfinally);
+    }
+    /**
+     * Parses the response body as JSON.
+     *
+     * If the response was already parsed as JSON (via getJSON, postJSON, etc.),
+     * returns the parsed data directly. Otherwise, parses the response body.
+     *
+     * @template TJson - The expected type of the JSON response
+     * @returns A promise that resolves to the parsed JSON
+     *
+     * @example
+     * ```typescript
+     * const user = await client.get("/api/user/1").json<User>();
+     * ```
+     */
+    async json() {
+        const response = await this.#responsePromise;
+        // If the response already has parsed data (from getJSON, etc.), return it
+        if (response.data !== null && response.data !== undefined) {
+            return response.data;
+        }
+        // Otherwise, parse the response body as JSON
+        const data = await response.json();
+        // Apply reviver and date parsing if options are set
+        if (this.#options?.reviver || this.#options?.shouldParseDates) {
+            return this.#reviveJson(data);
+        }
+        return data;
+    }
+    /**
+     * Returns the response body as text.
+     *
+     * @returns A promise that resolves to the response text
+     *
+     * @example
+     * ```typescript
+     * const html = await client.get("/page").text();
+     * ```
+     */
+    async text() {
+        const response = await this.#responsePromise;
+        return response.text();
+    }
+    /**
+     * Returns the response body as a Blob.
+     *
+     * @returns A promise that resolves to the response as a Blob
+     *
+     * @example
+     * ```typescript
+     * const imageBlob = await client.get("/image.png").blob();
+     * ```
+     */
+    async blob() {
+        const response = await this.#responsePromise;
+        return response.blob();
+    }
+    /**
+     * Returns the response body as an ArrayBuffer.
+     *
+     * @returns A promise that resolves to the response as an ArrayBuffer
+     *
+     * @example
+     * ```typescript
+     * const buffer = await client.get("/file").arrayBuffer();
+     * ```
+     */
+    async arrayBuffer() {
+        const response = await this.#responsePromise;
+        return response.arrayBuffer();
+    }
+    /**
+     * Returns the response body as FormData.
+     *
+     * @returns A promise that resolves to the response as FormData
+     *
+     * @example
+     * ```typescript
+     * const formData = await client.get("/form").formData();
+     * ```
+     */
+    async formData() {
+        const response = await this.#responsePromise;
+        return response.formData();
+    }
+    #reviveJson(data) {
+        if (data === null || data === undefined) {
+            return data;
+        }
+        if (Array.isArray(data)) {
+            return data.map((item) => this.#reviveJson(item));
+        }
+        if (typeof data === "object") {
+            const result = {};
+            for (const [key, value] of Object.entries(data)) {
+                result[key] = this.#reviveValue(key, this.#reviveJson(value));
+            }
+            return result;
+        }
+        return this.#reviveValue("", data);
+    }
+    #reviveValue(key, value) {
+        let revivedValue = value;
+        if (this.#options?.reviver) {
+            revivedValue = this.#options.reviver.call(this, key, revivedValue);
+        }
+        if (this.#options?.shouldParseDates) {
+            revivedValue = this.#tryParseDate(revivedValue);
+        }
+        return revivedValue;
+    }
+    #tryParseDate(value) {
+        if (typeof value !== "string") {
+            return value;
+        }
+        if (/^\d{4}-\d{2}-\d{2}/.test(value)) {
+            const date = new Date(value);
+            if (!isNaN(date.getTime())) {
+                return date;
+            }
+        }
+        return value;
+    }
+}

package/esm/src/RetryMiddleware.js

@@ -0,0 +1,179 @@
+/**
+ * Default HTTP methods that are eligible for retry.
+ * These are idempotent methods that can be safely retried without side effects.
+ */
+const DEFAULT_RETRY_METHODS = [
+    "GET",
+    "HEAD",
+    "PUT",
+    "DELETE",
+    "OPTIONS",
+    "TRACE",
+];
+/**
+ * Default HTTP status codes that trigger a retry.
+ */
+const DEFAULT_RETRY_STATUS_CODES = [
+    408, // Request Timeout
+    413, // Payload Too Large (rate limiting)
+    429, // Too Many Requests
+    500, // Internal Server Error
+    502, // Bad Gateway
+    503, // Service Unavailable
+    504, // Gateway Timeout
+];
+/**
+ * Retry middleware that automatically retries failed requests with exponential backoff.
+ *
+ * @example
+ * ```typescript
+ * const provider = new FetchClientProvider();
+ * provider.useRetry({
+ *   limit: 3,
+ *   statusCodes: [500, 502, 503, 504],
+ *   jitter: 0.1,
+ * });
+ *
+ * const client = provider.getFetchClient();
+ * const response = await client.getJSON('/api/data');
+ * ```
+ */
+export class RetryMiddleware {
+    #options;
+    constructor(options) {
+        this.#options = {
+            limit: options?.limit ?? 2,
+            methods: (options?.methods ?? DEFAULT_RETRY_METHODS).map((m) => m.toUpperCase()),
+            statusCodes: options?.statusCodes ?? DEFAULT_RETRY_STATUS_CODES,
+            maxRetryAfter: options?.maxRetryAfter ?? Infinity,
+            backoffLimit: options?.backoffLimit ?? 30000,
+            jitter: options?.jitter ?? 0.1,
+            delay: options?.delay,
+            shouldRetry: options?.shouldRetry,
+            onRetry: options?.onRetry,
+        };
+    }
+    /**
+     * Creates the middleware function.
+     * @returns The middleware function
+     */
+    middleware() {
+        return async (context, next) => {
+            const method = context.request.method.toUpperCase();
+            // Check if method is eligible for retry
+            if (!this.#options.methods.includes(method)) {
+                await next();
+                return;
+            }
+            let attemptNumber = 0;
+            while (true) {
+                // Store retry metadata in context for observability
+                if (attemptNumber > 0) {
+                    context.retryAttempt = attemptNumber;
+                }
+                await next();
+                // If no response or we've exhausted retries, stop
+                if (!context.response || attemptNumber >= this.#options.limit) {
+                    break;
+                }
+                const response = context.response;
+                // Check if status code is retryable
+                if (!this.#options.statusCodes.includes(response.status)) {
+                    break;
+                }
+                // Check custom shouldRetry predicate
+                if (this.#options.shouldRetry) {
+                    const shouldRetry = await this.#options.shouldRetry(response, attemptNumber);
+                    if (!shouldRetry) {
+                        break;
+                    }
+                }
+                // Calculate base delay
+                let delay = this.#calculateDelay(attemptNumber, response);
+                // Check Retry-After header
+                const retryAfterDelay = this.#parseRetryAfter(response);
+                if (retryAfterDelay !== null) {
+                    // If Retry-After exceeds maxRetryAfter, don't retry
+                    if (retryAfterDelay > this.#options.maxRetryAfter) {
+                        break;
+                    }
+                    // Use the larger of computed delay or Retry-After
+                    delay = Math.max(delay, retryAfterDelay);
+                }
+                // Invoke onRetry callback
+                this.#options.onRetry?.(attemptNumber, response, delay);
+                // Wait before retry
+                await this.#sleep(delay);
+                // Reset response for next attempt
+                context.response = null;
+                attemptNumber++;
+            }
+        };
+    }
+    /**
+     * Calculates the delay for a given attempt with exponential backoff and jitter.
+     */
+    #calculateDelay(attemptNumber, response) {
+        let baseDelay;
+        if (this.#options.delay) {
+            baseDelay = this.#options.delay(attemptNumber, response);
+        }
+        else {
+            // Default exponential backoff: 1s, 2s, 4s, 8s, ...
+            baseDelay = Math.min(1000 * Math.pow(2, attemptNumber), this.#options.backoffLimit);
+        }
+        // Apply jitter
+        return this.#applyJitter(baseDelay);
+    }
+    /**
+     * Applies jitter to a delay value.
+     */
+    #applyJitter(delay) {
+        if (this.#options.jitter <= 0) {
+            return delay;
+        }
+        const jitterRange = delay * this.#options.jitter;
+        // Random value between -jitterRange and +jitterRange
+        const jitter = (Math.random() * 2 - 1) * jitterRange;
+        return Math.max(0, Math.round(delay + jitter));
+    }
+    /**
+     * Parses the Retry-After header and returns the delay in milliseconds.
+     * Supports both delta-seconds and HTTP-date formats.
+     */
+    #parseRetryAfter(response) {
+        const retryAfter = response.headers.get("Retry-After");
+        if (!retryAfter) {
+            return null;
+        }
+        // Try parsing as seconds (integer)
+        const seconds = parseInt(retryAfter, 10);
+        if (!isNaN(seconds)) {
+            return seconds * 1000;
+        }
+        // Try parsing as HTTP-date
+        const date = Date.parse(retryAfter);
+        if (!isNaN(date)) {
+            return Math.max(0, date - Date.now());
+        }
+        return null;
+    }
+    /**
+     * Sleep for the specified number of milliseconds.
+     */
+    #sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+/**
+ * Creates a retry middleware with the given options.
+ *
+ * @example
+ * ```typescript
+ * const client = new FetchClient();
+ * client.use(createRetryMiddleware({ limit: 3 }));
+ * ```
+ */
+export function createRetryMiddleware(options) {
+    return new RetryMiddleware(options).middleware();
+}

package/esm/src/mocks/MockHistory.js

@@ -3,6 +3,7 @@
  */
 export class MockHistoryImpl {
     #get = [];
+    #head = [];
     #post = [];
     #put = [];
     #patch = [];
@@ -11,6 +12,9 @@ export class MockHistoryImpl {
     get get() {
         return [...this.#get];
     }
+    get head() {
+        return [...this.#head];
+    }
     get post() {
         return [...this.#post];
     }
@@ -35,6 +39,9 @@ export class MockHistoryImpl {
             case "GET":
                 this.#get.push(request);
                 break;
+            case "HEAD":
+                this.#head.push(request);
+                break;
             case "POST":
                 this.#post.push(request);
                 break;
@@ -54,6 +61,7 @@ export class MockHistoryImpl {
      */
     clear() {
         this.#get = [];
+        this.#head = [];
         this.#post = [];
         this.#put = [];
         this.#patch = [];

package/esm/src/mocks/MockRegistry.js

@@ -40,6 +40,13 @@ export class MockRegistry {
     onGet(url) {
         return this.#addMock("GET", url);
     }
+    /**
+     * Creates a mock for HEAD requests matching the given URL.
+     * @param url - URL string or RegExp to match
+     */
+    onHead(url) {
+        return this.#addMock("HEAD", url);
+    }
     /**
      * Creates a mock for POST requests matching the given URL.
      * @param url - URL string or RegExp to match

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foundatiofx/fetchclient",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "A typed JSON fetch client with middleware support for Deno, Node and the browser.",
   "keywords": [
     "Fetch",

package/readme.md

@@ -14,7 +14,7 @@ handling.
 
 - **Typed JSON helpers** - `getJSON`, `postJSON`, `putJSON`, `patchJSON`,
   `deleteJSON`
-- **Two API styles** - Functional (no classes) or class-based - your choice
+- **Two API styles** - Functional or class-based - your choice
 - **Response caching** - TTL-based caching with tags for grouped invalidation
 - **Middleware** - Intercept requests/responses for logging, auth, transforms
 - **Rate limiting** - Per-domain rate limits with automatic header detection
@@ -33,15 +33,13 @@ npm install @foundatiofx/fetchclient
 
 FetchClient works two ways - pick whichever style you prefer:
 
-### Functional API (no classes)
+### Functional API
 
 ```ts
 import { getJSON, postJSON, setBaseUrl } from "@foundatiofx/fetchclient";
 
-// Optional: configure once at startup
 setBaseUrl("https://api.example.com");
 
-// Use simple functions anywhere
 const { data: users } = await getJSON<User[]>("/users");
 const { data: created } = await postJSON<User>("/users", { name: "Alice" });
 ```
@@ -69,9 +67,6 @@ const client = new FetchClient({ baseUrl: "https://api.example.com" });
 const { data } = await client.getJSON<User[]>("/users");
 ```
 
-All styles share the same configuration - the functional API wraps a
-[default provider](https://fetchclient.foundatio.dev/guide/provider#default-provider).
-
 ## Caching
 
 ```ts
@@ -112,12 +107,11 @@ usePerDomainRateLimit({
 ## Circuit Breaker
 
 ```ts
-import { FetchClientProvider } from "@foundatiofx/fetchclient";
+import { useCircuitBreaker } from "@foundatiofx/fetchclient";
 
-const provider = new FetchClientProvider();
-provider.useCircuitBreaker({
-  failureThreshold: 5, // Open after 5 failures
-  openDurationMs: 30000, // Stay open for 30 seconds
+useCircuitBreaker({
+  failureThreshold: 5,
+  openDurationMs: 30000,
 });
 
 // When API fails repeatedly, circuit opens
@@ -133,10 +127,9 @@ import { MockRegistry } from "@foundatiofx/fetchclient/mocks";
 const mocks = new MockRegistry();
 mocks.onGet("/api/users").reply(200, [{ id: 1, name: "Alice" }]);
 
-const provider = new FetchClientProvider();
-mocks.install(provider);
+const client = new FetchClient();
+mocks.install(client);
 
-const client = provider.getFetchClient();
 const { data } = await client.getJSON("/api/users");
 // data = [{ id: 1, name: "Alice" }]
 ```

package/script/mod.js

@@ -14,9 +14,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPerDomainCircuitBreakerMiddleware = exports.createCircuitBreakerMiddleware = exports.CircuitOpenError = exports.CircuitBreakerMiddleware = exports.circuitBreakerGroupByDomain = exports.CircuitBreaker = exports.FetchClientProvider = exports.defaultProviderInstance = exports.FetchClientCache = exports.ProblemDetails = exports.FetchClient = void 0;
+exports.middleware = exports.RateLimiter = exports.rateLimiterGroupByDomain = exports.RateLimitMiddleware = exports.RateLimitError = exports.createRateLimitMiddleware = exports.createPerDomainRateLimitMiddleware = exports.RetryMiddleware = exports.createRetryMiddleware = exports.createPerDomainCircuitBreakerMiddleware = exports.createCircuitBreakerMiddleware = exports.CircuitOpenError = exports.CircuitBreakerMiddleware = exports.circuitBreakerGroupByDomain = exports.CircuitBreaker = exports.FetchClientProvider = exports.defaultProviderInstance = exports.FetchClientCache = exports.ProblemDetails = exports.ResponsePromise = exports.FetchClientError = exports.FetchClient = void 0;
 var FetchClient_js_1 = require("./src/FetchClient.js");
 Object.defineProperty(exports, "FetchClient", { enumerable: true, get: function () { return FetchClient_js_1.FetchClient; } });
+var FetchClientError_js_1 = require("./src/FetchClientError.js");
+Object.defineProperty(exports, "FetchClientError", { enumerable: true, get: function () { return FetchClientError_js_1.FetchClientError; } });
+var ResponsePromise_js_1 = require("./src/ResponsePromise.js");
+Object.defineProperty(exports, "ResponsePromise", { enumerable: true, get: function () { return ResponsePromise_js_1.ResponsePromise; } });
 var ProblemDetails_js_1 = require("./src/ProblemDetails.js");
 Object.defineProperty(exports, "ProblemDetails", { enumerable: true, get: function () { return ProblemDetails_js_1.ProblemDetails; } });
 var FetchClientCache_js_1 = require("./src/FetchClientCache.js");
@@ -33,3 +37,92 @@ Object.defineProperty(exports, "CircuitBreakerMiddleware", { enumerable: true, g
 Object.defineProperty(exports, "CircuitOpenError", { enumerable: true, get: function () { return CircuitBreakerMiddleware_js_1.CircuitOpenError; } });
 Object.defineProperty(exports, "createCircuitBreakerMiddleware", { enumerable: true, get: function () { return CircuitBreakerMiddleware_js_1.createCircuitBreakerMiddleware; } });
 Object.defineProperty(exports, "createPerDomainCircuitBreakerMiddleware", { enumerable: true, get: function () { return CircuitBreakerMiddleware_js_1.createPerDomainCircuitBreakerMiddleware; } });
+var RetryMiddleware_js_1 = require("./src/RetryMiddleware.js");
+Object.defineProperty(exports, "createRetryMiddleware", { enumerable: true, get: function () { return RetryMiddleware_js_1.createRetryMiddleware; } });
+Object.defineProperty(exports, "RetryMiddleware", { enumerable: true, get: function () { return RetryMiddleware_js_1.RetryMiddleware; } });
+var RateLimitMiddleware_js_1 = require("./src/RateLimitMiddleware.js");
+Object.defineProperty(exports, "createPerDomainRateLimitMiddleware", { enumerable: true, get: function () { return RateLimitMiddleware_js_1.createPerDomainRateLimitMiddleware; } });
+Object.defineProperty(exports, "createRateLimitMiddleware", { enumerable: true, get: function () { return RateLimitMiddleware_js_1.createRateLimitMiddleware; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return RateLimitMiddleware_js_1.RateLimitError; } });
+Object.defineProperty(exports, "RateLimitMiddleware", { enumerable: true, get: function () { return RateLimitMiddleware_js_1.RateLimitMiddleware; } });
+var RateLimiter_js_1 = require("./src/RateLimiter.js");
+Object.defineProperty(exports, "rateLimiterGroupByDomain", { enumerable: true, get: function () { return RateLimiter_js_1.groupByDomain; } });
+Object.defineProperty(exports, "RateLimiter", { enumerable: true, get: function () { return RateLimiter_js_1.RateLimiter; } });
+const RetryMiddleware_js_2 = require("./src/RetryMiddleware.js");
+const RateLimitMiddleware_js_2 = require("./src/RateLimitMiddleware.js");
+const CircuitBreakerMiddleware_js_2 = require("./src/CircuitBreakerMiddleware.js");
+const DefaultHelpers_js_1 = require("./src/DefaultHelpers.js");
+/**
+ * Convenience middleware factory functions for use with FetchClient.use()
+ *
+ * @example
+ * ```typescript
+ * import { FetchClient, middleware } from "@foundatiofx/fetchclient";
+ *
+ * const client = new FetchClient();
+ * client.use(
+ *   middleware.retry({ limit: 3 }),
+ *   middleware.rateLimit({ maxRequests: 100, windowSeconds: 60 }),
+ *   middleware.circuitBreaker({ failureThreshold: 5 })
+ * );
+ * ```
+ */
+exports.middleware = {
+    /** Retry failed requests with exponential backoff and jitter */
+    retry: RetryMiddleware_js_2.createRetryMiddleware,
+    /** Rate limit requests to prevent overwhelming servers */
+    rateLimit: RateLimitMiddleware_js_2.createRateLimitMiddleware,
+    /** Per-domain rate limit (each domain tracked separately) */
+    perDomainRateLimit: RateLimitMiddleware_js_2.createPerDomainRateLimitMiddleware,
+    /** Circuit breaker for fault tolerance */
+    circuitBreaker: CircuitBreakerMiddleware_js_2.createCircuitBreakerMiddleware,
+    /** Per-domain circuit breaker (each domain tracked separately) */
+    perDomainCircuitBreaker: CircuitBreakerMiddleware_js_2.createPerDomainCircuitBreakerMiddleware,
+};
+/**
+ * Default export for convenient access to all HTTP methods.
+ *
+ * @example
+ * ```typescript
+ * import fc from "@foundatiofx/fetchclient";
+ *
+ * // Configure middleware
+ * fc.use(fc.middleware.retry({ limit: 3 }));
+ *
+ * // Use JSON methods (recommended)
+ * const { data: user } = await fc.getJSON<User>("/api/user/1");
+ * const { data: created } = await fc.postJSON<User>("/api/users", { name: "Alice" });
+ *
+ * // Or use fluent API for other response types
+ * const html = await fc.get("/page").text();
+ * ```
+ */
+const fetchClient = {
+    /** Sends a GET request. Use `.json<T>()` for typed JSON response. */
+    get: (url, options) => (0, DefaultHelpers_js_1.useFetchClient)().get(url, options),
+    /** Sends a POST request. Use `.json<T>()` for typed JSON response. */
+    post: (url, body, options) => (0, DefaultHelpers_js_1.useFetchClient)().post(url, body, options),
+    /** Sends a PUT request. Use `.json<T>()` for typed JSON response. */
+    put: (url, body, options) => (0, DefaultHelpers_js_1.useFetchClient)().put(url, body, options),
+    /** Sends a PATCH request. Use `.json<T>()` for typed JSON response. */
+    patch: (url, body, options) => (0, DefaultHelpers_js_1.useFetchClient)().patch(url, body, options),
+    /** Sends a DELETE request. Use `.json<T>()` for typed JSON response. */
+    delete: (url, options) => (0, DefaultHelpers_js_1.useFetchClient)().delete(url, options),
+    /** Sends a HEAD request. */
+    head: (url, options) => (0, DefaultHelpers_js_1.useFetchClient)().head(url, options),
+    /** Sends a GET request and returns parsed JSON in response.data */
+    getJSON: DefaultHelpers_js_1.getJSON,
+    /** Sends a POST request and returns parsed JSON in response.data */
+    postJSON: DefaultHelpers_js_1.postJSON,
+    /** Sends a PUT request and returns parsed JSON in response.data */
+    putJSON: DefaultHelpers_js_1.putJSON,
+    /** Sends a PATCH request and returns parsed JSON in response.data */
+    patchJSON: DefaultHelpers_js_1.patchJSON,
+    /** Sends a DELETE request and returns parsed JSON in response.data */
+    deleteJSON: DefaultHelpers_js_1.deleteJSON,
+    /** Adds middleware to the default provider */
+    use: DefaultHelpers_js_1.useMiddleware,
+    /** Middleware factory functions */
+    middleware: exports.middleware,
+};
+exports.default = fetchClient;

package/script/src/DefaultHelpers.js

@@ -7,6 +7,7 @@ exports.putJSON = putJSON;
 exports.patchJSON = patchJSON;
 exports.deleteJSON = deleteJSON;
 exports.getCurrentProvider = getCurrentProvider;
+exports.getCache = getCache;
 exports.setCurrentProviderFunc = setCurrentProviderFunc;
 exports.setBaseUrl = setBaseUrl;
 exports.setAccessTokenFunc = setAccessTokenFunc;
@@ -30,7 +31,7 @@ function useFetchClient(options) {
  * Sends a GET request to the specified URL using the default client and provider and returns the response as JSON.
  * @param url - The URL to send the GET request to.
  * @param options - Optional request options.
- * @returns A promise that resolves to the response as JSON.
+ * @returns A promise that resolves to the response with parsed JSON in `data`.
  */
 function getJSON(url, options) {
     return useFetchClient().getJSON(url, options);
@@ -42,7 +43,7 @@ function getJSON(url, options) {
  * @param {string} url - The URL to send the request to.
  * @param {object | string | FormData} [body] - The JSON payload or form data to send with the request.
  * @param {RequestOptions} [options] - Additional options for the request.
- * @returns {Promise<FetchClientResponse<T>>} - A promise that resolves to the response data.
+ * @returns A promise that resolves to the response with parsed JSON in `data`.
  */
 function postJSON(url, body, options) {
     return useFetchClient().postJSON(url, body, options);
@@ -54,7 +55,7 @@ function postJSON(url, body, options) {
  * @param {string} url - The URL to send the request to.
  * @param {object | string} [body] - The JSON payload to send with the request.
  * @param {RequestOptions} [options] - Additional options for the request.
- * @returns {Promise<FetchClientResponse<T>>} - A promise that resolves to the response data.
+ * @returns A promise that resolves to the response with parsed JSON in `data`.
  */
 function putJSON(url, body, options) {
     return useFetchClient().putJSON(url, body, options);
@@ -66,7 +67,7 @@ function putJSON(url, body, options) {
  * @param {string} url - The URL to send the request to.
  * @param {object | string} [body] - The JSON payload to send with the request.
  * @param {RequestOptions} [options] - Additional options for the request.
- * @returns {Promise<FetchClientResponse<T>>} - A promise that resolves to the response data.
+ * @returns A promise that resolves to the response with parsed JSON in `data`.
  */
 function patchJSON(url, body, options) {
     return useFetchClient().patchJSON(url, body, options);
@@ -77,7 +78,7 @@ function patchJSON(url, body, options) {
  * @template T - The type of the response data.
  * @param {string} url - The URL to send the request to.
  * @param {RequestOptions} [options] - Additional options for the request.
- * @returns {Promise<FetchClientResponse<T>>} - A promise that resolves to the response data.
+ * @returns A promise that resolves to the response with parsed JSON in `data`.
  */
 function deleteJSON(url, options) {
     return useFetchClient().deleteJSON(url, options);
@@ -92,6 +93,13 @@ function getCurrentProvider() {
     }
     return getCurrentProviderFunc() ?? FetchClientProvider_js_1.defaultInstance;
 }
+/**
+ * Gets the cache from the current provider.
+ * @returns The FetchClientCache instance.
+ */
+function getCache() {
+    return getCurrentProvider().cache;
+}
 /**
  * Sets the function that retrieves the current FetchClientProvider using whatever scoping mechanism is available.
  * @param getProviderFunc - The function that retrieves the current FetchClientProvider.