jskelet 0.1.1 → 0.1.3

package/src/server/data-cache.js

@@ -0,0 +1,244 @@
+/**
+ * Upstream veri için TTL + stale-while-revalidate LRU önbelleği.
+ *
+ * HTML önbelleği (`html-cache.js`) yalnızca **trafiği olan** sayfaları tutar:
+ * girdi başına yüz kilobayt düştüğü için sınırı 500 civarındadır ve on binlerce
+ * yolluk bir site onu ısıtmaya çalıştığında kendi ısıttığını siler. Uzun kuyruk
+ * için doğru katman bu modül: aynı sayfanın JSON'u HTML'inden onlarca kat
+ * küçük olduğu için on binlerce girdi bellekte durur.
+ *
+ * Kazanç iki taraflı:
+ *   - Hiç ısıtılmamış bir uzun kuyruk sayfası ilk ziyaretçide render edilir ama
+ *     upstream'e gitmez; gecikme yüzlerce ms değil, şablon render'ı kadardır.
+ *   - Periyodik ısıtma turları API kotası harcamaz, veri katmanından okur.
+ *
+ * `null`/`undefined` **saklanmaz**: uygulamaların HTTP istemcisi hatada
+ * genellikle `null` döner ve bunu saklamak, geçici bir 429'u TTL boyunca "veri
+ * yok" hâline dondurmak olurdu. Boş cevabı bilinçli olarak saklamak isteyen
+ * `storeEmpty: true` verir.
+ */
+import { getConfig } from "../config/index.js";
+import { DEFAULT_DATA_CACHE } from "../config/defaults.js";
+
+/**
+ * @typedef {{ value: unknown, expiresAt: number, staleUntil: number }} DataEntry
+ */
+
+/** @type {Map<string, DataEntry>} */
+const store = new Map();
+
+/** @type {Map<string, Promise<unknown>>} */
+const inflight = new Map();
+
+/**
+ * Ayarlar config'ten okunur ama config yüklenmemiş olabilir: bu modül
+ * script'lerden ve testlerden de çağrılabiliyor. `getConfig()` fırlatırsa
+ * kod varsayılanına düşülür.
+ *
+ * @returns {{ maxEntries: number, staleFactor: number }}
+ */
+function settings() {
+  try {
+    const { data } = getConfig();
+    return {
+      maxEntries: Number(data?.maxEntries) || DEFAULT_DATA_CACHE.maxEntries,
+      staleFactor: Number.isFinite(Number(data?.staleFactor))
+        ? Number(data.staleFactor)
+        : DEFAULT_DATA_CACHE.staleFactor,
+    };
+  } catch {
+    return { ...DEFAULT_DATA_CACHE };
+  }
+}
+
+/**
+ * @param {string} key
+ * @returns {{ value: unknown, stale: boolean } | null}
+ */
+function read(key) {
+  const entry = store.get(key);
+  if (!entry) return null;
+
+  const now = Date.now();
+  if (now >= entry.staleUntil) {
+    store.delete(key);
+    return null;
+  }
+
+  // LRU: erişilen girdiyi sona taşı.
+  store.delete(key);
+  store.set(key, entry);
+
+  return { value: entry.value, stale: now >= entry.expiresAt };
+}
+
+/**
+ * @param {string} key
+ * @param {unknown} value
+ * @param {number} ttlSeconds
+ * @param {number} staleFactor
+ */
+function write(key, value, ttlSeconds, staleFactor) {
+  const now = Date.now();
+  const ttl = ttlSeconds * 1000;
+
+  store.set(key, {
+    value,
+    expiresAt: now + ttl,
+    staleUntil: now + ttl + ttl * staleFactor,
+  });
+
+  const { maxEntries } = settings();
+  while (store.size > maxEntries) {
+    const oldest = store.keys().next().value;
+    if (oldest === undefined) break;
+    store.delete(oldest);
+  }
+}
+
+/**
+ * @param {string} key
+ * @param {number} ttlSeconds
+ * @param {() => Promise<unknown>} producer
+ * @param {{ storeEmpty?: boolean, staleFactor?: number }} options
+ * @returns {Promise<unknown>}
+ */
+function refresh(key, ttlSeconds, producer, options) {
+  // Aynı anahtarı eşzamanlı isteyen yüz sayfa tek upstream isteğine düşer.
+  // Isıtma turlarında bu tek başına kotanın büyük kısmını kurtarıyor.
+  const pending = inflight.get(key);
+  if (pending) return pending;
+
+  const staleFactor = options.staleFactor ?? settings().staleFactor;
+
+  const task = Promise.resolve()
+    .then(producer)
+    .then((value) => {
+      const empty = value === undefined || value === null;
+      if (!empty || options.storeEmpty === true) {
+        write(key, value, ttlSeconds, staleFactor);
+      }
+      return value;
+    })
+    .finally(() => {
+      inflight.delete(key);
+    });
+
+  inflight.set(key, task);
+  return task;
+}
+
+/**
+ * Veriyi önbellekten döner, gerekiyorsa `producer` ile üretir.
+ *
+ * @param {string} key Anahtar tamamen uygulamanın; sürüm/dil gibi ayrımlar
+ *   anahtara yazılır (`quote:v2:${symbol}`).
+ * @param {number} ttlSeconds 0 → önbellek yok, `producer` her çağrıda çalışır.
+ * @param {() => Promise<T>} producer
+ * @param {{ storeEmpty?: boolean, staleFactor?: number }} [options]
+ *   `storeEmpty` boş cevabı da saklar, `staleFactor` bu anahtar için bayat
+ *   penceresini ayarlar (0 → bayat servis yok).
+ * @returns {Promise<T>}
+ * @template T
+ */
+export async function withDataCache(key, ttlSeconds, producer, options = {}) {
+  if (!ttlSeconds) return producer();
+
+  const hit = read(key);
+
+  if (hit) {
+    // Bayat girdi anında döner; tazeleme arkada yürür ve hatası bu isteği
+    // etkilemez — çağıran taraf bir şey beklemediği için upstream'in yavaş
+    // olması sayfaya yansımaz.
+    if (hit.stale) {
+      void refresh(key, ttlSeconds, producer, options).catch((error) => {
+        console.error(`[data-cache] background refresh failed: ${key}`, error);
+      });
+    }
+    return /** @type {T} */ (hit.value);
+  }
+
+  try {
+    return /** @type {T} */ (await refresh(key, ttlSeconds, producer, options));
+  } catch (error) {
+    // Girdi yoksa hata çağırana gider; asıl kazanç bayat girdinin olduğu
+    // durumda: upstream düşmüşken sayfayı eski veriyle ayakta tutmak,
+    // ziyaretçiye hata sayfası göstermekten iyidir.
+    const stale = read(key);
+    if (!stale) throw error;
+
+    console.warn(
+      `[data-cache] producer failed, serving stale value: ${key}`,
+      error instanceof Error ? error.message : error,
+    );
+    return /** @type {T} */ (stale.value);
+  }
+}
+
+/**
+ * `withDataCache`'in fonksiyon sarmalayıcısı: argümanlardan anahtar üretir.
+ * `cache()` (istek içi memoizasyon) ile aynı kullanım biçimi, ama istekler
+ * arasında ve TTL'li.
+ *
+ * @param {F} fn
+ * @param {{ key: string, revalidate: number, storeEmpty?: boolean,
+ *   staleFactor?: number }} options `key` önektir; argümanlar sonuna eklenir.
+ * @returns {F}
+ * @template {(...args: any[]) => Promise<any>} F
+ */
+export function dataCache(fn, options) {
+  const wrapped = (...args) =>
+    withDataCache(
+      args.length ? `${options.key}:${JSON.stringify(args)}` : options.key,
+      options.revalidate,
+      () => fn(...args),
+      options,
+    );
+
+  return /** @type {F} */ (wrapped);
+}
+
+/**
+ * Bir anahtarı ya da önek eşleşen tüm anahtarları düşürür. Webhook ile
+ * "bu haber güncellendi" bilgisi geldiğinde kullanılır.
+ *
+ * @param {string} [prefix] Verilmezse tüm önbellek boşaltılır.
+ * @returns {number} Silinen girdi sayısı.
+ */
+export function clearDataCache(prefix) {
+  if (prefix === undefined) {
+    const size = store.size;
+    store.clear();
+    return size;
+  }
+
+  let removed = 0;
+  for (const key of store.keys()) {
+    if (key.startsWith(prefix)) {
+      store.delete(key);
+      removed += 1;
+    }
+  }
+  return removed;
+}
+
+/** @returns {number} */
+export function getDataCacheSize() {
+  return store.size;
+}
+
+/**
+ * Dev raporu ve yönetim uçları için döküm. Değerin kendisi dönmez: JSON'un
+ * tamamını bir teşhis ucundan dışa vermek istenmez.
+ *
+ * @returns {{ key: string, stale: boolean, expiresIn: number }[]}
+ */
+export function getDataCacheEntries() {
+  const now = Date.now();
+
+  return [...store.entries()].map(([key, entry]) => ({
+    key,
+    stale: now >= entry.expiresAt,
+    expiresIn: Math.round((entry.expiresAt - now) / 1000),
+  }));
+}

