hadars 0.1.9 → 0.1.11

package/dist/cli.js

@@ -149,48 +149,48 @@ async function getStaticMarkupRenderer() {
   }
   return _renderToStaticMarkup;
 }
-var getHeadHtml = (seoData, renderToStaticMarkup) => {
-  const metaEntries = Object.entries(seoData.meta);
-  const linkEntries = Object.entries(seoData.link);
-  const styleEntries = Object.entries(seoData.style);
-  const scriptEntries = Object.entries(seoData.script);
-  return renderToStaticMarkup(
-    /* @__PURE__ */ jsxs(Fragment, { children: [
-      /* @__PURE__ */ jsx("title", { children: seoData.title }),
-      metaEntries.map(([id, options]) => /* @__PURE__ */ jsx(
-        "meta",
-        {
-          id,
-          ...options
-        },
-        id
-      )),
-      linkEntries.map(([id, options]) => /* @__PURE__ */ jsx(
-        "link",
-        {
-          id,
-          ...options
-        },
-        id
-      )),
-      styleEntries.map(([id, options]) => /* @__PURE__ */ jsx(
-        "style",
-        {
-          id,
-          ...options
-        },
-        id
-      )),
-      scriptEntries.map(([id, options]) => /* @__PURE__ */ jsx(
-        "script",
-        {
-          id,
-          ...options
-        },
-        id
-      ))
-    ] })
-  );
+var ESC = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" };
+var escAttr = (s) => s.replace(/[&<>"]/g, (c) => ESC[c]);
+var escText = (s) => s.replace(/[&<>]/g, (c) => ESC[c]);
+var ATTR = {
+  className: "class",
+  htmlFor: "for",
+  httpEquiv: "http-equiv",
+  charSet: "charset",
+  crossOrigin: "crossorigin",
+  noModule: "nomodule",
+  referrerPolicy: "referrerpolicy",
+  fetchPriority: "fetchpriority"
+};
+function renderHeadTag(tag, id, opts, selfClose = false) {
+  let attrs = ` id="${escAttr(id)}"`;
+  let inner = "";
+  for (const [k, v] of Object.entries(opts)) {
+    if (k === "key" || k === "children")
+      continue;
+    if (k === "dangerouslySetInnerHTML") {
+      inner = v.__html ?? "";
+      continue;
+    }
+    const attr = ATTR[k] ?? k;
+    if (v === true)
+      attrs += ` ${attr}`;
+    else if (v !== false && v != null)
+      attrs += ` ${attr}="${escAttr(String(v))}"`;
+  }
+  return selfClose ? `<${tag}${attrs}>` : `<${tag}${attrs}>${inner}</${tag}>`;
+}
+var getHeadHtml = (seoData) => {
+  let html = `<title>${escText(seoData.title ?? "")}</title>`;
+  for (const [id, opts] of Object.entries(seoData.meta))
+    html += renderHeadTag("meta", id, opts, true);
+  for (const [id, opts] of Object.entries(seoData.link))
+    html += renderHeadTag("link", id, opts, true);
+  for (const [id, opts] of Object.entries(seoData.style))
+    html += renderHeadTag("style", id, opts);
+  for (const [id, opts] of Object.entries(seoData.script))
+    html += renderHeadTag("script", id, opts);
+  return html;
 };
 var getReactResponse = async (req, opts) => {
   const App = opts.document.body;
@@ -233,18 +233,17 @@ var getReactResponse = async (req, opts) => {
     if (unsuspend.hasPending)
       await processUnsuspend();
   } while (unsuspend.hasPending && ++iters < 25);
-  props = getAfterRenderProps ? await getAfterRenderProps(props, html) : props;
-  try {
-    globalThis.__hadarsUnsuspend = unsuspend;
-    renderToStaticMarkup(
-      /* @__PURE__ */ jsx(App, { ...{
-        ...props,
-        location: req.location,
-        context
-      } })
-    );
-  } finally {
-    globalThis.__hadarsUnsuspend = null;
+  if (unsuspend.hasPending) {
+    console.warn("[hadars] SSR render loop hit the 25-iteration cap \u2014 some useServerData values may not be resolved. Check for data dependencies that are never fulfilled.");
+  }
+  if (getAfterRenderProps) {
+    props = await getAfterRenderProps(props, html);
+    try {
+      globalThis.__hadarsUnsuspend = unsuspend;
+      renderToStaticMarkup(/* @__PURE__ */ jsx(App, { ...{ ...props, location: req.location, context } }));
+    } finally {
+      globalThis.__hadarsUnsuspend = null;
+    }
   }
   const serverData = {};
   for (const [k, v] of unsuspend.cache) {
@@ -268,7 +267,7 @@ var getReactResponse = async (req, opts) => {
   return {
     ReactPage,
     status: context.head.status,
-    headHtml: getHeadHtml(context.head, renderToStaticMarkup),
+    headHtml: getHeadHtml(context.head),
     renderPayload: {
       appProps: { ...props, location: req.location, context },
       clientProps
@@ -619,7 +618,45 @@ function nodeReadableToWebStream(readable) {
   });
 }
 var noopCtx = { upgrade: () => false };
+var COMPRESSIBLE_RE = /\b(?:text\/|application\/(?:json|javascript|xml)|image\/svg\+xml)/;
+function withCompression(handler) {
+  return async (req, ctx) => {
+    const res = await handler(req, ctx);
+    if (!res?.body)
+      return res;
+    if (!COMPRESSIBLE_RE.test(res.headers.get("Content-Type") ?? ""))
+      return res;
+    if (res.headers.has("Content-Encoding"))
+      return res;
+    const accept = req.headers.get("Accept-Encoding") ?? "";
+    const encoding = accept.includes("br") ? "br" : accept.includes("gzip") ? "gzip" : null;
+    if (!encoding)
+      return res;
+    try {
+      const compressed = res.body.pipeThrough(new globalThis.CompressionStream(encoding));
+      const headers = new Headers(res.headers);
+      headers.set("Content-Encoding", encoding);
+      headers.delete("Content-Length");
+      return new Response(compressed, { status: res.status, statusText: res.statusText, headers });
+    } catch {
+      return res;
+    }
+  };
+}
+function withRequestLogging(handler) {
+  return async (req, ctx) => {
+    const start = performance.now();
+    const res = await handler(req, ctx);
+    const ms = Math.round(performance.now() - start);
+    const status = res?.status ?? 404;
+    const path2 = new URL(req.url).pathname;
+    console.log(`[hadars] ${req.method} ${path2} ${status} ${ms}ms`);
+    return res;
+  };
+}
 async function serve(port, fetchHandler, websocket) {
+  fetchHandler = withCompression(fetchHandler);
+  fetchHandler = withRequestLogging(fetchHandler);
   if (isBun) {
     globalThis.Bun.serve({
       port,
@@ -740,6 +777,7 @@ import { RspackDevServer } from "@rspack/dev-server";
 import pathMod3 from "node:path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
 import { createRequire as createRequire2 } from "node:module";
+import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import { existsSync as existsSync2 } from "node:fs";
 import os from "node:os";
@@ -766,42 +804,52 @@ var RenderWorkerPool = class {
   workerPending = /* @__PURE__ */ new Map();
   nextId = 0;
   rrIndex = 0;
+  _Worker = null;
+  _workerPath = "";
+  _ssrBundlePath = "";
   constructor(workerPath, size, ssrBundlePath) {
     this._init(workerPath, size, ssrBundlePath);
   }
   _init(workerPath, size, ssrBundlePath) {
+    this._workerPath = workerPath;
+    this._ssrBundlePath = ssrBundlePath;
     import("node:worker_threads").then(({ Worker }) => {
-      for (let i = 0; i < size; i++) {
-        const w = new Worker(workerPath, { workerData: { ssrBundlePath } });
-        this.workerPending.set(w, /* @__PURE__ */ new Set());
-        w.on("message", (msg) => {
-          const { id, html, headHtml, status, error } = msg;
-          const p = this.pending.get(id);
-          if (!p)
-            return;
-          this.pending.delete(id);
-          this.workerPending.get(w)?.delete(id);
-          if (error)
-            p.reject(new Error(error));
-          else
-            p.resolve({ html, headHtml, status });
-        });
-        w.on("error", (err) => {
-          console.error("[hadars] Render worker error:", err);
-          this._handleWorkerDeath(w, err);
-        });
-        w.on("exit", (code) => {
-          if (code !== 0) {
-            console.error(`[hadars] Render worker exited with code ${code}`);
-            this._handleWorkerDeath(w, new Error(`Render worker exited with code ${code}`));
-          }
-        });
-        this.workers.push(w);
-      }
+      this._Worker = Worker;
+      for (let i = 0; i < size; i++)
+        this._spawnWorker();
     }).catch((err) => {
       console.error("[hadars] Failed to initialise render worker pool:", err);
     });
   }
+  _spawnWorker() {
+    if (!this._Worker)
+      return;
+    const w = new this._Worker(this._workerPath, { workerData: { ssrBundlePath: this._ssrBundlePath } });
+    this.workerPending.set(w, /* @__PURE__ */ new Set());
+    w.on("message", (msg) => {
+      const { id, html, headHtml, status, error } = msg;
+      const p = this.pending.get(id);
+      if (!p)
+        return;
+      this.pending.delete(id);
+      this.workerPending.get(w)?.delete(id);
+      if (error)
+        p.reject(new Error(error));
+      else
+        p.resolve({ html, headHtml, status });
+    });
+    w.on("error", (err) => {
+      console.error("[hadars] Render worker error:", err);
+      this._handleWorkerDeath(w, err);
+    });
+    w.on("exit", (code) => {
+      if (code !== 0) {
+        console.error(`[hadars] Render worker exited with code ${code}`);
+        this._handleWorkerDeath(w, new Error(`Render worker exited with code ${code}`));
+      }
+    });
+    this.workers.push(w);
+  }
   _handleWorkerDeath(w, err) {
     const idx = this.workers.indexOf(w);
     if (idx !== -1)
@@ -817,6 +865,8 @@ var RenderWorkerPool = class {
       }
       this.workerPending.delete(w);
     }
+    console.log("[hadars] Spawning replacement render worker");
+    this._spawnWorker();
   }
   nextWorker() {
     if (this.workers.length === 0)
@@ -906,6 +956,74 @@ var makePrecontentHtmlGetter = (htmlFilePromise) => {
     return [preHead + headHtml + postHead, postContent];
   };
 };
+async function transformStream(data, stream) {
+  const writer = stream.writable.getWriter();
+  writer.write(data);
+  writer.close();
+  const chunks = [];
+  const reader = stream.readable.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    chunks.push(value);
+  }
+  const total = chunks.reduce((n, c) => n + c.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.length;
+  }
+  return out;
+}
+var gzipCompress = (d) => transformStream(d, new globalThis.CompressionStream("gzip"));
+var gzipDecompress = (d) => transformStream(d, new globalThis.DecompressionStream("gzip"));
+function createRenderCache(opts, handler) {
+  const store = /* @__PURE__ */ new Map();
+  return async (req, ctx) => {
+    const hadarsReq = parseRequest(req);
+    const cacheOpts = await opts(hadarsReq);
+    const key = cacheOpts?.key ?? null;
+    if (key != null) {
+      const entry = store.get(key);
+      if (entry) {
+        if (entry.expiresAt == null || Date.now() < entry.expiresAt) {
+          const accept = req.headers.get("Accept-Encoding") ?? "";
+          if (accept.includes("gzip")) {
+            return new Response(entry.body.buffer, { status: entry.status, headers: entry.headers });
+          }
+          const plain = await gzipDecompress(entry.body);
+          const headers = entry.headers.filter(([k]) => k.toLowerCase() !== "content-encoding");
+          return new Response(plain.buffer, { status: entry.status, headers });
+        }
+        store.delete(key);
+      }
+    }
+    const res = await handler(req, ctx);
+    if (key != null && res) {
+      const ttl = cacheOpts?.ttl;
+      res.clone().arrayBuffer().then(async (buf) => {
+        const body = await gzipCompress(new Uint8Array(buf));
+        const headers = [];
+        res.headers.forEach((v, k) => {
+          if (k.toLowerCase() !== "content-encoding" && k.toLowerCase() !== "content-length") {
+            headers.push([k, v]);
+          }
+        });
+        headers.push(["content-encoding", "gzip"]);
+        store.set(key, {
+          body,
+          status: res.status,
+          headers,
+          expiresAt: ttl != null ? Date.now() + ttl : null
+        });
+      }).catch(() => {
+      });
+    }
+    return res;
+  };
+}
 var SSR_FILENAME = "index.ssr.js";
 var __dirname2 = process.cwd();
 var getSuffix = (mode) => mode === "development" ? `?v=${Date.now()}` : "";
@@ -968,7 +1086,7 @@ var dev = async (options) => {
   }
   const tmpFilePath = pathMod3.join(os.tmpdir(), `hadars-client-${Date.now()}.tsx`);
   await fs.writeFile(tmpFilePath, clientScript);
-  let ssrBuildId = Date.now();
+  let ssrBuildId = crypto.randomBytes(4).toString("hex");
   const clientCompiler = createClientCompiler(tmpFilePath, {
     target: "web",
     output: {
@@ -1083,7 +1201,7 @@ var dev = async (options) => {
           } catch (e) {
           }
           if (chunk.includes(rebuildMarker)) {
-            ssrBuildId = Date.now();
+            ssrBuildId = crypto.randomBytes(4).toString("hex");
             console.log("[hadars] SSR bundle updated, build id:", ssrBuildId);
           }
         }
@@ -1137,23 +1255,32 @@ var dev = async (options) => {
       return projectRes;
     const ssrComponentPath = pathMod3.join(__dirname2, HadarsFolder, SSR_FILENAME);
     const importPath = pathToFileURL2(ssrComponentPath).href + `?t=${ssrBuildId}`;
-    const {
-      default: Component,
-      getInitProps,
-      getAfterRenderProps,
-      getFinalProps
-    } = await import(importPath);
-    const { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
-      document: {
-        body: Component,
-        lang: "en",
+    try {
+      const {
+        default: Component,
         getInitProps,
         getAfterRenderProps,
         getFinalProps
-      }
-    });
-    const unsuspend = renderPayload.appProps.context?._unsuspend ?? null;
-    return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
+      } = await import(importPath);
+      const { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
+        document: {
+          body: Component,
+          lang: "en",
+          getInitProps,
+          getAfterRenderProps,
+          getFinalProps
+        }
+      });
+      const unsuspend = renderPayload.appProps.context?._unsuspend ?? null;
+      return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
+    } catch (err) {
+      console.error("[hadars] SSR render error:", err);
+      const msg = (err?.stack ?? err?.message ?? String(err)).replace(/</g, "&lt;");
+      return new Response(`<!doctype html><pre style="white-space:pre-wrap">${msg}</pre>`, {
+        status: 500,
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    }
   }, options.websocket);
 };
 var build = async (options) => {
@@ -1236,7 +1363,7 @@ var run = async (options) => {
   const getPrecontentHtml = makePrecontentHtmlGetter(
     fs.readFile(pathMod3.join(__dirname2, StaticPath, "out.html"), "utf-8")
   );
-  await serve(port, async (req, ctx) => {
+  const runHandler = async (req, ctx) => {
     const request = parseRequest(req);
     if (handler) {
       const res = await handler(request);
@@ -1273,33 +1400,43 @@ var run = async (options) => {
     const componentPath = pathToFileURL2(
       pathMod3.resolve(__dirname2, HadarsFolder, SSR_FILENAME)
     ).href;
-    const {
-      default: Component,
-      getInitProps,
-      getAfterRenderProps,
-      getFinalProps
-    } = await import(componentPath);
-    if (renderPool) {
-      const serialReq = await serializeRequest(request);
-      const { html, headHtml: wHead, status: wStatus } = await renderPool.renderFull(serialReq);
-      const [precontentHtml, postContent] = await getPrecontentHtml(wHead);
-      return new Response(precontentHtml + html + postContent, {
-        headers: { "Content-Type": "text/html; charset=utf-8" },
-        status: wStatus
-      });
-    }
-    const { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
-      document: {
-        body: Component,
-        lang: "en",
+    try {
+      const {
+        default: Component,
         getInitProps,
         getAfterRenderProps,
         getFinalProps
+      } = await import(componentPath);
+      if (renderPool) {
+        const serialReq = await serializeRequest(request);
+        const { html, headHtml: wHead, status: wStatus } = await renderPool.renderFull(serialReq);
+        const [precontentHtml, postContent] = await getPrecontentHtml(wHead);
+        return new Response(precontentHtml + html + postContent, {
+          headers: { "Content-Type": "text/html; charset=utf-8" },
+          status: wStatus
+        });
       }
-    });
-    const unsuspend = renderPayload.appProps.context?._unsuspend ?? null;
-    return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
-  }, options.websocket);
+      const { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
+        document: {
+          body: Component,
+          lang: "en",
+          getInitProps,
+          getAfterRenderProps,
+          getFinalProps
+        }
+      });
+      const unsuspend = renderPayload.appProps.context?._unsuspend ?? null;
+      return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
+    } catch (err) {
+      console.error("[hadars] SSR render error:", err);
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  };
+  await serve(
+    port,
+    options.cache ? createRenderCache(options.cache, runHandler) : runHandler,
+    options.websocket
+  );
 };
 
 // cli-lib.ts

package/dist/index.cjs

@@ -172,12 +172,13 @@ var AppProviderCSR = import_react.default.memo(({ children }) => {
 var useApp = () => import_react.default.useContext(AppContext);
 var clientServerDataCache = /* @__PURE__ */ new Map();
 function initServerDataCache(data) {
+  clientServerDataCache.clear();
   for (const [k, v] of Object.entries(data)) {
     clientServerDataCache.set(k, v);
   }
 }
 function useServerData(key, fn) {
-  const cacheKey = Array.isArray(key) ? key.join("\0") : key;
+  const cacheKey = Array.isArray(key) ? JSON.stringify(key) : key;
   if (typeof window !== "undefined") {
     if (clientServerDataCache.has(cacheKey)) {
       return clientServerDataCache.get(cacheKey);

package/dist/index.d.ts

@@ -92,6 +92,29 @@ interface HadarsOptions {
      * Has no effect on the SSR bundle or dev mode.
      */
     optimization?: Record<string, unknown>;
+    /**
+     * SSR response cache for `run()` mode. Has no effect in `dev()` mode.
+     *
+     * Receives the incoming request and should return `{ key, ttl? }` to cache
+     * the response, or `null`/`undefined` to skip caching for that request.
+     * `ttl` is the time-to-live in milliseconds; omit for entries that never expire.
+     * The function may be async.
+     *
+     * @example
+     * // Cache every page by pathname (no per-user personalisation):
+     * cache: (req) => ({ key: req.pathname })
+     *
+     * @example
+     * // Cache with a per-route TTL, skip authenticated requests:
+     * cache: (req) => req.cookies.session ? null : { key: req.pathname, ttl: 60_000 }
+     */
+    cache?: (req: HadarsRequest) => {
+        key: string;
+        ttl?: number;
+    } | null | undefined | Promise<{
+        key: string;
+        ttl?: number;
+    } | null | undefined>;
 }
 type SwcPluginItem = string | [string, Record<string, unknown>] | {
     path: string;
@@ -106,7 +129,8 @@ interface HadarsRequest extends Request {
 }
 
 /** Call this before hydrating to seed the client cache from the server's data.
- *  Invoked automatically by the hadars client bootstrap. */
+ *  Invoked automatically by the hadars client bootstrap.
+ *  Always clears the existing cache before populating — call with `{}` to just clear. */
 declare function initServerDataCache(data: Record<string, unknown>): void;
 /**
  * Fetch async data on the server during SSR. Returns `undefined` on the first

package/dist/index.js

@@ -132,12 +132,13 @@ var AppProviderCSR = React.memo(({ children }) => {
 var useApp = () => React.useContext(AppContext);
 var clientServerDataCache = /* @__PURE__ */ new Map();
 function initServerDataCache(data) {
+  clientServerDataCache.clear();
   for (const [k, v] of Object.entries(data)) {
     clientServerDataCache.set(k, v);
   }
 }
 function useServerData(key, fn) {
-  const cacheKey = Array.isArray(key) ? key.join("\0") : key;
+  const cacheKey = Array.isArray(key) ? JSON.stringify(key) : key;
   if (typeof window !== "undefined") {
     if (clientServerDataCache.has(cacheKey)) {
       return clientServerDataCache.get(cacheKey);