domma-cms 1.8.27 → 1.8.29

package/server/services/assetCache.js

@@ -0,0 +1,141 @@
+/**
+ * Static assets from memory, compressed once.
+ *
+ * @fastify/static streams every stylesheet and script from disk on every
+ * request - stat, open, read, close - and @fastify/compress then brotli's the
+ * stream for every visitor. On a busy site that was a whole core for about a
+ * thousand assets a second, all of it repeated work: the files do not change
+ * between requests. This hook, placed BEFORE @fastify/compress's, keeps the
+ * served form of a text asset in memory - the bytes as sent, per encoding
+ * (br, gzip, or identity for a client that accepts none) - and answers the
+ * next request with the buffer. The file is still stat'ed each time, so an
+ * edit (a new mtime or size) is seen at once, and @fastify/static still does
+ * everything else: it resolved the path, set the type, the cache-control the
+ * mount asked for, the ETag and Last-Modified, and answered the 304s, the
+ * HEADs and the 404s before this runs. The hook only swaps the stream for a
+ * buffer, so a file @fastify/static would not have served is never served
+ * here either.
+ *
+ * Only what is worth it: GET, a 200, a compressible type (the same rule
+ * @fastify/compress uses), no Range, a file between 1 KB and `maxFileBytes`.
+ * Images, fonts and media stream as before. On while the response cache is
+ * on, like the page memo - the admin's cache switch means all of it - and
+ * emptied when the cache is cleared or re-initialised. Bounded by bytes, not
+ * entries, with the least recently served evicted first.
+ */
+import fs from 'node:fs/promises';
+import * as cache from './cache/index.js';
+import {encode, pickEncoding} from './htmlResponse.js';
+
+/** @fastify/compress's own rule for what is text enough to compress. */
+const COMPRESSIBLE = /^text\/(?!event-stream)|(?:\+|\/)json(?:;|$)|(?:\+|\/)text(?:;|$)|(?:\+|\/)xml(?:;|$)|javascript(?:;|$)/u;
+
+const DEFAULTS = {maxBytes: 64 * 1024 * 1024, maxFileBytes: 2 * 1024 * 1024, minBytes: 1024};
+
+/** @type {Map<string, {mtimeMs: number, size: number, body: Buffer}>} key = encoding + NUL + path */
+const _entries = new Map();
+/** @type {Map<string, Promise<Buffer>>} */
+const _inflight = new Map();
+let _bytes = 0;
+let _limits = {...DEFAULTS};
+const _stats = {hits: 0, misses: 0, evictions: 0};
+
+cache.onInvalidate((reason) => {
+    // Tags name pages, collections and blocks, never files; a file's own
+    // change is seen through its mtime. A clear, a re-init or the cache going
+    // off empties this too.
+    if (reason !== 'tags') clearAssetCache();
+});
+
+export function clearAssetCache() {
+    _entries.clear();
+    _inflight.clear();
+    _bytes = 0;
+}
+
+export function assetCacheStats() {
+    return {entries: _entries.size, bytes: _bytes, maxBytes: _limits.maxBytes, hits: _stats.hits, misses: _stats.misses, evictions: _stats.evictions};
+}
+
+export function _resetAssetCacheForTests() {
+    clearAssetCache();
+    _stats.hits = 0;
+    _stats.misses = 0;
+    _stats.evictions = 0;
+}
+
+/**
+ * Is this a stream @fastify/static made for a file? @fastify/send opens the
+ * file with fs.createReadStream, which carries the path it opened.
+ */
+function fileOf(payload) {
+    return payload && typeof payload.pipe === 'function' && typeof payload.path === 'string' ? payload.path : null;
+}
+
+async function bodyFor(file, st, encoding) {
+    const key = `${encoding}\0${file}`;
+    const kept = _entries.get(key);
+    if (kept && kept.mtimeMs === st.mtimeMs && kept.size === st.size) {
+        _entries.delete(key);
+        _entries.set(key, kept); // most recently served last
+        _stats.hits++;
+        return kept.body;
+    }
+    if (_inflight.has(key)) return _inflight.get(key);
+    _stats.misses++;
+    const making = (async () => {
+        try {
+            const raw = await fs.readFile(file);
+            const body = encoding === 'identity' ? raw : await encode(raw, encoding);
+            if (kept) { _bytes -= kept.body.length; _entries.delete(key); }
+            _entries.set(key, {mtimeMs: st.mtimeMs, size: st.size, body});
+            _bytes += body.length;
+            while (_bytes > _limits.maxBytes && _entries.size > 1) {
+                const [oldestKey, oldest] = _entries.entries().next().value;
+                _entries.delete(oldestKey);
+                _bytes -= oldest.body.length;
+                _stats.evictions++;
+            }
+            return body;
+        } finally {
+            _inflight.delete(key);
+        }
+    })();
+    _inflight.set(key, making);
+    return making;
+}
+
+/**
+ * Add the onSend hook. Call BEFORE registering @fastify/compress, so this
+ * runs first and compress sees `content-encoding` already set and steps aside.
+ *
+ * @param {import('fastify').FastifyInstance} app
+ * @param {{maxBytes?: number, maxFileBytes?: number, minBytes?: number}} [limits]
+ */
+export function registerAssetCache(app, limits = {}) {
+    _limits = {...DEFAULTS, ...limits};
+    app.addHook('onSend', async (request, reply, payload) => {
+        if (request.method !== 'GET' || reply.statusCode !== 200 || !cache.isEnabled()) return payload;
+        const file = fileOf(payload);
+        if (!file || request.headers.range) return payload;
+        if (!COMPRESSIBLE.test(String(reply.getHeader('content-type') || ''))) return payload;
+        if (reply.getHeader('content-encoding')) return payload; // a precompressed file @fastify/static served itself
+
+        let st;
+        try { st = await fs.stat(file); } catch { return payload; }
+        if (!st.isFile() || st.size < _limits.minBytes || st.size > _limits.maxFileBytes) return payload;
+
+        const encoding = pickEncoding(request.headers['accept-encoding']) || 'identity';
+        let body;
+        try { body = await bodyFor(file, st, encoding); } catch { return payload; }
+
+        payload.destroy(); // the stream @fastify/static opened: release its file descriptor
+        reply.removeHeader('accept-ranges');
+        reply.header('content-length', body.length);
+        if (encoding !== 'identity') {
+            reply.header('content-encoding', encoding);
+            reply.header('vary', 'accept-encoding');
+        }
+        return body;
+    });
+}