package/src/server/dev/devtools.js

@@ -21,6 +21,7 @@ import {
   recordPageReport,
   trackServerFetch,
 } from "./report.js";
+import { startVersionCheck, versionStatus } from "./version-check.mjs";
 
 /** Overlay dosyaları framework paketinden servis edilir, uygulamadan değil. */
 const DEVTOOLS_DIR = path.join(FRAMEWORK_ROOT, "src", "client", "devtools");
@@ -267,7 +268,8 @@ function router() {
 
   api.get("/logo.png", (req, res) => {
     res.type("image/png");
-    res.setHeader("Cache-Control", "no-store");
+    // Logo geliştirme sırasında değişmiyor; her gezinmede yeniden indirmesin.
+    res.setHeader("Cache-Control", "public, max-age=86400");
     fs.createReadStream(LOGO_FILE).pipe(res);
   });
 
@@ -293,6 +295,7 @@ function router() {
       boot: BOOT_ID,
       uptime: process.uptime(),
       node: process.version,
+      version: versionStatus(),
       memory: { rss: usage.rss, heapUsed: usage.heapUsed },
       prewarm: { ...prewarmProgress },
       requests: requests.slice(-25).reverse(),
@@ -351,7 +354,7 @@ function router() {
       origin: `${req.protocol}://${req.get("host")}`,
       paths: paths.length ? paths : undefined,
     }).catch((error) => {
-      console.error("[prewarm] elle tetikleme başarısız", error);
+      console.error("[prewarm] manual trigger failed", error);
     });
 
     res.json({ ok: true, scope: paths.length || "all" });
@@ -378,6 +381,7 @@ export function mountDevtools(app) {
   patchConsole();
   trackServerFetch();
   watchManifest();
+  startVersionCheck();
   app.use(timing());
   app.use(brand.devBasePath, router());
 }

package/src/server/dev/report.js

@@ -13,6 +13,7 @@ import fs from "node:fs";
 import path from "node:path";
 import zlib from "node:zlib";
 import { getHtmlCacheEntries, getHtmlCacheSize } from "../html-cache.js";
+import { getDataCacheSize } from "../data-cache.js";
 import { prewarmProgress } from "../prewarm.js";
 import { getConfig } from "../../config/index.js";
 
@@ -343,7 +344,13 @@ export function buildReport(devtools) {
     pages: pageList.sort((a, b) => (b.visits - a.visits) || b.at - a.at),
     serverApi: serverApiCalls.slice().reverse(),
     build: { assets: assets(), ...chunks() },
-    cache: { size: getHtmlCacheSize(), entries: getHtmlCacheEntries() },
+    cache: {
+      size: getHtmlCacheSize(),
+      entries: getHtmlCacheEntries(),
+      // Veri önbelleğinden yalnızca sayaç: uzun kuyruklu bir sitede on
+      // binlerce anahtar oluyor ve dökümü rapora koymak faydasız bir yük.
+      data: getDataCacheSize(),
+    },
     prewarm: { ...prewarmProgress },
     requests: devtools.requests,
     errors: devtools.errors,

package/src/server/dev/version-check.mjs

@@ -0,0 +1,139 @@
+/**
+ * npm kayıt defterindeki son sürümü yoklar ve dev overlay'e "outdated" bilgisi
+ * verir. Yalnızca geliştirme sırasında çalışır.
+ *
+ * Sonuç geçici dizinde saklanıyor: `node --watch` sunucuyu sık yeniden
+ * başlatıyor ve her açılışta ağa çıkmak hem yavaş hem gereksiz. Kayıt defteri
+ * ulaşılamazsa sessizce eski/boş sonuç kullanılır — sürüm kontrolü hiçbir
+ * koşulda dev akışını bekletmez ya da hata basmaz.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { FRAMEWORK_PACKAGE, FRAMEWORK_VERSION } from "../../version.mjs";
+
+const CACHE_FILE = path.join(os.tmpdir(), `jskelet-version-${FRAMEWORK_PACKAGE}.json`);
+
+/** Aynı sürümü saatte birden fazla sormanın anlamı yok. */
+const TTL = 6 * 60 * 60 * 1000;
+
+const TIMEOUT = 3000;
+
+/** @type {{ current: string, latest: string | null, outdated: boolean, checkedAt: number | null }} */
+let state = {
+  current: FRAMEWORK_VERSION,
+  latest: null,
+  outdated: false,
+  checkedAt: null,
+};
+
+/**
+ * Ön sürüm etiketleri (`1.2.0-beta.1`) karşılaştırmada yok sayılır: kayıt
+ * defterinden yalnızca `latest` etiketi okunduğu için pratikte gelmiyor.
+ * @param {string} a
+ * @param {string} b
+ * @returns {number} a > b ise pozitif
+ */
+function compare(a, b) {
+  const parse = (value) =>
+    String(value)
+      .split("-")[0]
+      .split(".")
+      .map((part) => Number.parseInt(part, 10) || 0);
+
+  const left = parse(a);
+  const right = parse(b);
+
+  for (let index = 0; index < 3; index += 1) {
+    const diff = (left[index] ?? 0) - (right[index] ?? 0);
+    if (diff) return diff;
+  }
+
+  return 0;
+}
+
+/**
+ * @param {string | null} latest
+ */
+function apply(latest) {
+  state = {
+    current: FRAMEWORK_VERSION,
+    latest,
+    outdated: Boolean(latest) && compare(latest, FRAMEWORK_VERSION) > 0,
+    checkedAt: Date.now(),
+  };
+}
+
+/** @returns {{ latest: string, checkedAt: number } | null} */
+function readCache() {
+  try {
+    const saved = JSON.parse(fs.readFileSync(CACHE_FILE, "utf8"));
+    if (typeof saved.latest !== "string" || typeof saved.checkedAt !== "number") return null;
+    return saved;
+  } catch {
+    return null;
+  }
+}
+
+async function fetchLatest() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), TIMEOUT);
+
+  try {
+    const response = await fetch(
+      `https://registry.npmjs.org/${encodeURIComponent(FRAMEWORK_PACKAGE)}/latest`,
+      {
+        signal: controller.signal,
+        headers: { accept: "application/vnd.npm.install-v1+json, application/json" },
+      },
+    );
+
+    if (!response.ok) return;
+
+    const body = await response.json();
+    if (typeof body?.version !== "string") return;
+
+    apply(body.version);
+    try {
+      fs.writeFileSync(
+        CACHE_FILE,
+        JSON.stringify({ latest: body.version, checkedAt: state.checkedAt }),
+      );
+    } catch {
+      // Önbellek yazılamazsa yalnızca her açılışta yeniden sorulur.
+    }
+  } catch {
+    // Ağ yok, kayıt defteri kapalı ya da zaman aşımı: sürüm bilgisi boş kalır.
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Kontrolü başlatır. Beklenmez; sonuç geldiğinde `versionStatus()` günceldir.
+ * `JSKELET_VERSION_CHECK=0` ile tamamen kapatılabilir (çevrimdışı çalışma,
+ * kurumsal ağlar).
+ */
+export function startVersionCheck() {
+  if (process.env.JSKELET_VERSION_CHECK === "0") return;
+
+  const cached = readCache();
+  if (cached) {
+    apply(cached.latest);
+    state.checkedAt = cached.checkedAt;
+    if (Date.now() - cached.checkedAt < TTL) return;
+  }
+
+  // Açılışta ağ isteği ilk isteğin önüne geçmesin.
+  const timer = setTimeout(() => {
+    fetchLatest();
+  }, 1500);
+  timer.unref?.();
+}
+
+/**
+ * @returns {{ current: string, latest: string | null, outdated: boolean, checkedAt: number | null }}
+ */
+export function versionStatus() {
+  return state;
+}

package/src/server/head-hints.js

@@ -29,7 +29,7 @@ export function preconnectHints() {
       try {
         return `<link rel="preconnect" href="${esc(new URL(origin).origin)}">`;
       } catch {
-        console.warn(`[head] preconnect geçersiz URL, atlandı: ${origin}`);
+        console.warn(`[head] invalid preconnect URL, skipped: ${origin}`);
         return "";
       }
     })

