@cacheable/net 1.0.1

package/LICENSE

@@ -0,0 +1,19 @@
+MIT License & © Jared Wray 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+[<img align="center" src="https://cacheable.org/logo.svg" alt="Cacheable" />](https://github.com/jaredwray/cacheable)
+
+> High Performance Network Caching for Node.js with fetch, request, http 1.1, and http 2 support
+
+[![codecov](https://codecov.io/gh/jaredwray/cacheable/graph/badge.svg?token=lWZ9OBQ7GM)](https://codecov.io/gh/jaredwray/cacheable)
+[![tests](https://github.com/jaredwray/cacheable/actions/workflows/tests.yml/badge.svg)](https://github.com/jaredwray/cacheable/actions/workflows/tests.yml)
+[![npm](https://img.shields.io/npm/dm/@cacheable/net.svg)](https://www.npmjs.com/package/@cacheable/net)
+[![npm](https://img.shields.io/npm/v/@cacheable/net.svg)](https://www.npmjs.com/package/@cacheable/net)
+[![license](https://img.shields.io/github/license/jaredwray/cacheable)](https://github.com/jaredwray/cacheable/blob/main/LICENSE)
+
+
+Features:
+* `fetch` from [undici](https://github.com/nodejs/undici) cache enabled via `cacheable`
+* `fetch` quick helpers such as `get`, `post`, `put`, and `delete` for easier development
+* `request` from [undici](https://github.com/nodejs/undici) cache enabled via `cacheable`
+* HTTP/1.1 and HTTP/2 caching support via Node.js `http` and `https` modules
+* [RFC 7234](http://httpwg.org/specs/rfc7234.html) compliant HTTP caching for native Node.js HTTP/HTTPS requests
+* Drop in replacement for `http` `https`, `fetch` modules with caching enabled
+* DNS caching for `dns.lookup` and `dns.resolve` methods via `cacheable`
+* WHOIS caching for `whois.lookup` method via `cacheable`
+* Advanced key generation via built in hashing and custom key generation functions
+* Benchmarks for performance comparison
+* All the features of [cacheable](https://npmjs.com/package/cacheable) - layered caching, LRU, expiration, hooks, backed by Keyv, and more!
+* Highly Tested and Maintained on a regular basis with a focus on performance and reliability
+
+# Table of Contents
+* [Getting Started](#getting-started)
+* [How to Contribute](#how-to-contribute)
+* [License and Copyright](#license-and-copyright)
+
+# Getting Started
+
+```bash
+npm install @cacheable/net
+```
+
+
+# How to Contribute
+
+You can contribute by forking the repo and submitting a pull request. Please make sure to add tests and update the documentation. To learn more about how to contribute go to our main README [https://github.com/jaredwray/cacheable](https://github.com/jaredwray/cacheable). This will talk about how to `Open a Pull Request`, `Ask a Question`, or `Post an Issue`.
+
+# License and Copyright
+[MIT © Jared Wray](./LICENSE)

package/dist/index.cjs

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CacheableNet: () => CacheableNet,
+  Net: () => Net,
+  fetch: () => fetch
+});
+module.exports = __toCommonJS(index_exports);
+var import_cacheable = require("cacheable");
+var import_hookified = require("hookified");
+
+// src/fetch.ts
+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}`);
+    }
+    return response;
+  });
+}
+
+// src/index.ts
+var CacheableNet = class extends import_hookified.Hookified {
+  _cache = new import_cacheable.Cacheable();
+  constructor(options) {
+    super(options);
+    if (options?.cache) {
+      this._cache = options.cache instanceof import_cacheable.Cacheable ? options.cache : new import_cacheable.Cacheable(options.cache);
+    }
+  }
+  get cache() {
+    return this._cache;
+  }
+  set cache(value) {
+    this._cache = value;
+  }
+  /**
+   * Fetch data from a URL with optional request options. Will use the cache that is already set in the instance.
+   * @param {string} url The URL to fetch.
+   * @param {FetchRequestInit} options Optional request options.
+   * @returns {Promise<FetchResponse>} The response from the fetch.
+   */
+  async fetch(url, options) {
+    const fetchOptions = {
+      ...options,
+      cache: this._cache
+    };
+    return fetch(url, fetchOptions);
+  }
+};
+var Net = CacheableNet;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CacheableNet,
+  Net,
+  fetch
+});

package/dist/index.d.cts

@@ -0,0 +1,37 @@
+import { Cacheable, CacheableOptions } from 'cacheable';
+import { HookifiedOptions, Hookified } from 'hookified';
+import { Response as Response$1, RequestInit } from 'undici';
+export { RequestInit as FetchRequestInit } from 'undici';
+
+type FetchOptions = Omit<RequestInit, "cache"> & {
+    cache: Cacheable;
+};
+/**
+ * Fetch data from a URL with optional request options.
+ * @param {string} url The URL to fetch.
+ * @param {FetchOptions} options Optional request options. The `cacheable` property is required and should be an
+ * instance of `Cacheable` or a `CacheableOptions` object.
+ * @returns {Promise<UndiciResponse>} The response from the fetch.
+ */
+declare function fetch(url: string, options: FetchOptions): Promise<Response$1>;
+type Response = Response$1;
+
+type CacheableNetOptions = {
+    cache?: Cacheable | CacheableOptions;
+} & HookifiedOptions;
+declare class CacheableNet extends Hookified {
+    private _cache;
+    constructor(options?: CacheableNetOptions);
+    get cache(): Cacheable;
+    set cache(value: Cacheable);
+    /**
+     * Fetch data from a URL with optional request options. Will use the cache that is already set in the instance.
+     * @param {string} url The URL to fetch.
+     * @param {FetchRequestInit} options Optional request options.
+     * @returns {Promise<FetchResponse>} The response from the fetch.
+     */
+    fetch(url: string, options?: RequestInit): Promise<Response>;
+}
+declare const Net: typeof CacheableNet;
+
+export { CacheableNet, type CacheableNetOptions, type FetchOptions, type Response as FetchResponse, Net, fetch };

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import { Cacheable, CacheableOptions } from 'cacheable';
+import { HookifiedOptions, Hookified } from 'hookified';
+import { Response as Response$1, RequestInit } from 'undici';
+export { RequestInit as FetchRequestInit } from 'undici';
+
+type FetchOptions = Omit<RequestInit, "cache"> & {
+    cache: Cacheable;
+};
+/**
+ * Fetch data from a URL with optional request options.
+ * @param {string} url The URL to fetch.
+ * @param {FetchOptions} options Optional request options. The `cacheable` property is required and should be an
+ * instance of `Cacheable` or a `CacheableOptions` object.
+ * @returns {Promise<UndiciResponse>} The response from the fetch.
+ */
+declare function fetch(url: string, options: FetchOptions): Promise<Response$1>;
+type Response = Response$1;
+
+type CacheableNetOptions = {
+    cache?: Cacheable | CacheableOptions;
+} & HookifiedOptions;
+declare class CacheableNet extends Hookified {
+    private _cache;
+    constructor(options?: CacheableNetOptions);
+    get cache(): Cacheable;
+    set cache(value: Cacheable);
+    /**
+     * Fetch data from a URL with optional request options. Will use the cache that is already set in the instance.
+     * @param {string} url The URL to fetch.
+     * @param {FetchRequestInit} options Optional request options.
+     * @returns {Promise<FetchResponse>} The response from the fetch.
+     */
+    fetch(url: string, options?: RequestInit): Promise<Response>;
+}
+declare const Net: typeof CacheableNet;
+
+export { CacheableNet, type CacheableNetOptions, type FetchOptions, type Response as FetchResponse, Net, fetch };

package/dist/index.js

@@ -0,0 +1,60 @@
+// src/index.ts
+import { Cacheable } from "cacheable";
+import { Hookified } from "hookified";
+
+// src/fetch.ts
+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"
+  };
+  return options.cache.getOrSet(url, async () => {
+    const response = await undiciFetch(url, fetchOptions);
+    if (!response.ok) {
+      throw new Error(`Fetch failed with status ${response.status}`);
+    }
+    return response;
+  });
+}
+
+// src/index.ts
+var CacheableNet = class extends Hookified {
+  _cache = new Cacheable();
+  constructor(options) {
+    super(options);
+    if (options?.cache) {
+      this._cache = options.cache instanceof Cacheable ? options.cache : new Cacheable(options.cache);
+    }
+  }
+  get cache() {
+    return this._cache;
+  }
+  set cache(value) {
+    this._cache = value;
+  }
+  /**
+   * Fetch data from a URL with optional request options. Will use the cache that is already set in the instance.
+   * @param {string} url The URL to fetch.
+   * @param {FetchRequestInit} options Optional request options.
+   * @returns {Promise<FetchResponse>} The response from the fetch.
+   */
+  async fetch(url, options) {
+    const fetchOptions = {
+      ...options,
+      cache: this._cache
+    };
+    return fetch(url, fetchOptions);
+  }
+};
+var Net = CacheableNet;
+export {
+  CacheableNet,
+  Net,
+  fetch
+};

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@cacheable/net",
+  "version": "1.0.1",
+  "description": "High Performance Network Caching for Node.js with fetch, request, http 1.1, and http 2 support",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jaredwray/cacheable.git",
+    "directory": "packages/cacheable"
+  },
+  "author": "Jared Wray <me@jaredwray.com>",
+  "license": "MIT",
+  "private": false,
+  "devDependencies": {
+    "@biomejs/biome": "^2.2.2",
+    "@faker-js/faker": "^10.0.0",
+    "@types/node": "^24.3.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "rimraf": "^6.0.1",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "dependencies": {
+    "hookified": "^1.12.0",
+    "undici": "^7.15.0",
+    "cacheable": "^1.10.4"
+  },
+  "keywords": [
+    "cacheable",
+    "http caching",
+    "fetch caching",
+    "request caching",
+    "http 1.1 caching",
+    "http 2 caching",
+    "dns caching",
+    "whois caching",
+    "high performance",
+    "layer 1 caching",
+    "layer 2 caching",
+    "distributed caching",
+    "keyv",
+    "expiration",
+    "CacheableMemory",
+    "distributed sync",
+    "secondary store",
+    "primary store",
+    "cache statistics",
+    "layered caching",
+    "fault tolerant",
+    "in-memory cache",
+    "distributed cache",
+    "lru",
+    "multi-tier cache"
+  ],
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "rimraf ./dist && tsup src/index.ts --format cjs,esm --dts --clean",
+    "prepublish": "pnpm build",
+    "lint": "biome check --write --error-on-warnings",
+    "test": "pnpm lint && vitest run --coverage",
+    "test:ci": "biome check --error-on-warnings && vitest run --coverage",
+    "clean": "rimraf ./dist ./coverage ./node_modules"
+  }
+}