@cacheable/net 1.0.2 → 2.0.0

package/dist/index.js

@@ -8,13 +8,17 @@ import {
   fetch as undiciFetch
 } from "undici";
 async function fetch(url, options) {
-  if (!options.cache) {
-    throw new Error("Fetch options must include a cache instance or options.");
-  }
   const fetchOptions = {
     ...options,
     cache: "no-cache"
   };
+  if (!options.cache) {
+    const response2 = await undiciFetch(url, fetchOptions);
+    if (!response2.ok) {
+      throw new Error(`Fetch failed with status ${response2.status}`);
+    }
+    return response2;
+  }
   if (options.method === "POST" || options.method === "PATCH" || options.method === "DELETE" || options.method === "HEAD") {
     const response2 = await undiciFetch(url, fetchOptions);
     if (!response2.ok) {
@@ -22,10 +26,10 @@ async function fetch(url, options) {
     }
     return response2;
   }
-  const useHttpCache = options.useHttpCache !== false;
+  const httpCachePolicy = options.httpCachePolicy !== false;
   const method = options.method || "GET";
   const cacheKey = `${method}:${url}`;
-  if (!useHttpCache) {
+  if (!httpCachePolicy) {
     const cachedData = await options.cache.getOrSet(cacheKey, async () => {
       const response2 = await undiciFetch(url, fetchOptions);
       if (!response2.ok) {
@@ -301,67 +305,122 @@ async function head(url, options) {
 // src/index.ts
 var CacheableNet = class extends Hookified {
   _cache = new Cacheable();
-  _useHttpCache = true;
+  _httpCachePolicy = true;
+  _stringify = JSON.stringify;
+  _parse = JSON.parse;
   constructor(options) {
     super(options);
     if (options?.cache) {
       this._cache = options.cache instanceof Cacheable ? options.cache : new Cacheable(options.cache);
     }
-    if (options?.useHttpCache !== void 0) {
-      this._useHttpCache = options.useHttpCache;
+    if (options?.httpCachePolicy !== void 0) {
+      this._httpCachePolicy = options.httpCachePolicy;
+    }
+    if (options?.stringify) {
+      this._stringify = options?.stringify;
     }
+    if (options?.parse) {
+      this._parse = options?.parse;
+    }
+  }
+  /**
+   * Get the stringify function used for converting objects to strings.
+   * @returns {StringifyType} The current stringify function
+   */
+  get stringify() {
+    return this._stringify;
+  }
+  /**
+   * Set the stringify function for converting objects to strings.
+   * @param {StringifyType} value - The stringify function to use
+   */
+  set stringify(value) {
+    this._stringify = value;
+  }
+  /**
+   * Get the parse function used for converting strings to objects.
+   * @returns {ParseType} The current parse function
+   */
+  get parse() {
+    return this._parse;
+  }
+  /**
+   * Set the parse function for converting strings to objects.
+   * @param {ParseType} value - The parse function to use
+   */
+  set parse(value) {
+    this._parse = value;
   }
+  /**
+   * Get the Cacheable instance used for caching fetch operations.
+   * @returns {Cacheable} The current Cacheable instance
+   */
   get cache() {
     return this._cache;
   }
+  /**
+   * Set the Cacheable instance for caching fetch operations.
+   * @param {Cacheable} value - The Cacheable instance to use for caching
+   */
   set cache(value) {
     this._cache = value;
   }
   /**
-   * Get the current HTTP cache setting.
+   * Get the current HTTP cache policy setting.
    * @returns {boolean} Whether HTTP cache semantics are enabled
    */
-  get useHttpCache() {
-    return this._useHttpCache;
+  get httpCachePolicy() {
+    return this._httpCachePolicy;
   }
   /**
    * Set whether to use HTTP cache semantics.
    * @param {boolean} value - Enable or disable HTTP cache semantics
    */
-  set useHttpCache(value) {
-    this._useHttpCache = value;
+  set httpCachePolicy(value) {
+    this._httpCachePolicy = value;
   }
   /**
    * Fetch data from a URL with optional request options. Will use the cache that is already set in the instance.
    *
-   * When `useHttpCache` is enabled (default), cache entries will have their TTL
+   * When `httpCachePolicy` is enabled (default), cache entries will have their TTL
    * set based on HTTP cache headers (e.g., Cache-Control: max-age). When disabled,
    * the default TTL from the Cacheable instance is used.
    *
    * @param {string} url The URL to fetch.
-   * @param {FetchRequestInit} options Optional request options.
+   * @param {Omit<FetchOptions, "cache">} options Optional request options.
    * @returns {Promise<FetchResponse>} The response from the fetch.
    */
   async fetch(url, options) {
     const fetchOptions = {
       ...options,
       cache: this._cache,
-      useHttpCache: this._useHttpCache
+      httpCachePolicy: this._httpCachePolicy
     };
     return fetch(url, fetchOptions);
   }
   /**
-   * Perform a GET request to a URL with optional request options. Will use the cache that is already set in the instance.
+   * Perform a GET request to a URL with optional request options. By default caching is enabled on all requests. To
+   * disable set `options.caching` to false.
    * @param {string} url The URL to fetch.
-   * @param {Omit<FetchRequestInit, 'method'>} options Optional request options (method will be set to GET).
+   * @param {NetFetchOptions} options Optional request options (method will be set to GET).
    * @returns {Promise<DataResponse<T>>} The typed data and response from the fetch.
    */
   async get(url, options) {
-    const response = await this.fetch(url, { ...options, method: "GET" });
+    const fetchOptions = {
+      ...options,
+      cache: this._cache,
+      httpCachePolicy: this._httpCachePolicy,
+      method: "GET"
+    };
+    if (options?.caching !== void 0) {
+      delete fetchOptions.cache;
+    }
+    const response = await fetch(url, fetchOptions);
     const text = await response.text();
     let data;
+    const parseFn = options?.parse || this._parse;
     try {
-      data = JSON.parse(text);
+      data = parseFn(text);
     } catch {
       data = text;
     }
@@ -376,10 +435,11 @@ var CacheableNet = class extends Hookified {
     };
   }
   /**
-   * Perform a POST request to a URL with data and optional request options. Will use the cache that is already set in the instance.
+   * Perform a POST request to a URL with data and optional request options. By default caching is not enabled. To enable it
+   * set `options.caching` to true. Note, setting caching to tru means it will not post if the data is the same.
    * @param {string} url The URL to fetch.
    * @param {unknown} data The data to send in the request body.
-   * @param {Omit<FetchRequestInit, 'method' | 'body'>} options Optional request options (method and body will be set).
+   * @param {Omit<NetFetchOptions, "method" | "body" >} options Optional request options (method and body will be set).
    * @returns {Promise<DataResponse<T>>} The typed data and response from the fetch.
    */
   async post(url, data, options) {
@@ -390,21 +450,28 @@ var CacheableNet = class extends Hookified {
     } else if (data instanceof FormData || data instanceof URLSearchParams || data instanceof Blob) {
       body = data;
     } else {
-      body = JSON.stringify(data);
+      const stringifyFn = options?.stringify || this._stringify;
+      body = stringifyFn(data);
       if (!headers["Content-Type"] && !headers["content-type"]) {
         headers["Content-Type"] = "application/json";
       }
     }
-    const response = await this.fetch(url, {
+    const fetchOptions = {
       ...options,
       headers,
       body,
+      httpCachePolicy: this._httpCachePolicy,
       method: "POST"
-    });
+    };
+    if (options?.caching === true) {
+      fetchOptions.cache = this._cache;
+    }
+    const response = await fetch(url, fetchOptions);
     const text = await response.text();
     let responseData;
+    const parseFn = options?.parse || this._parse;
     try {
-      responseData = JSON.parse(text);
+      responseData = parseFn(text);
     } catch {
       responseData = text;
     }
@@ -419,20 +486,82 @@ var CacheableNet = class extends Hookified {
     };
   }
   /**
-   * Perform a HEAD request to a URL with optional request options. Will use the cache that is already set in the instance.
+   * Perform a HEAD request to a URL with optional request options. By default caching is enabled on all requests. To
+   * disable set `options.caching` to false.
    * @param {string} url The URL to fetch.
-   * @param {Omit<FetchRequestInit, 'method'>} options Optional request options (method will be set to HEAD).
+   * @param {NetFetchOptions} options Optional request options (method will be set to HEAD).
    * @returns {Promise<FetchResponse>} The response from the fetch (no body).
    */
   async head(url, options) {
-    const response = await this.fetch(url, { ...options, method: "HEAD" });
+    const fetchOptions = {
+      ...options,
+      cache: this._cache,
+      httpCachePolicy: this._httpCachePolicy,
+      method: "HEAD"
+    };
+    if (options?.caching !== void 0 && !options.caching) {
+      delete fetchOptions.cache;
+    }
+    const response = await fetch(url, fetchOptions);
     return response;
   }
   /**
-   * Perform a PATCH request to a URL with data and optional request options. Will use the cache that is already set in the instance.
+   * Perform a PUT request to a URL with data and optional request options. By default caching is not enabled. To enable it
+   * set `options.caching` to true. Note, setting caching to true means it will not put if the data is the same.
+   * @param {string} url The URL to fetch.
+   * @param {unknown} data The data to send in the request body.
+   * @param {Omit<NetFetchOptions, 'method' | 'body'>} options Optional request options (method and body will be set).
+   * @returns {Promise<DataResponse<T>>} The typed data and response from the fetch.
+   */
+  async put(url, data, options) {
+    let body;
+    const headers = { ...options?.headers };
+    if (typeof data === "string") {
+      body = data;
+    } else if (data instanceof FormData || data instanceof URLSearchParams || data instanceof Blob) {
+      body = data;
+    } else {
+      const stringifyFn = options?.stringify || this._stringify;
+      body = stringifyFn(data);
+      if (!headers["Content-Type"] && !headers["content-type"]) {
+        headers["Content-Type"] = "application/json";
+      }
+    }
+    const fetchOptions = {
+      ...options,
+      headers,
+      body,
+      httpCachePolicy: this._httpCachePolicy,
+      method: "PUT"
+    };
+    if (options?.caching === true) {
+      fetchOptions.cache = this._cache;
+    }
+    const response = await fetch(url, fetchOptions);
+    const text = await response.text();
+    let responseData;
+    const parseFn = options?.parse || this._parse;
+    try {
+      responseData = parseFn(text);
+    } catch {
+      responseData = text;
+    }
+    const newResponse = new Response(text, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    return {
+      data: responseData,
+      response: newResponse
+    };
+  }
+  /**
+   * Perform a PATCH request to a URL with data and optional request options. By default caching is not enabled. To enable it
+   * set `options.caching` to true. Note, setting caching to true means it will not patch if the data is the same.
    * @param {string} url The URL to fetch.
    * @param {unknown} data The data to send in the request body.
-   * @param {Omit<FetchRequestInit, 'method' | 'body'>} options Optional request options (method and body will be set).
+   * @param {Omit<NetFetchOptions, 'method' | 'body'>} options Optional request options (method and body will be set).
    * @returns {Promise<DataResponse<T>>} The typed data and response from the fetch.
    */
   async patch(url, data, options) {
@@ -443,21 +572,28 @@ var CacheableNet = class extends Hookified {
     } else if (data instanceof FormData || data instanceof URLSearchParams || data instanceof Blob) {
       body = data;
     } else {
-      body = JSON.stringify(data);
+      const stringifyFn = options?.stringify || this._stringify;
+      body = stringifyFn(data);
       if (!headers["Content-Type"] && !headers["content-type"]) {
         headers["Content-Type"] = "application/json";
       }
     }
-    const response = await this.fetch(url, {
+    const fetchOptions = {
       ...options,
       headers,
       body,
+      httpCachePolicy: this._httpCachePolicy,
       method: "PATCH"
-    });
+    };
+    if (options?.caching === true) {
+      fetchOptions.cache = this._cache;
+    }
+    const response = await fetch(url, fetchOptions);
     const text = await response.text();
     let responseData;
+    const parseFn = options?.parse || this._parse;
     try {
-      responseData = JSON.parse(text);
+      responseData = parseFn(text);
     } catch {
       responseData = text;
     }
@@ -472,10 +608,11 @@ var CacheableNet = class extends Hookified {
     };
   }
   /**
-   * Perform a DELETE request to a URL with optional data and request options. Will use the cache that is already set in the instance.
+   * Perform a DELETE request to a URL with optional data and request options. By default caching is not enabled. To enable it
+   * set `options.caching` to true. Note, setting caching to true means it will not delete if the data is the same.
    * @param {string} url The URL to fetch.
    * @param {unknown} data Optional data to send in the request body.
-   * @param {Omit<FetchRequestInit, 'method' | 'body'>} options Optional request options (method and body will be set).
+   * @param {Omit<NetFetchOptions, 'method' | 'body'>} options Optional request options (method and body will be set).
    * @returns {Promise<DataResponse<T>>} The typed data and response from the fetch.
    */
   async delete(url, data, options) {
@@ -487,22 +624,29 @@ var CacheableNet = class extends Hookified {
       } else if (data instanceof FormData || data instanceof URLSearchParams || data instanceof Blob) {
         body = data;
       } else {
-        body = JSON.stringify(data);
+        const stringifyFn = options?.stringify || this._stringify;
+        body = stringifyFn(data);
         if (!headers["Content-Type"] && !headers["content-type"]) {
           headers["Content-Type"] = "application/json";
         }
       }
     }
-    const response = await this.fetch(url, {
+    const fetchOptions = {
       ...options,
       headers,
       body,
+      httpCachePolicy: this._httpCachePolicy,
       method: "DELETE"
-    });
+    };
+    if (options?.caching === true) {
+      fetchOptions.cache = this._cache;
+    }
+    const response = await fetch(url, fetchOptions);
     const text = await response.text();
     let responseData;
+    const parseFn = options?.parse || this._parse;
     try {
-      responseData = JSON.parse(text);
+      responseData = parseFn(text);
     } catch {
       responseData = text;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cacheable/net",
-  "version": "1.0.2",
+  "version": "2.0.0",
   "description": "High Performance Network Caching for Node.js with fetch, request, http 1.1, and http 2 support",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -21,10 +21,10 @@
   "license": "MIT",
   "private": false,
   "devDependencies": {
-    "@biomejs/biome": "^2.2.2",
+    "@biomejs/biome": "^2.2.4",
     "@faker-js/faker": "^10.0.0",
     "@types/http-cache-semantics": "^4.0.4",
-    "@types/node": "^24.3.0",
+    "@types/node": "^24.5.2",
     "@vitest/coverage-v8": "^3.2.4",
     "rimraf": "^6.0.1",
     "tsup": "^8.5.0",
@@ -32,10 +32,10 @@
     "vitest": "^3.2.4"
   },
   "dependencies": {
-    "hookified": "^1.12.0",
+    "hookified": "^1.12.1",
     "http-cache-semantics": "^4.2.0",
-    "undici": "^7.15.0",
-    "cacheable": "^2.0.1"
+    "undici": "^7.16.0",
+    "cacheable": "^2.0.3"
   },
   "keywords": [
     "cacheable",