@blaze-cache/fetch 0.0.0-stage → 0.2.1-beta

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Blaze Cache
+
+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

@@ -1,3 +1,194 @@
-# Temporary Holding Version
+<p align="center">
+  <img src="https://raw.githubusercontent.com/blaze-cache/blaze-cache/main/docs/blaze-cache-logo.png" alt="Blaze Cache logo" width="150">
+</p>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<h1 align="center">@blaze-cache/fetch</h1>
+
+A drop-in `fetch()` replacement backed by a WebAssembly cache — TTLs, `Cache-Control`,
+stale-while-revalidate and an `x-blaze-cache: HIT | MISS` marker.
+
+## Install
+
+```sh
+npm install @blaze-cache/fetch@beta @blaze-cache/core@beta
+```
+
+`@beta` is npm's dist-tag for the prerelease; drop it to install the last stable
+release.
+
+## Quick start
+
+```ts
+import { createCache } from '@blaze-cache/core';
+import { createBlazeFetch } from '@blaze-cache/fetch';
+
+const cache = await createCache({ capacity: 1000 });
+const fetch = createBlazeFetch(cache, { ttlMs: 30_000 });
+
+const response = await fetch('/api/users');
+response.headers.get('x-blaze-cache'); // 'MISS' …
+```
+
+```ts
+const again = await fetch('/api/users');
+again.headers.get('x-blaze-cache');    // … then 'HIT'
+await again.json();                     // the body replayed from the cache
+```
+
+The wrapper **is** a `fetch`: same signature, same `Response` back. Hand it to anything that
+expects the platform function.
+
+```ts
+const asFetch: typeof fetch = fetch;
+window.fetch = fetch;                   // now every request in the app is cached
+```
+
+## Behaviour
+
+* **Only `GET` is cached** — pass `methods: ['GET', 'HEAD']` to include `HEAD`. Everything
+  else (including errors from uncached methods) always goes to the network.
+* **`Cache-Control` is honoured on both sides** when `cacheControl` is on (the default):
+  on the request, `no-store`/`no-cache` and `max-age=0` skip the read; on the response,
+  `max-age` overrides `ttlMs`, `Age` is deducted, and `no-store`/`no-cache` — the per-field
+  `no-cache="set-cookie"` form included — stop it being stored.
+  `must-revalidate`/`proxy-revalidate` gets no stale window, however short the fresh one.
+* **Identical concurrent requests coalesce** — one caller leads and the rest replay the
+  record it stored, so a burst of the same `GET` opens one connection. Only cacheable
+  requests lead, callers that demanded the network are never joined, and a leader that
+  fails opens the gate over an empty cache so its joiners fetch in turn.
+* **Only successful responses are stored** — the default `shouldCache` keeps `2xx`; replace
+  it to widen or narrow that.
+* **`Authorization` participates in the default key** (hashed, never stored verbatim), so a
+  personalized response is never replayed to a different user. Tune with `varyHeaders`.
+* **The response's own `Vary` is honoured** — `Vary: *` is never stored (RFC 9111 §3), and
+  a response varying on a header you have not put in `varyHeaders` is left uncached rather
+  than replay a variant to the wrong caller. Server headers missing from `varyHeaders`?
+  That is the safe default working as intended — list them to opt in. The check runs
+  before *every* store, `cacheControl: false` included: variant correctness is not a
+  freshness preference.
+* **A hit is a real `Response`** — status, status text, headers, body, `url` after a
+  redirect and `redirected` are replayed exactly, so your code cannot tell the difference
+  apart from the marker header.
+* **Binary, `Blob` and chunked bodies are first-class** — the payload is buffered as raw
+  bytes whether it arrived as a file, a `ReadableStream` or plain text, so an image
+  replays byte-for-byte with its `content-type` intact and `blob().type`/`blob().size`
+  still correct. Buffering runs on a teed clone *after* your `Response` is handed back, so
+  a streaming body is never held up waiting for the cache — and because the record is
+  complete before it is written, a hit can never half-load.
+* **Transport headers are corrected to the bytes stored** — `fetch` decodes
+  `content-encoding` for you, so the record drops `content-encoding` and
+  `transfer-encoding` and rewrites `content-length` to the payload's real size. Without
+  that, a hit would claim `content-length: 1425` (the compressed size) for 6504 stored
+  bytes — which breaks anything that measures a download. `HEAD` keeps its headers: no
+  body was sent, so its `content-length` is what a GET *would* return.
+* **Failures behave like plain `fetch`** — a rejected network call still rejects; a cache
+  that cannot store a response never breaks the request that produced it. Reads, writes
+  and the `shouldCache` callback are all guarded: the first cache-layer failure is
+  announced once on the console, then the wrapper keeps working *without* the cache rather
+  than warning on every call.
+
+## Options
+
+```ts
+const fetch = createBlazeFetch(cache, {
+  ttlMs: 30_000,                        // number | (response, url, init) => number
+  methods: ['GET'],                     // which methods are cacheable
+  cacheControl: true,                   // honour Cache-Control on request + response
+  staleWhileRevalidate: false,          // true | milliseconds — see below
+  key: (url, init) => `${init.method} ${url}`,   // custom cache key
+  shouldCache: (response) => response.ok,        // which responses are stored
+  tags: (response, url) => ['fetch', url],       // tags on stored entries
+  varyHeaders: ['authorization'],       // headers folded into the default key
+  markerHeader: 'x-blaze-cache',        // or false to disable the marker
+  fetch: globalThis.fetch,              // the real network function (for tests)
+});
+```
+
+| Option | Default | What it does |
+| --- | --- | --- |
+| `ttlMs` | `60_000` | Freshness window. Overridden by a response `max-age`. |
+| `methods` | `['GET']` | Methods eligible for caching. |
+| `cacheControl` | `true` | Honour `Cache-Control`/`Age` on both sides. |
+| `staleWhileRevalidate` | `false` | Serve stale entries while refreshing. A number is the fallback window when the response omits the directive. |
+| `key` | method + URL + vary hash | Custom cache key. |
+| `shouldCache` | `2xx` | Which responses are stored. |
+| `tags` | `['fetch', '<method> <url>']` | Tags for `cache.invalidateTags(...)`. |
+| `varyHeaders` | `['authorization']` | Request headers folded into the default key. |
+| `markerHeader` | `'x-blaze-cache'` | Header carrying `HIT`/`MISS`/`STALE`; `false` disables it. |
+| `fetch` | `globalThis.fetch` | The real network call — pass a stub in tests. |
+
+Requests can force the behaviour per call:
+
+```ts
+await fetch('/api/users', { forceRefresh: true });  // bypass the cache read
+await fetch('/api/users', { cache: 'no-cache' });   // the standard spelling of the same
+await fetch('/api/users', { cache: 'no-store' });   // neither read nor write
+```
+
+## Stale-while-revalidate
+
+```ts
+const fetch = createBlazeFetch(cache, { ttlMs: 10_000, staleWhileRevalidate: 30_000 });
+```
+
+Within the stale window a request is answered **immediately** from the cache with
+`x-blaze-cache: STALE`, while a background refresh rewrites the entry — the next request is
+a fresh `HIT`. One refresh runs per key at a time, and its failure is swallowed: a stale
+entry is better than a failed request.
+
+The window comes from the response's `Cache-Control: stale-while-revalidate=<seconds>`;
+the number you pass is only the fallback for servers that do not send it.
+
+## Invalidating
+
+Stored responses carry two tags, so they plug straight into the cache's tag API:
+
+```ts
+cache.invalidateTags('fetch');                 // everything this wrapper stored
+cache.invalidateTags('get /api/users');        // one resource
+cache.set('get /api/users', /* … */);          // … or just overwrite it
+```
+
+## Custom keys
+
+```ts
+import { createBlazeFetch, defaultCacheKey } from '@blaze-cache/fetch';
+
+const fetch = createBlazeFetch(cache, {
+  // Keep the default (method + URL + vary hash) and add a version prefix:
+  key: (url, init) => `v2:${defaultCacheKey(url, init, ['authorization'])}`,
+});
+```
+
+## Testing
+
+Two suites, both run against the built package:
+
+```sh
+pnpm --filter @blaze-cache/fetch test         # stubbed network — deterministic, offline
+pnpm --filter @blaze-cache/fetch test:live    # real public API — opt-in, needs the network
+```
+
+The live suite calls `api.github.com`, `raw.githubusercontent.com` and
+`jsonplaceholder.typicode.com` — all keyless, and well within GitHub's unauthenticated 60
+requests/hour — to prove that *real* `Cache-Control` and `Vary` headers are read
+correctly; a stub can only simulate that. It also lists each server's vary headers in
+`varyHeaders`, which is exactly the configuration a real deployment needs: a response
+varying on a header the key does not fold in is deliberately left uncached.
+Every test in it is skipped unless `BLAZE_CACHE_LIVE=1` is set, so the default suite always
+passes with no network at all.
+
+## Documentation
+
+Setup, core concepts and the complete API reference live in the
+[repository README](https://github.com/blaze-cache/blaze-cache#readme).
+
+## Part of Blaze Cache
+
+* [`@blaze-cache/core`](https://www.npmjs.com/package/@blaze-cache/core) — the cache itself
+* [`@blaze-cache/axios`](https://www.npmjs.com/package/@blaze-cache/axios) — the axios adapter
+* [`@blaze-cache/react-query`](https://www.npmjs.com/package/@blaze-cache/react-query) — TanStack Query v5 mirror
+
+## License
+
+[MIT](https://github.com/blaze-cache/blaze-cache/blob/main/LICENSE) © Blaze Cache

package/dist/cache-control.d.ts

@@ -0,0 +1,55 @@
+/**
+ * What `Cache-Control` (and the related `Age`) say about a request or a response — plus the
+ * one `Vary` question a keying client must answer before storing anything.
+ *
+ * Package-local on purpose: this wrapper needs the `stale-while-revalidate` directive, which
+ * `@blaze-cache/axios` does not, and each package is free to grow its own directives without
+ * dragging the others along.
+ */
+export interface CacheControl {
+    /** `no-store` — neither read nor write the cache. */
+    noStore: boolean;
+    /** `no-cache` — must not be served without revalidating, per-field spellings (`no-cache="…"`) included. */
+    noCache: boolean;
+    /** `must-revalidate` (or the shared-cache spelling `proxy-revalidate`) — never serve a stale response. */
+    mustRevalidate: boolean;
+    /** `max-age=<seconds>`, converted to milliseconds. */
+    maxAgeMs: number | undefined;
+    /** `stale-while-revalidate=<seconds>`, converted to milliseconds. */
+    staleWhileRevalidateMs: number | undefined;
+}
+/** The value used when parsing is switched off (`cacheControl: false`) or a header is absent. */
+export declare const NO_DIRECTIVES: CacheControl;
+/**
+ * Minimal `Cache-Control` parser — only the directives a client-side cache acts on.
+ *
+ * ```ts
+ * parseCacheControl('max-age=30, stale-while-revalidate=120').maxAgeMs; // 30_000
+ * ```
+ */
+export declare function parseCacheControl(value: string | undefined | null): CacheControl;
+/**
+ * Whether a response carrying `Vary: <responseVary>` may be stored under a key that already
+ * folds in `varyHeaders`.
+ *
+ * `Vary` names the *request* headers the response's identity depends on — `Cookie`,
+ * `Accept-Language`, `Origin`. A cache may only replay a stored response to a request whose
+ * keyed headers match, so a response varying on anything **not** folded into the key cannot
+ * be keyed correctly, and the only safe verdict is "store nothing": storing anyway would
+ * replay one caller's variant — another user's private payload, another locale's page — to
+ * the next caller whose unkeyed header happens to differ. `Vary: *` advertises variants
+ * that are unknowable by construction and is never cacheable (RFC 9111 §3).
+ *
+ * An absent, empty or unparsable header varies on nothing and is always storable; a listed
+ * name that *is* folded in (case-insensitively, as header names are) makes the response
+ * storable.
+ */
+export declare function varyIsStorable(responseVary: string | null, varyHeaders: readonly string[]): boolean;
+/**
+ * `Age: <seconds>` — how long an intermediate cache has been holding the response.
+ *
+ * The freshness window shrinks by this much: a response that is already halfway to its
+ * `max-age` deadline must not look brand new to us. Anything unparsable counts as zero.
+ */
+export declare function parseAgeMs(value: string | undefined | null): number;
+//# sourceMappingURL=cache-control.d.ts.map

package/dist/cache-control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-control.d.ts","sourceRoot":"","sources":["../src/cache-control.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,YAAY;IAC3B,qDAAqD;IACrD,OAAO,EAAE,OAAO,CAAC;IACjB,2GAA2G;IAC3G,OAAO,EAAE,OAAO,CAAC;IACjB,0GAA0G;IAC1G,cAAc,EAAE,OAAO,CAAC;IACxB,sDAAsD;IACtD,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,qEAAqE;IACrE,sBAAsB,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5C;AAED,iGAAiG;AACjG,eAAO,MAAM,aAAa,EAAE,YAM1B,CAAC;AAEH;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,YAAY,CAiChF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,EAAE,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAYnG;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,CAInE"}

package/dist/cache-control.js

@@ -0,0 +1,110 @@
+/**
+ * What `Cache-Control` (and the related `Age`) say about a request or a response — plus the
+ * one `Vary` question a keying client must answer before storing anything.
+ *
+ * Package-local on purpose: this wrapper needs the `stale-while-revalidate` directive, which
+ * `@blaze-cache/axios` does not, and each package is free to grow its own directives without
+ * dragging the others along.
+ */
+/** The value used when parsing is switched off (`cacheControl: false`) or a header is absent. */
+export const NO_DIRECTIVES = Object.freeze({
+    noStore: false,
+    noCache: false,
+    mustRevalidate: false,
+    maxAgeMs: undefined,
+    staleWhileRevalidateMs: undefined,
+});
+/**
+ * Minimal `Cache-Control` parser — only the directives a client-side cache acts on.
+ *
+ * ```ts
+ * parseCacheControl('max-age=30, stale-while-revalidate=120').maxAgeMs; // 30_000
+ * ```
+ */
+export function parseCacheControl(value) {
+    const result = {
+        noStore: false,
+        noCache: false,
+        mustRevalidate: false,
+        maxAgeMs: undefined,
+        staleWhileRevalidateMs: undefined,
+    };
+    if (!value)
+        return result;
+    for (const rawDirective of value.split(',')) {
+        const directive = rawDirective.trim().toLowerCase();
+        if (directive === 'no-store') {
+            result.noStore = true;
+        }
+        else if (directive === 'no-cache') {
+            result.noCache = true;
+        }
+        else if (directive.startsWith('no-cache=')) {
+            // `no-cache="set-cookie, field2"` — reuse is forbidden until *those fields* have been
+            // revalidated, and this cache cannot revalidate individual fields, so it must read as
+            // the whole-response spelling. Matching only the bare directive would silently turn
+            // this opt-out back into "cacheable".
+            result.noCache = true;
+        }
+        else if (directive === 'must-revalidate' || directive === 'proxy-revalidate') {
+            // Two spellings of one rule — never serve a stale response. `proxy-revalidate` is the
+            // shared-cache name; a browser cache ignoring it would be just as wrong.
+            result.mustRevalidate = true;
+        }
+        else if (directive.startsWith('max-age=')) {
+            result.maxAgeMs = seconds(directive.slice('max-age='.length));
+        }
+        else if (directive.startsWith('stale-while-revalidate=')) {
+            result.staleWhileRevalidateMs = seconds(directive.slice('stale-while-revalidate='.length));
+        }
+    }
+    return result;
+}
+/**
+ * Whether a response carrying `Vary: <responseVary>` may be stored under a key that already
+ * folds in `varyHeaders`.
+ *
+ * `Vary` names the *request* headers the response's identity depends on — `Cookie`,
+ * `Accept-Language`, `Origin`. A cache may only replay a stored response to a request whose
+ * keyed headers match, so a response varying on anything **not** folded into the key cannot
+ * be keyed correctly, and the only safe verdict is "store nothing": storing anyway would
+ * replay one caller's variant — another user's private payload, another locale's page — to
+ * the next caller whose unkeyed header happens to differ. `Vary: *` advertises variants
+ * that are unknowable by construction and is never cacheable (RFC 9111 §3).
+ *
+ * An absent, empty or unparsable header varies on nothing and is always storable; a listed
+ * name that *is* folded in (case-insensitively, as header names are) makes the response
+ * storable.
+ */
+export function varyIsStorable(responseVary, varyHeaders) {
+    if (responseVary === null)
+        return true;
+    const names = responseVary
+        .split(',')
+        .map((name) => name.trim().toLowerCase())
+        .filter((name) => name.length > 0);
+    if (names.length === 0)
+        return true; // `Vary:` with no names varies on nothing
+    if (names.includes('*'))
+        return false; // RFC 9111 §3: never usable from a cache
+    const keyed = new Set(varyHeaders.map((name) => name.toLowerCase()));
+    return names.every((name) => keyed.has(name));
+}
+/**
+ * `Age: <seconds>` — how long an intermediate cache has been holding the response.
+ *
+ * The freshness window shrinks by this much: a response that is already halfway to its
+ * `max-age` deadline must not look brand new to us. Anything unparsable counts as zero.
+ */
+export function parseAgeMs(value) {
+    if (!value)
+        return 0;
+    const secondsValue = Number(value.trim());
+    return Number.isFinite(secondsValue) && secondsValue >= 0 ? secondsValue * 1000 : 0;
+}
+/** Seconds → milliseconds, or `undefined` when the value is not a usable non-negative number. */
+function seconds(raw) {
+    const value = Number(raw.trim());
+    return Number.isFinite(value) && value >= 0 ? value * 1000 : undefined;
+}
+//# sourceMappingURL=cache-control.js.map

package/dist/cache-control.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-control.js","sourceRoot":"","sources":["../src/cache-control.ts"],"names":[],"mappings":"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"}

package/dist/client.d.ts

@@ -0,0 +1,21 @@
+import type { BlazeFetch, BlazeFetchCacheLike, BlazeFetchOptions } from './types.js';
+/**
+ * Wraps the platform `fetch` with a Blaze Cache layer.
+ *
+ * ```ts
+ * import { createCache } from '@blaze-cache/core';
+ * import { createBlazeFetch } from '@blaze-cache/fetch';
+ *
+ * const cache = await createCache({ capacity: 1000 });
+ * const fetch = createBlazeFetch(cache, { ttlMs: 30_000 });
+ *
+ * const response = await fetch('/api/users');
+ * response.headers.get('x-blaze-cache'); // 'MISS', then 'HIT' on the next call
+ * ```
+ *
+ * The returned function keeps the platform signature — hand it to anything expecting
+ * `typeof fetch`. Requests outside {@link BlazeFetchOptions.methods} pass through untouched,
+ * and a failing network call rejects exactly as it would have without the wrapper.
+ */
+export declare function createBlazeFetch(cache: BlazeFetchCacheLike, options?: BlazeFetchOptions): BlazeFetch;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,UAAU,EACV,mBAAmB,EAInB,iBAAiB,EAElB,MAAM,YAAY,CAAC;AAgBpB;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,mBAAmB,EAC1B,OAAO,GAAE,iBAAsB,GAC9B,UAAU,CA2TZ"}