jskelet 0.5.2 → 0.5.4

package/src/index.js

@@ -35,6 +35,13 @@ export {
   setCookie,
   setSignedCookie,
 } from "./http/cookies.js";
+export {
+  clearSharedCookie,
+  requestIsHttps,
+  resolveSharedCookieDomain,
+  SHARED_COOKIE_WARN_BYTES,
+  writeSharedCookie,
+} from "./http/shared-cookie.js";
 export { reportUpstreamFailure } from "./server/upstream-tracking.js";
 export { asset, hasAsset, optimizedImage, getSpriteIds } from "./server/assets.js";
 export { remoteImageUrl, parseAllowedRemoteUrl } from "./server/image-optimizer.js";

package/src/server/auth/handoff.js

@@ -0,0 +1,226 @@
+/**
+ * Alt alan adı handoff: kısa ömürlü tek kullanımlık bilet.
+ *
+ * Akış:
+ *   1. Paylaşımlı cookie yazımı başarısız (istemci read-back fail)
+ *   2. POST /_jskelet/auth/handoff { name, value, next }
+ *   3. Yanıt { url: "https://tr.…/path?handoff=TICKET" }
+ *   4. Hedef host'ta GET middleware bileti tüketir → Set-Cookie + 303
+ *
+ * Bilet süreç belleğinde; tek süreçte tüm locale host'ları servis eden
+ * kurulumlar için yeterli. Değer kısa session id olmalı.
+ */
+import { getConfig } from "../../config/index.js";
+import { randomToken, setCookie } from "../../http/cookies.js";
+import {
+  SHARED_COOKIE_WARN_BYTES,
+  requestIsHttps,
+  writeSharedCookie,
+} from "../../http/shared-cookie.js";
+import { resolveSharedCookieDomain } from "../../shared/cookie-domain.js";
+
+/** @type {Map<string, { name: string, value: string, maxAge?: number, exp: number }>} */
+const tickets = new Map();
+
+const DEFAULT_TTL_SECONDS = 60;
+const HANDOFF_PATH = "/_jskelet/auth/handoff";
+
+/**
+ * @returns {{ enabled: boolean, ttlSeconds: number, path: string, maxValueBytes: number }}
+ */
+function settings() {
+  const auth = getConfig().auth ?? {};
+  const raw = auth.crossSubdomainHandoff;
+  if (raw === false || raw == null) {
+    return {
+      enabled: false,
+      ttlSeconds: DEFAULT_TTL_SECONDS,
+      path: HANDOFF_PATH,
+      maxValueBytes: SHARED_COOKIE_WARN_BYTES,
+    };
+  }
+
+  if (raw === true) {
+    return {
+      enabled: true,
+      ttlSeconds: DEFAULT_TTL_SECONDS,
+      path: HANDOFF_PATH,
+      maxValueBytes: SHARED_COOKIE_WARN_BYTES,
+    };
+  }
+
+  const source = /** @type {Record<string, unknown>} */ (raw);
+  const ttl = Number(source.ttlSeconds);
+  const maxBytes = Number(source.maxValueBytes);
+  return {
+    enabled: source.enabled !== false,
+    ttlSeconds:
+      Number.isFinite(ttl) && ttl > 0 ? Math.min(300, Math.floor(ttl)) : DEFAULT_TTL_SECONDS,
+    path:
+      typeof source.path === "string" && source.path.startsWith("/")
+        ? source.path
+        : HANDOFF_PATH,
+    maxValueBytes:
+      Number.isFinite(maxBytes) && maxBytes > 0
+        ? Math.floor(maxBytes)
+        : SHARED_COOKIE_WARN_BYTES,
+  };
+}
+
+function sweep() {
+  const now = Date.now();
+  for (const [id, entry] of tickets) {
+    if (entry.exp <= now) tickets.delete(id);
+  }
+}
+
+/**
+ * @param {string} next
+ * @param {import('express').Request} req
+ * @returns {URL | null}
+ */
+function parseNext(next, req) {
+  try {
+    return new URL(next, `${req.protocol}://${req.get("host")}`);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {URL} url
+ * @param {import('express').Request} req
+ * @returns {boolean}
+ */
+function nextAllowed(url, req) {
+  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+
+  const roots = getConfig().brand?.sharedCookieRoots ?? [];
+  const targetHost = url.hostname.toLowerCase();
+  const sourceHost = String(req.hostname || "")
+    .toLowerCase()
+    .replace(/:\d+$/, "");
+
+  if (targetHost === sourceHost) return true;
+
+  const sourceRoot = resolveSharedCookieDomain(sourceHost, roots);
+  const targetRoot = resolveSharedCookieDomain(targetHost, roots);
+  return Boolean(sourceRoot && targetRoot && sourceRoot === targetRoot);
+}
+
+/**
+ * @param {import('express').Request} req
+ * @param {import('express').Response} res
+ * @param {{ name: string, value: string, maxAge?: number }} payload
+ * @returns {void}
+ */
+function issueCookie(req, res, payload) {
+  const shared = writeSharedCookie(res, payload.name, payload.value, {
+    req,
+    maxAge: payload.maxAge,
+  });
+
+  if (shared.ok) return;
+
+  setCookie(res, payload.name, payload.value, {
+    path: "/",
+    httpOnly: true,
+    sameSite: "Lax",
+    secure: requestIsHttps(req),
+    maxAge: payload.maxAge,
+  });
+}
+
+/**
+ * @param {string} ticketId
+ * @returns {{ name: string, value: string, maxAge?: number } | null}
+ */
+function redeem(ticketId) {
+  sweep();
+  const entry = tickets.get(ticketId);
+  if (!entry) return null;
+  tickets.delete(ticketId);
+  if (entry.exp <= Date.now()) return null;
+  return { name: entry.name, value: entry.value, maxAge: entry.maxAge };
+}
+
+/**
+ * Handoff uçlarını mount eder. `auth.crossSubdomainHandoff` kapalıysa no-op.
+ *
+ * @param {import('express').Express} app
+ * @returns {void}
+ */
+export function mountAuthHandoff(app) {
+  const cfg = settings();
+  if (!cfg.enabled) return;
+
+  app.post(cfg.path, (req, res) => {
+    sweep();
+
+    const name = typeof req.body?.name === "string" ? req.body.name.trim() : "";
+    const value = typeof req.body?.value === "string" ? req.body.value : "";
+    const next = typeof req.body?.next === "string" ? req.body.next.trim() : "";
+    const maxAge =
+      req.body?.maxAge != null && Number.isFinite(Number(req.body.maxAge))
+        ? Math.floor(Number(req.body.maxAge))
+        : undefined;
+
+    if (!name || !next) {
+      res.status(400).json({ ok: false, error: "name and next are required" });
+      return;
+    }
+
+    if (Buffer.byteLength(value, "utf8") > cfg.maxValueBytes) {
+      res.status(400).json({
+        ok: false,
+        error: `value exceeds ${cfg.maxValueBytes} bytes; use a short session id`,
+      });
+      return;
+    }
+
+    const nextUrl = parseNext(next, req);
+    if (!nextUrl || !nextAllowed(nextUrl, req)) {
+      res.status(400).json({ ok: false, error: "next is not an allowed URL" });
+      return;
+    }
+
+    const id = randomToken(24);
+    tickets.set(id, {
+      name,
+      value,
+      maxAge,
+      exp: Date.now() + cfg.ttlSeconds * 1000,
+    });
+
+    nextUrl.searchParams.set("handoff", id);
+    res.setHeader("Cache-Control", "no-store");
+    res.json({ ok: true, url: nextUrl.href });
+  });
+
+  // Hedef host'ta `?handoff=` yakala — route render'ından önce.
+  app.use((req, res, next) => {
+    if (req.method !== "GET" && req.method !== "HEAD") return next();
+    const ticket = typeof req.query?.handoff === "string" ? req.query.handoff : "";
+    if (!ticket) return next();
+
+    const payload = redeem(ticket);
+    if (!payload) return next();
+
+    issueCookie(req, res, payload);
+
+    const url = new URL(req.originalUrl || req.url, `${req.protocol}://${req.get("host")}`);
+    url.searchParams.delete("handoff");
+    res.setHeader("Cache-Control", "no-store");
+    res.redirect(303, url.pathname + url.search + url.hash);
+  });
+}
+
+/** @returns {void} */
+export function _resetHandoffTickets() {
+  tickets.clear();
+}
+
+/** @returns {number} */
+export function _handoffTicketCount() {
+  return tickets.size;
+}

package/src/server/cache-vary.js

@@ -0,0 +1,113 @@
+/**
+ * HTML cache anahtarına host / header / özel fn ile sabit vary parçası ekler.
+ *
+ * CDN zaten tam URL ile ayırır; asıl risk origin L1 ve Redis HTML anahtarı —
+ * host'tan locale üreten sitelerde `vary.host: true` olmadan ilk locale'in
+ * HTML'i diğer host'a servis edilir.
+ */
+import { getConfig } from "../config/index.js";
+
+/**
+ * Public Host: `x-forwarded-host` (ilk değer) yoksa `Host`. Lowercase, portsuz.
+ * IPv6 (`[::1]:3000`) köşeli parantezleri korur.
+ *
+ * @param {{ headers?: Record<string, unknown>, get?: (name: string) => string | undefined }} req
+ * @returns {string}
+ */
+export function publicHost(req) {
+  const forwarded = headerValue(req, "x-forwarded-host");
+  const raw = forwarded || headerValue(req, "host") || "";
+  const first = raw.split(",")[0].trim().toLowerCase();
+  return stripPort(first);
+}
+
+/**
+ * @param {string} host
+ * @returns {string}
+ */
+function stripPort(host) {
+  if (!host) return "";
+  if (host.startsWith("[")) {
+    const end = host.indexOf("]");
+    return end === -1 ? host : host.slice(0, end + 1);
+  }
+  // Birden fazla `:` → portsuz IPv6 (Host'ta nadir); tek `:` → host:port.
+  const colon = host.lastIndexOf(":");
+  if (colon === -1) return host;
+  if (host.indexOf(":") !== colon) return host;
+  return host.slice(0, colon);
+}
+
+/**
+ * @param {{ headers?: Record<string, unknown>, get?: (name: string) => string | undefined }} req
+ * @param {string} name
+ * @returns {string}
+ */
+function headerValue(req, name) {
+  const viaGet = req.get?.(name);
+  if (typeof viaGet === "string" && viaGet) return viaGet;
+
+  const raw = req.headers?.[name.toLowerCase()];
+  if (Array.isArray(raw)) return raw[0] ? String(raw[0]) : "";
+  if (raw == null) return "";
+  return String(raw);
+}
+
+/**
+ * Anahtarın başına eklenen önek: `h=tr.example.com|` veya
+ * `h=…&x-locale=tr|`. Vary yoksa boş string.
+ *
+ * @param {{ headers?: Record<string, unknown>, get?: (name: string) => string | undefined }} [req]
+ * @returns {string}
+ */
+export function buildVaryPrefix(req) {
+  if (!req) return "";
+
+  let vary;
+  try {
+    vary = getConfig().cacheVary;
+  } catch {
+    return "";
+  }
+
+  if (!vary || (!vary.host && !vary.headers.length && !vary.fn)) return "";
+
+  /** @type {string[]} */
+  const parts = [];
+
+  if (vary.host) {
+    const host = publicHost(req);
+    if (host) parts.push(`h=${host}`);
+  }
+
+  for (const name of vary.headers) {
+    const value = headerValue(req, name).trim();
+    if (value) parts.push(`${name}=${value}`);
+  }
+
+  if (typeof vary.fn === "function") {
+    try {
+      const custom = vary.fn(/** @type {import('express').Request} */ (req));
+      if (custom != null && custom !== "") parts.push(String(custom));
+    } catch (error) {
+      console.warn("[cache] cache().vary.fn threw, ignoring it", error);
+    }
+  }
+
+  return parts.length ? `${parts.join("&")}|` : "";
+}
+
+/**
+ * Anahtardan yol kısmını çıkarır (`[vary|]yol?query` → `yol`).
+ * Invalidation hedefleri `/…` ile başlar; vary öneki eşleşmeye karışmamalı.
+ *
+ * @param {string} key
+ * @returns {string}
+ */
+export function pathOfCacheKey(key) {
+  const mark = key.indexOf("?");
+  const beforeQuery = mark === -1 ? key : key.slice(0, mark);
+  const sep = beforeQuery.indexOf("|/");
+  if (sep !== -1) return beforeQuery.slice(sep + 1);
+  return beforeQuery;
+}

package/src/server/create-app.js

@@ -21,6 +21,9 @@
  *      body parser'dan önce, admin ile aynı katmanda.
  *   5. body parser'lar — statikten sonra: görsel isteklerinde gövde ayrıştırma
  *      maliyeti ödenmesin.
+ *   5b. auth handoff (açıksa) — POST bilet + `?handoff=` redeem; csrf'den
+ *      önce değil sonra: JSON gövde parser'ı hazır olsun. Redeem GET route
+ *      render'ından önce olmalı.
  *   6. csrf — body parser'lardan sonra olmalı: token form alanından okunuyor.
  *      Rewrite'lardan önce, çünkü kontrol istemcinin gördüğü yola bakar.
  *   7. rewrites(afterFiles) — statik denendikten sonra, sayfalardan önce.
@@ -149,6 +152,17 @@ export async function createApp(options = {}) {
   app.use(express.urlencoded({ extended: false, limit: "64kb" }));
   app.use(express.json({ limit: "256kb" }));
 
+  const handoff = config.auth?.crossSubdomainHandoff;
+  if (
+    handoff === true ||
+    (handoff &&
+      typeof handoff === "object" &&
+      /** @type {{ enabled?: boolean }} */ (handoff).enabled !== false)
+  ) {
+    const { mountAuthHandoff } = await import("./auth/handoff.js");
+    mountAuthHandoff(app);
+  }
+
   app.use(csrf());
 
   app.use(configRewrites("afterFiles"));

package/src/server/html-cache.js

@@ -34,6 +34,7 @@ import { getConfig } from "../config/index.js";
 import { DEFAULT_HTML_CACHE_MAX_ENTRIES } from "../config/defaults.js";
 import { collectDependencies } from "./cache-deps.js";
 import { compilePattern, matchPattern } from "../config/pattern.js";
+import { pathOfCacheKey } from "./cache-vary.js";
 import {
   cacheKey,
   onCacheEvent,
@@ -662,8 +663,9 @@ function invalidateKey(key, hard) {
  * arkada ve anahtar başına tek seferde koşar. `hard: true` yalnızca eski
  * HTML'in gerçekten geçersiz olduğu durumlar için.
  *
- * Anahtar `yol?query` olduğundan eşleştirme **yol kısmına** yapılır: bir
- * yolun bütün query varyantları (`?utm_source=…` dahil) tek çağrıyla düşer.
+ * Anahtar `yol?query` (isteğe bağlı `vary|` önekiyle) olduğundan eşleştirme
+ * **yol kısmına** yapılır: bir yolun bütün query / host varyantları tek
+ * çağrıyla düşer.
  *
  * @param {string | RegExp | (string | RegExp)[]} target
  * @param {{ hard?: boolean }} [options]
@@ -733,14 +735,14 @@ function compileMatchers(targets) {
 }
 
 /**
- * Anahtar `yol?query`; eşleştirme **yol kısmına** yapılır.
+ * Anahtar `[vary|]yol?query`; eşleştirme **yol** kısmına yapılır.
+ * Vary öneki (`h=…|`) invalidation hedefiyle karışmasın.
  *
  * @param {string} key
  * @returns {string}
  */
 function pathOf(key) {
-  const mark = key.indexOf("?");
-  return mark === -1 ? key : key.slice(0, mark);
+  return pathOfCacheKey(key);
 }
 
 /**
@@ -879,6 +881,9 @@ function dropLocalKey(key) {
  * boşaltır. Isıtma turu bunları başa alır; iki tur aynı yolu tekrar
  * ısıtmasın diye okuma yıkıcıdır.
  *
+ * Vary öneki (`h=…|`) düşülür — HTTP ısıtması yalnızca yolu ister; host
+ * ayrımı `prewarm.origins` / istek Host'u ile yapılır.
+ *
  * @returns {string[]}
  */
 export function takeInvalidatedPaths() {
@@ -886,8 +891,13 @@ export function takeInvalidatedPaths() {
 
   const paths = [...invalidated];
   invalidated.clear();
-  // Anahtar `yol?query`; query boşsa sondaki `?` atılır.
-  return paths.map((key) => (key.endsWith("?") ? key.slice(0, -1) : key));
+  return paths.map((key) => {
+    const pathname = pathOfCacheKey(key);
+    const q = key.indexOf("?");
+    if (q === -1) return pathname;
+    const query = key.slice(q + 1);
+    return query ? `${pathname}?${query}` : pathname;
+  });
 }
 
 /**

package/src/server/prewarm.js

@@ -24,6 +24,65 @@ import { getDataCacheStats } from "./data-cache.js";
 import { isTransientStatus } from "./upstream-tracking.js";
 import { upstreamCooldownMs } from "./upstream-limiter.js";
 
+/**
+ * `cache().prewarm.origins` yoksa loopback. Port'suz origin'lere dinleme
+ * portu eklenir — `http://tr.localhost` → `http://tr.localhost:3000`.
+ *
+ * @param {number} port
+ * @returns {string[]}
+ */
+function resolvePrewarmOrigins(port) {
+  const configured = getConfig().prewarm?.origins;
+  const list = Array.isArray(configured)
+    ? configured.filter((value) => typeof value === "string" && value)
+    : [];
+
+  if (!list.length) return [`http://127.0.0.1:${port}`];
+
+  return list.map((origin) => {
+    try {
+      const url = new URL(origin);
+      if (!url.port) url.port = String(port);
+      return url.origin;
+    } catch {
+      return origin;
+    }
+  });
+}
+
+/**
+ * Vary açıkken ısıtma isteği ziyaretçinin Host'unu taşısın — aksi halde
+ * loopback anahtarı ısınır, gerçek locale host soğuk kalır.
+ *
+ * @param {{ get?: (name: string) => string | undefined,
+ *   headers?: Record<string, unknown>, protocol?: string } | undefined} req
+ * @param {string} fallback
+ * @returns {string}
+ */
+function originFromRequest(req, fallback) {
+  if (!req) return fallback;
+
+  let vary;
+  try {
+    vary = getConfig().cacheVary;
+  } catch {
+    return fallback;
+  }
+  if (!vary?.host && !vary?.headers?.length && !vary?.fn) return fallback;
+
+  const host =
+    req.get?.("host") ||
+    (typeof req.headers?.host === "string" ? req.headers.host : "");
+  if (!host) return fallback;
+
+  const forwarded = req.headers?.["x-forwarded-proto"];
+  const protoRaw = Array.isArray(forwarded)
+    ? forwarded[0]
+    : forwarded || req.protocol || "http";
+  const proto = String(protoRaw).split(",")[0].trim() || "http";
+  return `${proto}://${host}`;
+}
+
 /** Klasik turu yöneten env'ler; `onVisit` ile birlikte yasak. */
 const CLASSIC_PREWARM_ENV = [
   "PREWARM_MAX",
@@ -715,6 +774,9 @@ export function noteVisitWarm(html, context) {
     /** @type {string | undefined} */ (context.req?.headers?.["user-agent"]);
   if (ua && ua === getConfig().brand.prewarmUserAgent) return;
 
+  // Vary açıksa bu ziyaretin Host'u üzerinden ısıt — loopback anahtarı değil.
+  visitOrigin = originFromRequest(context.req, visitOrigin);
+
   const perPage = Number(getConfig().prewarm?.onVisit?.perPage) || 20;
   const links = extractSameOriginLinks(html, {
     limit: perPage,
@@ -796,12 +858,13 @@ export function startPrewarm({ port }) {
   const config = getConfig();
   if (process.env.PREWARM === "0") return;
 
-  const origin = `http://127.0.0.1:${port}`;
+  const origins = resolvePrewarmOrigins(port);
+  const origin = origins[0];
 
   // Klasik `prewarmPaths` olmasa da TTL öncesi soft-bayatlayan girdiler
   // HTTP ile ısıtılsın. `PREWARM=0` yukarıda her şeyi keser.
   startEarlyExpirySweep();
-  startExpiryWarmDrain(origin);
+  startExpiryWarmDrain(origins);
 
   if (config.prewarm?.onVisit?.enabled) {
     const classicEnv = CLASSIC_PREWARM_ENV.filter((key) => process.env[key]);
@@ -833,7 +896,10 @@ export function startPrewarm({ port }) {
     if (running) return;
     running = true;
     try {
-      await prewarm({ origin });
+      // `vary.host` açıkken her origin ayrı anahtar ısıtır.
+      for (const next of origins) {
+        await prewarm({ origin: next });
+      }
     } catch (error) {
       console.error("[prewarm] failed", error);
     } finally {
@@ -856,8 +922,8 @@ export function startPrewarm({ port }) {
   if (interval > 0) setInterval(() => void run(), interval * 1000).unref();
 }
 
-/** @type {string | null} */
-let expiryOrigin = null;
+/** @type {string[]} */
+let expiryOrigins = [];
 
 /** @type {boolean} */
 let expiryDraining = false;
@@ -869,11 +935,11 @@ let expiryDrainTimer = null;
  * Soft-bayat / invalidate kuyruğunu periyodik boşaltır. Klasik tur ve onVisit
  * aynı kuyruğu da okur; bu drain `prewarmPaths` yokken de çalışır.
  *
- * @param {string} origin
+ * @param {string[]} origins
  * @returns {void}
  */
-function startExpiryWarmDrain(origin) {
-  expiryOrigin = origin;
+function startExpiryWarmDrain(origins) {
+  expiryOrigins = origins.length ? origins : [];
   if (expiryDrainTimer) return;
   expiryDrainTimer = setInterval(() => {
     void drainExpiryWarm();
@@ -885,7 +951,7 @@ function startExpiryWarmDrain(origin) {
  * @returns {Promise<void>}
  */
 async function drainExpiryWarm() {
-  if (expiryDraining || !expiryOrigin) return;
+  if (expiryDraining || !expiryOrigins.length) return;
 
   const paths = takeInvalidatedPaths();
   if (!paths.length) return;
@@ -895,7 +961,9 @@ async function drainExpiryWarm() {
     const cold = paths.filter((path) => !isHtmlCacheFresh(path));
     if (!cold.length) return;
 
-    await prewarm({ origin: expiryOrigin, paths: cold, quiet: true });
+    for (const origin of expiryOrigins) {
+      await prewarm({ origin, paths: cold, quiet: true });
+    }
   } catch (error) {
     console.error("[prewarm] expiry warm failed", error);
   } finally {

package/src/server/render.js

@@ -18,6 +18,7 @@ import fs from "node:fs";
 import { pathToFileURL } from "node:url";
 import ejs from "ejs";
 import { withHtmlCache } from "./html-cache.js";
+import { buildVaryPrefix } from "./cache-vary.js";
 import { getConfig, hook } from "../config/index.js";
 import { matchPattern } from "../config/pattern.js";
 import { encodeText, negotiateEncoding } from "./middleware/compression.js";
@@ -329,12 +330,14 @@ export function route(controller, options = {}) {
     // Anahtar `null` ise query bu yol için cache'lenebilir değil: sayfa
     // dinamik davranır. Anahtar yine de gerekiyor (hata sayfası ölçümü,
     // teşhis) ama TTL sıfırlanıp cache yolu kapatılır.
-    const key = buildCacheKey(req.path, ctx.query);
+    const key = buildCacheKey(req.path, ctx.query, req);
     const cacheable =
       !isPrivate && req.method === "GET" && Boolean(revalidate) && key !== null;
-    const cacheKey = key ?? `${req.path}?${new URLSearchParams(
-      Object.entries(ctx.query).map(([k, v]) => [k, String(v)]),
-    ).toString()}`;
+    const cacheKey =
+      key ??
+      `${buildVaryPrefix(req)}${req.path}?${new URLSearchParams(
+        Object.entries(ctx.query).map(([k, v]) => [k, String(v)]),
+      ).toString()}`;
 
     try {
       const result = await withRequestContext(context, () =>
@@ -582,6 +585,10 @@ function resolveQueryPolicy(pathname) {
 /**
  * HTML cache anahtarı, ya da query bu yol için cache'lenebilir değilse `null`.
  *
+ * Biçim: `${varyPrefix}${pathname}?${izin verilen query}`.
+ * Vary (`cache().vary`) query allowlist'ten bağımsız; host/locale sitelerinde
+ * ilk host'un HTML'inin diğerine servis edilmesini engeller.
+ *
  * Varsayılan olarak query parametresi taşıyan istek dinamiktir: `cache().query`
  * altında eşleşen bir kural olmadıkça cache'e hiç girmez. Aksi hâlde bir yolun
  * bütün `?utm_source=…` varyantları ayrı girdi olur ve LRU'daki gerçek
@@ -592,11 +599,13 @@ function resolveQueryPolicy(pathname) {
  *
  * @param {string} pathname
  * @param {Record<string, unknown>} query
+ * @param {{ headers?: Record<string, unknown>, get?: (name: string) => string | undefined }} [req]
  * @returns {string | null}
  */
-function buildCacheKey(pathname, query) {
+function buildCacheKey(pathname, query, req) {
+  const vary = buildVaryPrefix(req);
   const entries = Object.entries(query);
-  if (!entries.length) return `${pathname}?`;
+  if (!entries.length) return `${vary}${pathname}?`;
 
   const policy = resolveQueryPolicy(pathname);
   if (policy === null) return null;
@@ -612,7 +621,7 @@ function buildCacheKey(pathname, query) {
       .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)),
   );
 
-  return `${pathname}?${params.toString()}`;
+  return `${vary}${pathname}?${params.toString()}`;
 }
 
 /**