jskelet 0.5.1 → 0.5.3

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()}`;
 }
 
 /**

package/src/server/router.js

@@ -14,8 +14,9 @@
  *
  * Modül sözleşmesi: default export ya da `register` adlı named export,
  * `(app, api) => void | Promise<void>` imzasıyla. `api` içinde `route`,
- * `fragment`, `renderView`, `renderPage` ve `notFound`/`redirect` hazır gelir,
- * böylece route dosyaları framework'ten tek tek import yapmak zorunda kalmaz.
+ * `fragment`, `renderView`, `renderPage`, `notFound`/`redirect` ve
+ * `ogHandler` hazır gelir, böylece route dosyaları framework'ten tek tek
+ * import yapmak zorunda kalmaz.
  */
 import fs from "node:fs";
 import path from "node:path";
@@ -29,6 +30,7 @@ import {
   redirect,
   seeOther,
 } from "../http/control-flow.js";
+import { ImageResponse, ogHandler, ogImage, sendOgImage } from "./og-image.js";
 
 const isDev = process.env.NODE_ENV === "development";
 
@@ -96,6 +98,10 @@ const api = {
   redirect,
   permanentRedirect,
   seeOther,
+  ogHandler,
+  ogImage,
+  sendOgImage,
+  ImageResponse,
 };
 
 /**