package/server/services/htmlResponse.js

@@ -72,12 +72,12 @@ export function pickEncoding(header, offered = ENCODINGS) {
 /**
  * The compressed body, the way @fastify/compress would have made it.
  *
- * @param {string} html
+ * @param {string|Buffer} input
  * @param {string} encoding - 'br' | 'gzip'
  * @returns {Promise<Buffer>}
  */
-export function encodeHtml(html, encoding) {
-    const input = Buffer.from(html, 'utf8');
+export function encode(input, encoding) {
+    if (!Buffer.isBuffer(input)) input = Buffer.from(String(input), 'utf8');
     if (encoding === 'br') {
         return brotli(input, {params: {
             [zlib.constants.BROTLI_PARAM_QUALITY]: 4,
@@ -88,6 +88,9 @@ export function encodeHtml(html, encoding) {
     throw new Error(`Unknown encoding: ${encoding}`);
 }
 
+/** encode() for a page's HTML. */
+export const encodeHtml = encode;
+
 /** The validator's content part: the same hash whatever the encoding. */
 export function htmlHash(html) {
     return createHash('sha1').update(html).digest('base64');

package/server/services/renderer.js

@@ -687,6 +687,10 @@ function buildSeoMeta({page, site, baseUrl, title, description, image}) {
         });
     }
 
+    // The page's own structured data (frontmatter `seo.schema` - the editor's
+    // SEO tab): one object or a list, each emitted as its own block.
+    jsonLd.push(...schemaBlocks(page.seo?.schema));
+
     return {
         title,
         description,
@@ -703,6 +707,32 @@ function buildSeoMeta({page, site, baseUrl, title, description, image}) {
     };
 }
 
+/**
+ * The JSON-LD blocks a page declares in `seo.schema`: an object, a list of
+ * them, or a JSON string of either (a hand-written frontmatter may hold it as
+ * text). Anything that is not a plain object with a string `@type` is dropped
+ * rather than emitted broken, and `@context` defaults to schema.org, which is
+ * what every example and validator expects. Pure.
+ *
+ * @param {unknown} value
+ * @returns {object[]}
+ */
+export function schemaBlocks(value) {
+    let v = value;
+    if (typeof v === 'string') {
+        if (!v.trim()) return [];
+        try { v = JSON.parse(v); } catch { return []; }
+    }
+    const list = Array.isArray(v) ? v : [v];
+    const out = [];
+    for (const item of list) {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) continue;
+        if (typeof item['@type'] !== 'string' || !item['@type'].trim()) continue;
+        out.push(item['@context'] ? item : {'@context': 'https://schema.org', ...item});
+    }
+    return out;
+}
+
 /** An absolute URL for og:image and JSON-LD: crawlers ignore relative ones. */
 function absoluteUrl(url, origin) {
     const u = String(url || '').trim();

package/server/templates/page.html

@@ -25,7 +25,7 @@
     <link rel="stylesheet" href="/dist/domma/themes/domma-themes.css">
 
     <!-- Site CSS -->
-    <link rel="stylesheet" href="/public/css/site.css?v=20261016-footer-blocks">
+    <link rel="stylesheet" href="/public/css/site.css?v=20261019-button-defaults">
     <link rel="stylesheet" href="/public/css/forms.css?v=20260927-submit-btn-css">
     <!-- Menu item hover / current-page effects. Loaded after site.css so a
          menu's own highlight wins over the blanket link styling there. -->