package/src/server/html-cache.js

@@ -8,12 +8,31 @@
  * WebSocket'ten güncellendiği için bu gecikme ekranda görünmez.
  */
 
+import { getConfig } from "../config/index.js";
+import { DEFAULT_HTML_CACHE_MAX_ENTRIES } from "../config/defaults.js";
+
 /**
  * @typedef {{ html: string, status: number, expiresAt: number,
  *   staleUntil: number, encoded: Map<string, Buffer> }} HtmlEntry
  */
 
-const MAX_ENTRIES = 500;
+/**
+ * Girdi sınırı `cache().maxEntries` ile yükseltilebilir ama uzun kuyruklu bir
+ * siteyi buradan çözmeye çalışmak yanlış katman: girdi başına yüz kilobayt
+ * düşüyor. On binlerce yol için `withDataCache` kullanılır.
+ *
+ * Config yüklenmemiş olabilir (testler bu modülü doğrudan çağırıyor); o
+ * durumda kod varsayılanı geçerli.
+ *
+ * @returns {number}
+ */
+function maxEntries() {
+  try {
+    return getConfig().htmlMaxEntries;
+  } catch {
+    return DEFAULT_HTML_CACHE_MAX_ENTRIES;
+  }
+}
 
 /**
  * TTL dolduktan sonra eski HTML'in kaç TTL boyunca daha servis edilebileceği.
@@ -73,7 +92,8 @@ function write(key, value, ttlSeconds) {
     staleUntil: now + ttlSeconds * 1000 * (1 + STALE_FACTOR),
   });
 
-  while (store.size > MAX_ENTRIES) {
+  const limit = maxEntries();
+  while (store.size > limit) {
     const oldest = store.keys().next().value;
     if (oldest === undefined) break;
     store.delete(oldest);
@@ -83,8 +103,10 @@ function write(key, value, ttlSeconds) {
 /**
  * @param {string} key
  * @param {number} ttlSeconds
- * @param {() => Promise<{ html: string, status: number, degraded?: boolean }>} producer
- * @returns {Promise<{ html: string, status: number, degraded?: boolean }>}
+ * @param {() => Promise<{ html: string, status: number, degraded?: boolean,
+ *   storable?: boolean }>} producer
+ * @returns {Promise<{ html: string, status: number, degraded?: boolean,
+ *   storable?: boolean }>}
  */
 function refresh(key, ttlSeconds, producer) {
   const pending = inflight.get(key);
@@ -94,7 +116,11 @@ function refresh(key, ttlSeconds, producer) {
     .then((value) => {
       // `degraded`: upstream düştüğü için eksik veriyle üretilmiş HTML.
       // Saklanırsa eksik içerik tüm TTL boyunca servis edilir.
-      if (value.status === 200 && !value.degraded) {
+      //
+      // `storable: false`: çıktı kullanıcıya bağlı (cookie/Authorization
+      // okundu). Anahtar yalnızca yol + query olduğu için saklamak, bir
+      // kullanıcının HTML'ini bir başkasına servis etmek olur.
+      if (value.status === 200 && !value.degraded && value.storable !== false) {
         write(key, value, ttlSeconds);
       }
       return value;
@@ -127,7 +153,7 @@ export async function withHtmlCache(key, ttlSeconds, producer) {
     // isteği etkilemez (eski HTML stale penceresi boyunca geçerli kalır).
     if (hit.stale) {
       void refresh(key, ttlSeconds, producer).catch((error) => {
-        console.error(`[html-cache] arka plan tazelemesi başarısız: ${key}`, error);
+        console.error(`[html-cache] background refresh failed: ${key}`, error);
       });
     }
     return { ...hit, cached: true };

package/src/server/middleware/csrf.js

@@ -0,0 +1,134 @@
+/**
+ * CSRF koruması.
+ *
+ * Bu yüzey framework'e ait, çünkü gövdeyi ayrıştıran o: `create-app.js`
+ * `express.urlencoded` ve `express.json` kuruyor, yani state değiştiren
+ * istekleri kabul eden katman framework. Cookie ile kimlik doğrulayan bir
+ * uygulama bu koruma olmadan açık.
+ *
+ * İki katman:
+ *
+ * 1. **Origin kontrolü** (varsayılan açık). `Origin` ya da
+ *    `Sec-Fetch-Site` başlığı çapraz site olduğunu gösteriyorsa istek
+ *    reddedilir. Başlıkların **hiçbiri yoksa geçer**: tarayıcılar çapraz
+ *    origin bir POST'ta `Origin`'i her zaman gönderir, buna karşılık
+ *    webhook'lar ve sunucudan sunucuya çağrılar hiç göndermez. Bu ayrım,
+ *    korumayı açık bırakırken entegrasyonları bozmamayı sağlıyor.
+ *
+ * 2. **Çift gönderim token'ı** (`security.csrf.token` ile açılır). Cookie'deki
+ *    imzalı token ile form alanı/başlıktaki değer karşılaştırılır. `Origin`
+ *    göndermeyen eski tarayıcılar için ikinci katman; formlara `csrfField()`
+ *    eklenmesini gerektirdiği için varsayılan kapalı.
+ *
+ * Token'ı bu middleware **üretmez**, yalnızca doğrular. Üretim `csrfField()`
+ * içinde, yani gerçekten bir forma basıldığı anda olur. Sebebi somut: token
+ * her yanıtta yazılsaydı public ve cache'lenebilir bir sayfa da `Set-Cookie`
+ * taşırdı, bir CDN o yanıtı saklardı ve tüm ziyaretçiler aynı token'ı
+ * paylaşırdı — çift gönderim kontrolü tam olarak o noktada anlamını yitirir.
+ */
+import { getConfig } from "../../config/index.js";
+import { matchPattern } from "../../config/pattern.js";
+import { getSignedCookie, safeEqual } from "../../http/cookies.js";
+
+/** Gövdesi olmayan, yan etkisi beklenmeyen metotlar. */
+const SAFE_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
+
+/**
+ * İsteğin geldiği origin'in kendi origin'imiz olup olmadığını söyler.
+ *
+ * `trust proxy` kapalıysa `req.protocol` her zaman `http` döner ve HTTPS
+ * arkasında her istek çapraz site sanılır; bu yüzden karşılaştırma yalnızca
+ * host üzerinden yapılır, protokol değil.
+ *
+ * @param {import('express').Request} req
+ * @param {string[]} allowedOrigins
+ * @returns {boolean}
+ */
+function isSameOrigin(req, allowedOrigins) {
+  const origin = req.headers.origin;
+  if (!origin || origin === "null") return false;
+
+  if (allowedOrigins.includes(origin)) return true;
+
+  try {
+    const host = req.headers.host;
+    return Boolean(host) && new URL(origin).host === host;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @returns {import('express').RequestHandler}
+ */
+export function csrf() {
+  const { security } = getConfig();
+  const { csrf: options } = security;
+
+  return (req, res, next) => {
+    if (!options.enabled) {
+      next();
+      return;
+    }
+
+    const pathname = req.path ?? "";
+    if (options.exclude.some((pattern) => matchPattern(pattern, pathname))) {
+      next();
+      return;
+    }
+
+    if (SAFE_METHODS.has(req.method)) {
+      next();
+      return;
+    }
+
+    const site = String(req.headers["sec-fetch-site"] ?? "");
+    const hasOrigin = Boolean(req.headers.origin);
+
+    // Yalnızca çapraz site olduğu **belli** olan istekler reddedilir.
+    if (site === "cross-site" || (hasOrigin && !isSameOrigin(req, options.allowedOrigins))) {
+      reject(req, res, "origin mismatch");
+      return;
+    }
+
+    if (options.token) {
+      // Cookie yoksa istek zaten token basan bir formdan gelmiyor.
+      const expected = getSignedCookie(req, options.cookieName);
+      const provided =
+        firstString(/** @type {any} */ (req.body)?.[options.fieldName]) ??
+        firstString(req.headers[options.headerName]);
+
+      if (!expected || !provided || !safeEqual(provided, expected)) {
+        reject(req, res, "token mismatch");
+        return;
+      }
+    }
+
+    next();
+  };
+}
+
+/**
+ * @param {unknown} value
+ * @returns {string | null}
+ */
+function firstString(value) {
+  if (typeof value === "string" && value) return value;
+  if (Array.isArray(value)) return firstString(value[0]);
+  return null;
+}
+
+/**
+ * Reddedilen istek HTML sayfası değil düz metin döner: bu bir kullanıcı
+ * hatası değil, ya bir saldırı ya da bir programlama hatası — ve fragment
+ * takasında bir hata sayfasının içine düşmemeli.
+ *
+ * @param {import('express').Request} req
+ * @param {import('express').Response} res
+ * @param {string} reason
+ */
+function reject(req, res, reason) {
+  console.warn(`[csrf] ${req.method} ${req.originalUrl} rejected — ${reason}`);
+  res.status(403).setHeader("Cache-Control", "no-store");
+  res.type("text/plain").send("Forbidden");
+}