what-isr 0.10.0

package/dist/index.js

@@ -0,0 +1,653 @@
+// packages/cache/src/key.js
+import { createHash } from "node:crypto";
+var STRIP_EXACT = /* @__PURE__ */ new Set(["fbclid", "gclid", "_", "mc_cid", "mc_eid"]);
+var STRIP_PREFIXES = ["utm_"];
+function shouldStrip(name) {
+  if (STRIP_EXACT.has(name)) return true;
+  for (const p of STRIP_PREFIXES) if (name.startsWith(p)) return true;
+  return false;
+}
+function normalizePath(path) {
+  if (!path) return "/";
+  let p = String(path).split("?")[0].split("#")[0];
+  if (p.length > 1 && p.endsWith("/")) p = p.slice(0, -1);
+  return p || "/";
+}
+function queryToEntries(query) {
+  if (!query) return [];
+  if (typeof query === "string") {
+    const s = query.startsWith("?") ? query.slice(1) : query;
+    if (!s) return [];
+    return [...new URLSearchParams(s).entries()];
+  }
+  const out = [];
+  for (const [k, v] of Object.entries(query)) {
+    if (Array.isArray(v)) for (const item of v) out.push([k, String(item)]);
+    else out.push([k, String(v)]);
+  }
+  return out;
+}
+function normalizeQuery(query) {
+  const entries = queryToEntries(query).filter(([k]) => !shouldStrip(k)).sort((a, b) => a[0] === b[0] ? a[1] < b[1] ? -1 : 1 : a[0] < b[0] ? -1 : 1);
+  return entries.map(([k, v]) => `${k}=${v}`).join("&");
+}
+function varyString(vary) {
+  if (!vary) return "";
+  return Object.entries(vary).sort((a, b) => a[0] < b[0] ? -1 : 1).map(([k, v]) => `${k}=${v}`).join("&");
+}
+function cacheKey({ path, query, vary } = {}) {
+  return [normalizePath(path), normalizeQuery(query), varyString(vary)].join("\0");
+}
+function hashKey(key) {
+  const hex = createHash("sha256").update(key).digest("hex");
+  return `${hex.slice(0, 2)}/${hex.slice(2, 4)}/${hex.slice(4)}`;
+}
+
+// packages/cache/src/stores/store-interface.js
+function makeEntry(out, config = {}, now = Date.now()) {
+  const maxAge = Number(config.revalidate) || 0;
+  const swrWindow = config.swr != null ? Number(config.swr) : maxAge;
+  return {
+    html: out.html || "",
+    head: out.head || "",
+    state: out.state ?? null,
+    tags: out.tags || config.tags || [],
+    path: out.path || config.path,
+    status: out.status || 200,
+    partial: !!out.partial,
+    renderedAt: now,
+    maxAge,
+    swrWindow,
+    expiresAt: maxAge > 0 ? now + maxAge * 1e3 : Infinity
+  };
+}
+function isFresh(entry, now = Date.now()) {
+  return entry.expiresAt === Infinity || now < entry.expiresAt;
+}
+function isServableStale(entry, now = Date.now()) {
+  if (isFresh(entry, now)) return true;
+  if (entry.swrWindow == null) return false;
+  return now < entry.expiresAt + entry.swrWindow * 1e3;
+}
+
+// packages/cache/src/headers.js
+function buildCacheHeaders(entry = {}, config = {}, cacheStatus = "MISS") {
+  const headers = { "X-What-Cache": cacheStatus };
+  const cacheable = (entry.maxAge > 0 || config.mode === "static" || config.mode === "hybrid") && config.mode !== "server";
+  if (!cacheable) {
+    headers["Cache-Control"] = "private, no-store";
+    return headers;
+  }
+  const sMaxAge = entry.partial ? 0 : entry.maxAge || 0;
+  const swr = entry.swrWindow != null ? entry.swrWindow : sMaxAge;
+  headers["Cache-Control"] = `public, s-maxage=${sMaxAge}, stale-while-revalidate=${swr}`;
+  if (entry.tags && entry.tags.length) {
+    headers["Cache-Tag"] = entry.tags.join(",");
+    headers["Surrogate-Key"] = entry.tags.join(" ");
+  }
+  return headers;
+}
+
+// packages/cache/src/isr.js
+function createCacheEngine({ store, render, cdn, now = Date.now, logger = console } = {}) {
+  const inFlight = /* @__PURE__ */ new Map();
+  function keyFor(routeMatch) {
+    return cacheKey({ path: routeMatch.path, query: routeMatch.query, vary: routeMatch.vary });
+  }
+  function regenerate(key, routeMatch, renderOverride) {
+    const existing = inFlight.get(key);
+    if (existing) return existing;
+    const doRender = renderOverride || render;
+    const p = (async () => {
+      const out = await doRender(routeMatch, {});
+      const entry = makeEntry({ ...out, path: routeMatch.path }, routeMatch.config || {}, now());
+      await store.set(key, entry);
+      return entry;
+    })().finally(() => inFlight.delete(key));
+    inFlight.set(key, p);
+    return p;
+  }
+  function serve(entry, cacheStatus, config) {
+    return {
+      html: entry.html,
+      head: entry.head,
+      state: entry.state,
+      status: entry.status || 200,
+      cacheStatus,
+      headers: buildCacheHeaders(entry, config || {}, cacheStatus)
+    };
+  }
+  async function handle(routeMatch, renderOverride) {
+    const config = routeMatch.config || {};
+    if (config.mode === "server") {
+      const out = await (renderOverride || render)(routeMatch, {});
+      const entry2 = makeEntry({ ...out, path: routeMatch.path }, config, now());
+      return serve(entry2, "BYPASS", config);
+    }
+    const key = keyFor(routeMatch);
+    const entry = await store.get(key);
+    const t = now();
+    if (entry && isFresh(entry, t)) {
+      return serve(entry, "HIT", config);
+    }
+    if (entry && isServableStale(entry, t)) {
+      regenerate(key, routeMatch, renderOverride).catch((e) => logger.error?.("[what-isr] background regenerate failed:", e));
+      return serve(entry, "STALE", config);
+    }
+    if (entry && config.onMiss === "stale-if-error") {
+      try {
+        const fresh2 = await regenerate(key, routeMatch, renderOverride);
+        return serve(fresh2, "MISS", config);
+      } catch (e) {
+        logger.error?.("[what-isr] regenerate failed, serving stale:", e);
+        return serve(entry, "STALE", config);
+      }
+    }
+    const fresh = await regenerate(key, routeMatch, renderOverride);
+    return serve(fresh, "MISS", config);
+  }
+  async function revalidatePath(path, { regenerate: regen = false, routeResolver } = {}) {
+    const norm = normalizePath(path);
+    const deleted = await store.deleteByPath(norm);
+    if (cdn && cdn.purge) await cdn.purge([path]);
+    if (regen) {
+      const route = routeResolver ? routeResolver(norm) : { path: norm, query: {}, config: {} };
+      await regenerate(keyFor(route), route).catch((e) => logger.error?.("[what-isr] regen after revalidatePath failed:", e));
+    }
+    return deleted;
+  }
+  async function revalidateTag(tag, { regenerate: regen = false, routeResolver } = {}) {
+    const deleted = await store.deleteByTag(tag);
+    if (cdn && cdn.purgeTags) await cdn.purgeTags([tag]);
+    if (regen && routeResolver) {
+      for (const key of deleted) {
+        const route = routeResolver(key);
+        if (route) await regenerate(keyFor(route), route).catch(() => {
+        });
+      }
+    }
+    return deleted;
+  }
+  return {
+    handle,
+    regenerate: (routeMatch) => regenerate(keyFor(routeMatch), routeMatch),
+    revalidatePath,
+    revalidateTag,
+    keyFor,
+    store,
+    _inFlight: inFlight,
+    _now: now,
+    _cdn: cdn
+  };
+}
+
+// packages/cache/src/stores/memory-store.js
+function createMemoryStore({ maxEntries = 1e3 } = {}) {
+  const map = /* @__PURE__ */ new Map();
+  const tagIndex = /* @__PURE__ */ new Map();
+  const pathIndex = /* @__PURE__ */ new Map();
+  function addToIndex(index, name, key) {
+    if (name == null) return;
+    let set = index.get(name);
+    if (!set) index.set(name, set = /* @__PURE__ */ new Set());
+    set.add(key);
+  }
+  function removeFromIndex(index, name, key) {
+    if (name == null) return;
+    const set = index.get(name);
+    if (set) {
+      set.delete(key);
+      if (set.size === 0) index.delete(name);
+    }
+  }
+  function indexEntry(key, entry) {
+    if (entry.tags) for (const t of entry.tags) addToIndex(tagIndex, t, key);
+    addToIndex(pathIndex, entry.path, key);
+  }
+  function deindexEntry(key, entry) {
+    if (entry.tags) for (const t of entry.tags) removeFromIndex(tagIndex, t, key);
+    removeFromIndex(pathIndex, entry.path, key);
+  }
+  function removeKey(key) {
+    const e = map.get(key);
+    if (!e) return false;
+    map.delete(key);
+    deindexEntry(key, e);
+    return true;
+  }
+  function deleteByIndex(index, name) {
+    const set = index.get(name);
+    if (!set) return [];
+    const deleted = [...set];
+    for (const k of deleted) removeKey(k);
+    return deleted;
+  }
+  return {
+    async get(key) {
+      const e = map.get(key);
+      if (!e) return null;
+      map.delete(key);
+      map.set(key, e);
+      return e;
+    },
+    async set(key, entry) {
+      if (map.has(key)) deindexEntry(key, map.get(key));
+      map.set(key, entry);
+      indexEntry(key, entry);
+      while (map.size > maxEntries) {
+        const oldest = map.keys().next().value;
+        removeKey(oldest);
+      }
+    },
+    async delete(key) {
+      return removeKey(key);
+    },
+    async deleteByTag(tag) {
+      return deleteByIndex(tagIndex, tag);
+    },
+    async deleteByPath(path) {
+      return deleteByIndex(pathIndex, path);
+    },
+    async clear() {
+      map.clear();
+      tagIndex.clear();
+      pathIndex.clear();
+    },
+    async keys() {
+      return [...map.keys()];
+    }
+  };
+}
+
+// packages/cache/src/stores/filesystem-store.js
+import { mkdir, writeFile, readFile, rename, rm, readdir, stat } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+function safeName(s) {
+  return createHash2("sha256").update(String(s)).digest("hex");
+}
+function createFilesystemStore({ dir }) {
+  const entriesDir = join(dir, "entries");
+  const tagsDir = join(dir, "tags");
+  const pathsDir = join(dir, "paths");
+  const entryFile = (key) => join(entriesDir, hashKey(key) + ".json");
+  const indexFile = (base, name) => join(base, safeName(name) + ".json");
+  async function atomicWrite(file, contents) {
+    await mkdir(dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.${safeName(file).slice(0, 8)}.tmp`;
+    await writeFile(tmp, contents);
+    await rename(tmp, file);
+  }
+  async function readJson(file) {
+    try {
+      return JSON.parse(await readFile(file, "utf8"));
+    } catch {
+      return null;
+    }
+  }
+  async function addToIndex(base, name, key) {
+    const file = indexFile(base, name);
+    const list = await readJson(file) || [];
+    if (!list.includes(key)) {
+      list.push(key);
+      await atomicWrite(file, JSON.stringify(list));
+    }
+  }
+  async function removeFromIndex(base, name, key) {
+    const file = indexFile(base, name);
+    const list = await readJson(file);
+    if (!list) return;
+    const next = list.filter((k) => k !== key);
+    if (next.length) await atomicWrite(file, JSON.stringify(next));
+    else await rm(file, { force: true });
+  }
+  async function deleteByIndex(base, name) {
+    const file = indexFile(base, name);
+    const keys = await readJson(file);
+    if (!keys) return [];
+    for (const k of keys) await removeKey(k);
+    await rm(file, { force: true });
+    return keys;
+  }
+  async function removeKey(key) {
+    const record = await readJson(entryFile(key));
+    if (!record) return false;
+    await rm(entryFile(key), { force: true });
+    const entry = record.entry || {};
+    for (const t of entry.tags || []) await removeFromIndex(tagsDir, t, key);
+    if (entry.path) await removeFromIndex(pathsDir, entry.path, key);
+    return true;
+  }
+  async function walkKeys() {
+    const out = [];
+    let shards;
+    try {
+      shards = await readdir(entriesDir);
+    } catch {
+      return out;
+    }
+    for (const a of shards) {
+      const aDir = join(entriesDir, a);
+      let st;
+      try {
+        st = await stat(aDir);
+      } catch {
+        continue;
+      }
+      if (!st.isDirectory()) continue;
+      for (const b of await readdir(aDir)) {
+        const bDir = join(aDir, b);
+        try {
+          if (!(await stat(bDir)).isDirectory()) continue;
+        } catch {
+          continue;
+        }
+        for (const f of await readdir(bDir)) {
+          if (!f.endsWith(".json")) continue;
+          const rec = await readJson(join(bDir, f));
+          if (rec && rec.key != null) out.push(rec.key);
+        }
+      }
+    }
+    return out;
+  }
+  return {
+    async get(key) {
+      const rec = await readJson(entryFile(key));
+      return rec ? rec.entry : null;
+    },
+    async set(key, entry) {
+      const prev = await readJson(entryFile(key));
+      if (prev && prev.entry) {
+        for (const t of prev.entry.tags || []) await removeFromIndex(tagsDir, t, key);
+        if (prev.entry.path) await removeFromIndex(pathsDir, prev.entry.path, key);
+      }
+      await atomicWrite(entryFile(key), JSON.stringify({ key, entry }));
+      for (const t of entry.tags || []) await addToIndex(tagsDir, t, key);
+      if (entry.path) await addToIndex(pathsDir, entry.path, key);
+    },
+    async delete(key) {
+      return removeKey(key);
+    },
+    async deleteByTag(tag) {
+      return deleteByIndex(tagsDir, tag);
+    },
+    async deleteByPath(path) {
+      return deleteByIndex(pathsDir, path);
+    },
+    async clear() {
+      await rm(dir, { recursive: true, force: true });
+    },
+    async keys() {
+      return walkKeys();
+    }
+  };
+}
+
+// packages/cache/src/stores/redis-store.js
+function createRedisStore({ client, namespace = "what" } = {}) {
+  if (!client) throw new Error("[what-isr] createRedisStore requires { client }");
+  const ck = (key) => `${namespace}:cache:${key}`;
+  const tk = (tag) => `${namespace}:tag:${tag}`;
+  const pk = (path) => `${namespace}:path:${path}`;
+  async function deindex(key, entry) {
+    if (!entry) return;
+    for (const t of entry.tags || []) await client.srem(tk(t), key);
+    if (entry.path) await client.srem(pk(entry.path), key);
+  }
+  async function deleteBySet(setKey) {
+    const keys = await client.smembers(setKey) || [];
+    for (const k of keys) await client.del(ck(k));
+    await client.del(setKey);
+    return keys;
+  }
+  return {
+    async get(key) {
+      const v = await client.get(ck(key));
+      return v ? JSON.parse(v) : null;
+    },
+    async set(key, entry) {
+      const prev = await this.get(key);
+      if (prev) await deindex(key, prev);
+      await client.set(ck(key), JSON.stringify(entry));
+      for (const t of entry.tags || []) await client.sadd(tk(t), key);
+      if (entry.path) await client.sadd(pk(entry.path), key);
+    },
+    async delete(key) {
+      const entry = await this.get(key);
+      await client.del(ck(key));
+      await deindex(key, entry);
+      return !!entry;
+    },
+    async deleteByTag(tag) {
+      return deleteBySet(tk(tag));
+    },
+    async deleteByPath(path) {
+      return deleteBySet(pk(path));
+    },
+    async clear() {
+      if (typeof client.keys === "function") {
+        const all = await client.keys(`${namespace}:*`);
+        for (const k of all) await client.del(k);
+      }
+    },
+    async keys() {
+      if (typeof client.keys !== "function") return [];
+      const prefix = `${namespace}:cache:`;
+      const all = await client.keys(`${prefix}*`);
+      return all.map((k) => k.slice(prefix.length));
+    }
+  };
+}
+
+// packages/cache/src/paths.js
+async function resolveStaticPaths(getStaticPaths, ctx = {}) {
+  if (typeof getStaticPaths !== "function") return { paths: [], fallback: false };
+  const result = await getStaticPaths(ctx);
+  return {
+    paths: result && result.paths || [],
+    fallback: result && "fallback" in result ? result.fallback : false
+  };
+}
+function buildPath(pattern, params = {}) {
+  return pattern.replace(/[:*]([A-Za-z0-9_]+)/g, (_, name) => {
+    const v = params[name];
+    return v == null ? "" : String(v);
+  });
+}
+function isKnownParams(staticPaths, params) {
+  return staticPaths.some((entry) => {
+    const p = entry.params || {};
+    const keys = /* @__PURE__ */ new Set([...Object.keys(p), ...Object.keys(params)]);
+    for (const k of keys) if (String(p[k]) !== String(params[k])) return false;
+    return true;
+  });
+}
+function decideFallback(fallback, isKnown) {
+  if (isKnown) return "serve";
+  if (fallback === "blocking") return "render";
+  if (fallback === true) return "skeleton";
+  return "notfound";
+}
+
+// packages/cache/src/webhook.js
+function safeEqual(a, b) {
+  if (typeof a !== "string" || typeof b !== "string") return false;
+  if (a.length !== b.length) return false;
+  let result = 0;
+  for (let i = 0; i < a.length; i++) result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return result === 0;
+}
+function createRevalidateWebhook(engine, options = {}) {
+  const { secret, header = "x-what-revalidate-secret", regenerate = false } = options;
+  return async function handle(reqLike) {
+    const provided = (reqLike.headers || {})[header] || (reqLike.headers || {})[header.toLowerCase()];
+    if (!secret || !safeEqual(provided || "", secret)) {
+      return { status: 401, body: { message: "Unauthorized" } };
+    }
+    const body = reqLike.body;
+    if (!body || typeof body !== "object") {
+      return { status: 400, body: { message: "Invalid body" } };
+    }
+    const { paths, tags, regenerate: regen = regenerate } = body;
+    if (!Array.isArray(paths) && !Array.isArray(tags)) {
+      return { status: 400, body: { message: "Provide `paths` and/or `tags` arrays" } };
+    }
+    const revalidated = { paths: [], tags: [] };
+    if (Array.isArray(paths)) {
+      for (const p of paths) {
+        await engine.revalidatePath(p, { regenerate: regen });
+        revalidated.paths.push(p);
+      }
+    }
+    if (Array.isArray(tags)) {
+      for (const t of tags) {
+        await engine.revalidateTag(t, { regenerate: regen });
+        revalidated.tags.push(t);
+      }
+    }
+    return { status: 200, body: { revalidated: true, ...revalidated } };
+  };
+}
+
+// packages/cache/src/scheduler.js
+function createScheduler(engine, options = {}) {
+  const {
+    maxConcurrent = 4,
+    random = Math.random,
+    setTimer = setTimeout,
+    clearTimer = clearTimeout,
+    logger = console
+  } = options;
+  const tasks = [];
+  const queue = [];
+  let running = false;
+  let active = 0;
+  function jittered(intervalMs) {
+    return Math.round(intervalMs * (1 + random() * 0.1));
+  }
+  function schedule(task) {
+    task.timer = setTimer(() => fire(task), jittered(task.intervalMs));
+    if (task.timer && typeof task.timer.unref === "function") task.timer.unref();
+  }
+  function fire(task) {
+    if (!running) return;
+    if (active < maxConcurrent) runTask(task);
+    else queue.push(task);
+  }
+  async function runTask(task) {
+    active++;
+    try {
+      await engine.regenerate(task.route);
+    } catch (e) {
+      logger.error?.("[what-isr] scheduled regenerate failed:", e);
+    } finally {
+      active--;
+      if (running) schedule(task);
+      drain();
+    }
+  }
+  function drain() {
+    while (running && active < maxConcurrent && queue.length) {
+      runTask(queue.shift());
+    }
+  }
+  return {
+    register(route, { intervalMs }) {
+      tasks.push({ route, intervalMs, timer: null });
+      return this;
+    },
+    start() {
+      running = true;
+      for (const t of tasks) schedule(t);
+      return this;
+    },
+    stop() {
+      running = false;
+      for (const t of tasks) if (t.timer != null) clearTimer(t.timer);
+      queue.length = 0;
+      return this;
+    },
+    _tasks: tasks
+  };
+}
+
+// packages/cache/src/cdn/cloudflare.js
+function createCloudflareCDN({ zoneId, apiToken } = {}) {
+  const endpoint = `https://api.cloudflare.com/client/v4/zones/${zoneId}/purge_cache`;
+  const headers = { Authorization: `Bearer ${apiToken}`, "Content-Type": "application/json" };
+  async function post(body) {
+    if (!zoneId || !apiToken) return;
+    await fetch(endpoint, { method: "POST", headers, body: JSON.stringify(body) });
+  }
+  return {
+    purge: (urls) => post({ files: urls }),
+    purgeTags: (tags) => post({ tags })
+  };
+}
+
+// packages/cache/src/cdn/fastly.js
+function createFastlyCDN({ serviceId, apiToken } = {}) {
+  const headers = { "Fastly-Key": apiToken, Accept: "application/json" };
+  async function purgeKey(key) {
+    if (!serviceId || !apiToken) return;
+    await fetch(`https://api.fastly.com/service/${serviceId}/purge/${encodeURIComponent(key)}`, {
+      method: "POST",
+      headers
+    });
+  }
+  return {
+    async purge(urls) {
+      for (const url of urls) {
+        if (!apiToken) return;
+        await fetch(url, { method: "PURGE", headers });
+      }
+    },
+    async purgeTags(tags) {
+      for (const t of tags) await purgeKey(t);
+    }
+  };
+}
+
+// packages/cache/src/cdn/vercel.js
+function createVercelCDN({ token, projectId, teamId } = {}) {
+  const headers = { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
+  const qs = teamId ? `?teamId=${teamId}` : "";
+  async function purgeTags(tags) {
+    if (!token || !projectId) return;
+    await fetch(`https://api.vercel.com/v1/projects/${projectId}/cache/purge${qs}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ tags })
+    });
+  }
+  return {
+    purge: () => Promise.resolve(),
+    // Vercel purges by tag; URL purge is header-driven
+    purgeTags
+  };
+}
+export {
+  buildCacheHeaders,
+  buildPath,
+  cacheKey,
+  createCacheEngine,
+  createCloudflareCDN,
+  createFastlyCDN,
+  createFilesystemStore,
+  createMemoryStore,
+  createRedisStore,
+  createRevalidateWebhook,
+  createScheduler,
+  createVercelCDN,
+  decideFallback,
+  hashKey,
+  isFresh,
+  isKnownParams,
+  isServableStale,
+  makeEntry,
+  normalizePath,
+  normalizeQuery,
+  resolveStaticPaths
+};
+//# sourceMappingURL=index.js.map