@cacheable/net 1.0.1 → 2.0.0

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -22,64 +32,683 @@ var index_exports = {};
 __export(index_exports, {
   CacheableNet: () => CacheableNet,
   Net: () => Net,
-  fetch: () => fetch
+  del: () => del,
+  fetch: () => fetch,
+  get: () => get,
+  head: () => head,
+  patch: () => patch,
+  post: () => post
 });
 module.exports = __toCommonJS(index_exports);
 var import_cacheable = require("cacheable");
 var import_hookified = require("hookified");
 
 // src/fetch.ts
+var import_http_cache_semantics = __toESM(require("http-cache-semantics"), 1);
 var import_undici = require("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"
   };
-  return options.cache.getOrSet(url, async () => {
-    const response = await (0, import_undici.fetch)(url, fetchOptions);
-    if (!response.ok) {
-      throw new Error(`Fetch failed with status ${response.status}`);
+  if (!options.cache) {
+    const response2 = await (0, import_undici.fetch)(url, fetchOptions);
+    if (!response2.ok) {
+      throw new Error(`Fetch failed with status ${response2.status}`);
     }
-    return response;
+    return response2;
+  }
+  if (options.method === "POST" || options.method === "PATCH" || options.method === "DELETE" || options.method === "HEAD") {
+    const response2 = await (0, import_undici.fetch)(url, fetchOptions);
+    if (!response2.ok) {
+      throw new Error(`Fetch failed with status ${response2.status}`);
+    }
+    return response2;
+  }
+  const httpCachePolicy = options.httpCachePolicy !== false;
+  const method = options.method || "GET";
+  const cacheKey = `${method}:${url}`;
+  if (!httpCachePolicy) {
+    const cachedData = await options.cache.getOrSet(cacheKey, async () => {
+      const response2 = await (0, import_undici.fetch)(url, fetchOptions);
+      if (!response2.ok) {
+        throw new Error(`Fetch failed with status ${response2.status}`);
+      }
+      const body2 = await response2.text();
+      return {
+        body: body2,
+        status: response2.status,
+        statusText: response2.statusText,
+        headers: Object.fromEntries(response2.headers.entries())
+      };
+    });
+    if (!cachedData) {
+      throw new Error("Failed to get or set cache data");
+    }
+    return new Response(cachedData.body, {
+      status: cachedData.status,
+      statusText: cachedData.statusText,
+      headers: cachedData.headers
+    });
+  }
+  const policyKey = `${cacheKey}:policy`;
+  const [cachedResponse, cachedPolicyData] = await Promise.all([
+    options.cache.get(cacheKey),
+    options.cache.get(policyKey)
+  ]);
+  let policy;
+  let cachedBody;
+  let cachedStatus;
+  let cachedStatusText;
+  let cachedHeaders;
+  if (cachedPolicyData && cachedResponse) {
+    policy = import_http_cache_semantics.default.fromObject(
+      cachedPolicyData
+    );
+    cachedBody = cachedResponse.body;
+    cachedStatus = cachedResponse.status;
+    cachedStatusText = cachedResponse.statusText;
+    cachedHeaders = cachedResponse.headers;
+  }
+  const requestHeaders = fetchOptions.headers || {};
+  const request = {
+    url,
+    method,
+    headers: requestHeaders
+  };
+  if (policy?.satisfiesWithoutRevalidation(request)) {
+    const headers = policy.responseHeaders();
+    return new Response(cachedBody, {
+      status: cachedStatus,
+      statusText: cachedStatusText,
+      headers
+    });
+  }
+  let revalidationHeaders = {};
+  if (policy?.revalidationHeaders(request)) {
+    revalidationHeaders = policy.revalidationHeaders(request);
+  }
+  const response = await (0, import_undici.fetch)(url, {
+    ...fetchOptions,
+    headers: {
+      ...fetchOptions.headers,
+      ...revalidationHeaders
+    }
+  });
+  if (response.status === 304 && policy) {
+    const { policy: updatedPolicy, modified } = policy.revalidatedPolicy(
+      request,
+      {
+        status: response.status,
+        headers: Object.fromEntries(response.headers.entries())
+      }
+    );
+    if (!modified) {
+      const ttl = updatedPolicy.timeToLive();
+      await options.cache.set(policyKey, updatedPolicy.toObject(), ttl);
+      await options.cache.set(
+        cacheKey,
+        {
+          body: cachedBody,
+          status: cachedStatus,
+          statusText: cachedStatusText,
+          headers: cachedHeaders
+        },
+        ttl
+      );
+      const headers = updatedPolicy.responseHeaders();
+      return new Response(cachedBody, {
+        status: cachedStatus,
+        statusText: cachedStatusText,
+        headers
+      });
+    }
+  }
+  if (!response.ok && response.status !== 304) {
+    throw new Error(`Fetch failed with status ${response.status}`);
+  }
+  const body = await response.text();
+  const responseForPolicy = {
+    status: response.status,
+    statusText: response.statusText,
+    headers: Object.fromEntries(response.headers.entries())
+  };
+  const newPolicy = new import_http_cache_semantics.default(request, responseForPolicy);
+  if (newPolicy.storable()) {
+    const ttl = newPolicy.timeToLive();
+    await Promise.all([
+      options.cache.set(
+        cacheKey,
+        {
+          body,
+          status: response.status,
+          statusText: response.statusText,
+          headers: responseForPolicy.headers
+        },
+        ttl
+      ),
+      options.cache.set(policyKey, newPolicy.toObject(), ttl)
+    ]);
+  }
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+async function get(url, options) {
+  const response = await fetch(url, { ...options, method: "GET" });
+  const text = await response.text();
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    data = text;
+  }
+  const newResponse = new Response(text, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+  return {
+    data,
+    response: newResponse
+  };
+}
+async function post(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 {
+    body = JSON.stringify(data);
+    if (!headers["Content-Type"] && !headers["content-type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  const response = await fetch(url, {
+    ...options,
+    headers,
+    body,
+    method: "POST"
+  });
+  const text = await response.text();
+  let responseData;
+  try {
+    responseData = JSON.parse(text);
+  } catch {
+    responseData = text;
+  }
+  const newResponse = new Response(text, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+  return {
+    data: responseData,
+    response: newResponse
+  };
+}
+async function patch(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 {
+    body = JSON.stringify(data);
+    if (!headers["Content-Type"] && !headers["content-type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  const response = await fetch(url, {
+    ...options,
+    headers,
+    body,
+    method: "PATCH"
+  });
+  const text = await response.text();
+  let responseData;
+  try {
+    responseData = JSON.parse(text);
+  } catch {
+    responseData = text;
+  }
+  const newResponse = new Response(text, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+  return {
+    data: responseData,
+    response: newResponse
+  };
+}
+async function del(url, data, options) {
+  let actualData;
+  let actualOptions;
+  if (data !== void 0 && typeof data === "object" && data !== null && "cache" in data) {
+    actualData = void 0;
+    actualOptions = data;
+  } else if (options) {
+    actualData = data;
+    actualOptions = options;
+  } else {
+    throw new Error("Fetch options must include a cache instance or options.");
+  }
+  let body;
+  const headers = { ...actualOptions.headers };
+  if (actualData !== void 0) {
+    if (typeof actualData === "string") {
+      body = actualData;
+    } else if (actualData instanceof FormData || actualData instanceof URLSearchParams || actualData instanceof Blob) {
+      body = actualData;
+    } else {
+      body = JSON.stringify(actualData);
+      if (!headers["Content-Type"] && !headers["content-type"]) {
+        headers["Content-Type"] = "application/json";
+      }
+    }
+  }
+  const response = await fetch(url, {
+    ...actualOptions,
+    headers,
+    body,
+    method: "DELETE"
+  });
+  const text = await response.text();
+  let responseData;
+  try {
+    responseData = JSON.parse(text);
+  } catch {
+    responseData = text;
+  }
+  const newResponse = new Response(text, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
   });
+  return {
+    data: responseData,
+    response: newResponse
+  };
+}
+async function head(url, options) {
+  const response = await fetch(url, { ...options, method: "HEAD" });
+  return response;
 }
 
 // src/index.ts
 var CacheableNet = class extends import_hookified.Hookified {
   _cache = new import_cacheable.Cacheable();
+  _httpCachePolicy = true;
+  _stringify = JSON.stringify;
+  _parse = JSON.parse;
   constructor(options) {
     super(options);
     if (options?.cache) {
       this._cache = options.cache instanceof import_cacheable.Cacheable ? options.cache : new import_cacheable.Cacheable(options.cache);
     }
+    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 policy setting.
+   * @returns {boolean} Whether HTTP cache semantics are enabled
+   */
+  get httpCachePolicy() {
+    return this._httpCachePolicy;
+  }
+  /**
+   * Set whether to use HTTP cache semantics.
+   * @param {boolean} value - Enable or disable HTTP cache semantics
+   */
+  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 `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
+      cache: this._cache,
+      httpCachePolicy: this._httpCachePolicy
     };
     return fetch(url, fetchOptions);
   }
+  /**
+   * 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 {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 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 = parseFn(text);
+    } catch {
+      data = text;
+    }
+    const newResponse = new Response(text, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    return {
+      data,
+      response: newResponse
+    };
+  }
+  /**
+   * 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<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) {
+    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: "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 = 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 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 {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 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 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<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) {
+    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: "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 = 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 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<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) {
+    let body;
+    const headers = { ...options?.headers };
+    if (data !== void 0) {
+      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: "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 = parseFn(text);
+    } catch {
+      responseData = text;
+    }
+    const newResponse = new Response(text, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    return {
+      data: responseData,
+      response: newResponse
+    };
+  }
 };
 var Net = CacheableNet;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CacheableNet,
   Net,
-  fetch
+  del,
+  fetch,
+  get,
+  head,
+  patch,
+  post
 });