domma-cms 0.16.0 → 0.18.0

package/server/services/health.js

@@ -0,0 +1,282 @@
+/**
+ * Health Service
+ * Aggregates server + site health checks for the dashboard.
+ * Each check returns { id, level: 'ok'|'warn'|'fail', label, value, detail? }.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import {fileURLToPath} from 'url';
+import {config} from '../config.js';
+import {getLastSendResult} from './email.js';
+import {listPages} from './content.js';
+import {getPluginLoadFailures} from './plugins.js';
+import {FORMS_DIR} from './forms.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..', '..');
+
+const CACHE_TTL_MS = 30 * 1000;
+const STALE_PAGE_DAYS = 90;
+const FORM_WARN_DAYS  = 30;
+let cached = { at: 0, value: null };
+
+const LEVELS = { ok: 0, warn: 1, fail: 2 };
+
+/**
+ * Compute the worst level across a set of checks.
+ *
+ * @param {Array<{ level: string }>} checks
+ * @returns {string}
+ */
+function worstLevel(checks) {
+    let worst = 'ok';
+    for (const c of checks) if (LEVELS[c.level] > LEVELS[worst]) worst = c.level;
+    return worst;
+}
+
+/**
+ * Format a byte count as a human-readable string.
+ *
+ * @param {number} n
+ * @returns {string}
+ */
+function formatBytes(n) {
+    if (n < 1024) return n + ' B';
+    if (n < 1024 * 1024) return (n / 1024).toFixed(1) + ' KB';
+    if (n < 1024 * 1024 * 1024) return (n / 1024 / 1024).toFixed(1) + ' MB';
+    return (n / 1024 / 1024 / 1024).toFixed(2) + ' GB';
+}
+
+/**
+ * Format a duration in seconds as a human-readable string.
+ *
+ * @param {number} seconds
+ * @returns {string}
+ */
+function formatDuration(seconds) {
+    const d = Math.floor(seconds / 86400);
+    const h = Math.floor((seconds % 86400) / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    const s = Math.floor(seconds % 60);
+    if (d > 0) return `${d}d ${h}h`;
+    if (h > 0) return `${h}h ${m}m`;
+    if (m > 0) return `${m}m`;
+    return `${s}s`;
+}
+
+/**
+ * Recursively compute the size of a directory in bytes.
+ *
+ * @param {string} dir
+ * @returns {Promise<number>}
+ */
+async function dirSize(dir) {
+    let total = 0;
+    let entries;
+    try { entries = await fs.readdir(dir, { withFileTypes: true }); }
+    catch { return 0; }
+    for (const e of entries) {
+        const full = path.join(dir, e.name);
+        if (e.isDirectory()) total += await dirSize(full);
+        else if (e.isFile()) {
+            try { total += (await fs.stat(full)).size; } catch { /* ignore */ }
+        }
+    }
+    return total;
+}
+
+// ---------------------------------------------------------------------------
+// Individual checks
+// ---------------------------------------------------------------------------
+
+async function checkUptime() {
+    return {
+        id: 'uptime',
+        level: 'ok',
+        label: 'Uptime',
+        value: formatDuration(Math.floor(process.uptime()))
+    };
+}
+
+async function checkMemory() {
+    const mem = process.memoryUsage();
+    const usedMb = mem.heapUsed / 1024 / 1024;
+    const totalMb = mem.heapTotal / 1024 / 1024;
+    const pct = totalMb === 0 ? 0 : usedMb / totalMb;
+    return {
+        id: 'memory',
+        level: pct > 0.9 ? 'warn' : 'ok',
+        label: 'Heap',
+        value: `${usedMb.toFixed(0)} / ${totalMb.toFixed(0)} MB`
+    };
+}
+
+async function checkContentDisk() {
+    const contentDir = path.isAbsolute(config.content.contentDir)
+        ? config.content.contentDir
+        : path.join(ROOT, config.content.contentDir);
+    const size = await dirSize(contentDir);
+    return {
+        id: 'disk-content',
+        level: 'ok',
+        label: 'Content disk',
+        value: formatBytes(size)
+    };
+}
+
+async function checkStalePages() {
+    const pages = await listPages().catch(() => []);
+    const cutoff = Date.now() - STALE_PAGE_DAYS * 24 * 60 * 60 * 1000;
+    const stale = pages.filter(p => {
+        const updated = p.updatedAt ? new Date(p.updatedAt).getTime() : 0;
+        return updated > 0 && updated < cutoff;
+    });
+    return {
+        id: 'stale-pages',
+        level: stale.length === 0 ? 'ok' : 'warn',
+        label: `Stale pages (>${STALE_PAGE_DAYS}d)`,
+        value: stale.length,
+        detail: stale.slice(0, 10).map(p => p.urlPath)
+    };
+}
+
+async function checkMissingMeta() {
+    const pages = await listPages().catch(() => []);
+    const missing = pages.filter(p => !p.description || String(p.description).trim() === '');
+    return {
+        id: 'missing-meta',
+        level: missing.length === 0 ? 'ok' : 'warn',
+        label: 'Pages missing description',
+        value: missing.length,
+        detail: missing.slice(0, 10).map(p => p.urlPath)
+    };
+}
+
+async function checkLastForm() {
+    let formsExist = false;
+    try {
+        const formFiles = await fs.readdir(FORMS_DIR);
+        formsExist = formFiles.some(f => f.endsWith('.json'));
+    } catch { /* no forms dir */ }
+
+    const collectionsDir = path.join(ROOT, 'content', 'collections');
+    let newestIso = '';
+    let dirs = [];
+    try { dirs = await fs.readdir(collectionsDir, { withFileTypes: true }); } catch { /* none */ }
+    for (const d of dirs) {
+        if (!d.isDirectory()) continue;
+        const dataFile = path.join(collectionsDir, d.name, 'data.json');
+        let entries = [];
+        try { entries = JSON.parse(await fs.readFile(dataFile, 'utf8')); }
+        catch { continue; }
+        if (!Array.isArray(entries)) continue;
+        for (const e of entries) {
+            const at = e?.meta?.createdAt;
+            if (typeof at === 'string' && at > newestIso) newestIso = at;
+        }
+    }
+
+    if (!formsExist) {
+        return { id: 'last-form', level: 'ok', label: 'Last form submission', value: 'no forms defined' };
+    }
+    if (!newestIso) {
+        return { id: 'last-form', level: 'warn', label: 'Last form submission', value: 'never' };
+    }
+    const ageDays = (Date.now() - new Date(newestIso).getTime()) / (24 * 60 * 60 * 1000);
+    return {
+        id: 'last-form',
+        level: ageDays > FORM_WARN_DAYS ? 'warn' : 'ok',
+        label: 'Last form submission',
+        value: newestIso
+    };
+}
+
+async function checkSmtp() {
+    const r = getLastSendResult();
+    if (!r) return { id: 'smtp', level: 'ok', label: 'Last email send', value: 'never sent' };
+    return {
+        id: 'smtp',
+        level: r.ok ? 'ok' : 'fail',
+        label: 'Last email send',
+        value: r.at,
+        detail: r.info ? [r.info] : []
+    };
+}
+
+async function checkPluginLoad() {
+    const failures = getPluginLoadFailures();
+    return {
+        id: 'plugin-load',
+        level: failures.length === 0 ? 'ok' : 'fail',
+        label: 'Plugin failures',
+        value: failures.length,
+        detail: failures.slice(0, 10).map(f => `${f.name}: ${f.reason}`)
+    };
+}
+
+// ---------------------------------------------------------------------------
+// Orchestrator
+// ---------------------------------------------------------------------------
+
+/**
+ * Run a single health check, isolating any thrown errors.
+ *
+ * If the check function throws, the failure is degraded to a `fail`-level
+ * result for that check rather than propagating and killing the aggregate.
+ *
+ * @param {string} label
+ * @param {() => Promise<object>} fn
+ * @returns {Promise<object>}
+ */
+async function safeCheck(label, fn) {
+    try {
+        return await fn();
+    } catch (err) {
+        return {
+            id: label,
+            level: 'fail',
+            label,
+            value: 'check failed',
+            detail: [String(err.message || err)]
+        };
+    }
+}
+
+/**
+ * Aggregate site + server health checks.
+ *
+ * Returns the cached result if it's within the 30 s TTL; otherwise runs all eight
+ * checks in parallel and caches the result. Per-check errors are isolated — an
+ * unexpected throw degrades only that check to `fail`, never the whole call.
+ *
+ * Note: no in-flight deduplication. Two concurrent cache misses will both run the
+ * eight checks. Acceptable for the dashboard's traffic profile; revisit if the
+ * checks become heavy or the cache TTL drops.
+ *
+ * @returns {Promise<{status: 'ok'|'warn'|'fail', checks: Array}>}
+ */
+export async function getHealth() {
+    if (cached.value && Date.now() - cached.at < CACHE_TTL_MS) return cached.value;
+    const checks = await Promise.all([
+        safeCheck('uptime',       checkUptime),
+        safeCheck('memory',       checkMemory),
+        safeCheck('disk-content', checkContentDisk),
+        safeCheck('stale-pages',  checkStalePages),
+        safeCheck('missing-meta', checkMissingMeta),
+        safeCheck('last-form',    checkLastForm),
+        safeCheck('smtp',         checkSmtp),
+        safeCheck('plugin-load',  checkPluginLoad)
+    ]);
+    const value = { status: worstLevel(checks), checks };
+    cached = { at: Date.now(), value };
+    return value;
+}
+
+export { worstLevel };
+
+/**
+ * Reset the in-memory cache. Test-only helper.
+ *
+ * @returns {void}
+ */
+export function _resetCache() { cached = { at: 0, value: null }; }

package/server/services/markdown.js

@@ -247,7 +247,7 @@ async function getBlockShortTagNames() {
  * @param {string} content
  * @returns {Promise<string>}
  */
-async function processStaticBlocks(content) {
+async function processStaticBlocks(content, tagSet) {
     // --- [block template="name" .../] ---
     const pattern = /\[block\s+([\s\S]+?)\/\]/g;
     const matches = [...content.matchAll(pattern)];
@@ -262,6 +262,7 @@ async function processStaticBlocks(content) {
             output = output.slice(0, match.index) + output.slice(match.index + match[0].length);
             continue;
         }
+        tagSet?.add(`block:${attrs.template}`);
         let replacement = '';
         try {
             const [tpl, css] = await Promise.all([
@@ -287,6 +288,7 @@ async function processStaticBlocks(content) {
             for (const [, key, dq, sq] of (match[1] ?? '').matchAll(/([\w-]+)=(?:"([^"]*)"|'([^']*)')/g)) {
                 attrs[key] = dq ?? sq ?? '';
             }
+            tagSet?.add(`block:${tagName}`);
             let replacement = '';
             try {
                 const [tpl, css] = await Promise.all([
@@ -458,7 +460,7 @@ function renderCollectionTimeline(entries, opts) {
  * @param {string} markdown
  * @returns {Promise<string>}
  */
-async function processViewBlocks(markdown) {
+async function processViewBlocks(markdown, tagSet) {
     const {scrubbed, restore} = scrubCodeRegions(markdown);
     const pattern = /\[view([^\]]*?)\/\]/gi;
     const matches = [...scrubbed.matchAll(pattern)];
@@ -474,6 +476,7 @@ async function processViewBlocks(markdown) {
             result = result.replace(fullMatch, '');
             continue;
         }
+        tagSet?.add(`view:${slug}`);
 
         const displayAttr = attrs.display || '';
         const emptyMsg   = attrs.empty      || 'No results found';
@@ -579,7 +582,7 @@ async function processViewBlocks(markdown) {
  * @param {string} markdown
  * @returns {Promise<string>}
  */
-async function processCollectionBlocks(markdown) {
+async function processCollectionBlocks(markdown, tagSet) {
     const {scrubbed, restore} = scrubCodeRegions(markdown);
     // Find all [collection ...] shortcodes
     const pattern = /\[collection([^\]]*?)\/\]/gi;
@@ -596,6 +599,7 @@ async function processCollectionBlocks(markdown) {
             result = result.replace(fullMatch, '');
             continue;
         }
+        tagSet?.add(`collection:${slug}`);
 
         const display    = attrs.display || 'table';
         const limitAttr  = parseInt(attrs.limit, 10) || 0;
@@ -1947,11 +1951,13 @@ function processAccordionBlocks(markdown) {
  *   [/carousel]
  *
  * Supported attributes on [carousel]:
- *   autoplay  - "true" to auto-advance slides
- *   interval  - milliseconds between slides (default 5000)
- *   loop      - "false" to disable loop (default true)
- *   animation - "fade" or "slide" (default slide)
- *   id        - optional id on the wrapper
+ *   autoplay           - "true" to auto-advance slides
+ *   interval           - milliseconds between slides (default 5000)
+ *   loop               - "false" to disable loop (default true)
+ *   animation          - "slide" | "fade" | "crossfade" (default slide)
+ *   animation-duration - transition length in milliseconds (default 500)
+ *   animation-easing   - CSS timing function (e.g. ease, linear, ease-in-out, cubic-bezier(...))
+ *   id                 - optional id on the wrapper
  *
  * Supported attributes on [slide]:
  *   image - URL of a background/header image
@@ -1970,7 +1976,9 @@ function processCarouselBlocks(markdown) {
         attrs.autoplay ? ` data-autoplay="${escapeAttr(attrs.autoplay)}"` : '',
         attrs.interval ? ` data-interval="${escapeAttr(attrs.interval)}"` : '',
         attrs.loop ? ` data-loop="${escapeAttr(attrs.loop)}"` : '',
-        attrs.animation ? ` data-animation="${escapeAttr(attrs.animation)}"` : ''
+        attrs.animation ? ` data-animation="${escapeAttr(attrs.animation)}"` : '',
+        attrs['animation-duration'] ? ` data-animation-duration="${escapeAttr(attrs['animation-duration'])}"` : '',
+        attrs['animation-easing'] ? ` data-animation-easing="${escapeAttr(attrs['animation-easing'])}"` : ''
       ].join('');
       const idAttr = attrs.id ? ` id="${escapeAttr(attrs.id)}"` : '';
 
@@ -2617,7 +2625,7 @@ function processIconBlocks(markdown) {
  */
 const FORMS_DIR = path.resolve(__dirname_md, '../../content/forms');
 
-async function processFormBlocks(markdown) {
+async function processFormBlocks(markdown, tagSet) {
   const {scrubbed, restore} = scrubCodeRegions(markdown);
   const regex = /\[form([^\]]*?)\/\]/gi;
   let result = scrubbed;
@@ -2638,6 +2646,7 @@ async function processFormBlocks(markdown) {
           result = result.slice(0, index) + `<div class="cms-form-error">Invalid form slug: ${escapeAttr(slug)}</div>` + result.slice(index + full.length);
           continue;
       }
+      tagSet?.add(`form:${slug}`);
     let replacement;
     try {
       const filePath = path.resolve(FORMS_DIR, `${slug}.json`);
@@ -2916,9 +2925,10 @@ export async function parseMarkdown(raw) {
   //   → grid → card → slideover → marked → sanitize → afterParse
   const preprocessed = applyTransforms('markdown:beforeParse', content);
   const {output: withComponents, used: usedComponents} = collectAndRewriteComponents(preprocessed);
-  const withCollection = await processCollectionBlocks(withComponents);
-  const withView = await processViewBlocks(withCollection);
-  const withStaticBlock = await processStaticBlocks(withView);
+  const tagSet = new Set();
+  const withCollection = await processCollectionBlocks(withComponents, tagSet);
+  const withView = await processViewBlocks(withCollection, tagSet);
+  const withStaticBlock = await processStaticBlocks(withView, tagSet);
   const withDconfig = processDConfigBlocks(withStaticBlock);
     const withEffects = processEffectsBlocks(withDconfig);
     const withPluginShortcodes = await processPluginShortcodes(withEffects);
@@ -2931,7 +2941,7 @@ export async function parseMarkdown(raw) {
     const withSpacer = processSpacerBlocks(withListGroup);
     const withCenter = processCenterBlocks(withSpacer);
     const withIcon = processIconBlocks(withCenter);
-  const withForm = await processFormBlocks(withIcon);
+  const withForm = await processFormBlocks(withIcon, tagSet);
   const withHero = processHeroBlocks(withForm);
   const withTable = processTableBlocks(withHero);
   const withBadge  = processBadgeBlocks(withTable);
@@ -2997,7 +3007,7 @@ export async function parseMarkdown(raw) {
   const allowed = new Set(_dmTagAllowlist.map(t => t.replace(/^dm-/, '')));
   const filteredUsed = [...usedComponents].filter(name => allowed.has(name));
 
-  return {data, content, html, usedComponents: filteredUsed};
+  return {data, content, html, usedComponents: filteredUsed, tags: [...tagSet]};
 }
 
 /**

package/server/services/plugins.js

@@ -23,6 +23,28 @@ const PLUGINS_DIR = path.resolve('plugins');
 
 const REQUIRED_MANIFEST_FIELDS = ['name', 'displayName', 'version', 'description', 'author', 'date', 'icon'];
 
+const failedLoads = [];
+
+/**
+ * Record a plugin load failure for health reporting.
+ *
+ * @param {string} name
+ * @param {string} reason
+ * @returns {void}
+ */
+export function recordPluginLoadFailure(name, reason) {
+    failedLoads.push({ name, reason, at: new Date().toISOString() });
+}
+
+/**
+ * Return a snapshot of all recorded plugin load failures.
+ *
+ * @returns {Array<{ name: string, reason: string, at: string }>}
+ */
+export function getPluginLoadFailures() {
+    return failedLoads.slice();
+}
+
 /**
  * In-memory registry of loaded plugins, populated by registerPlugins().
  * Keyed by plugin name; each entry mirrors the manifest plus runtime metadata.
@@ -71,7 +93,9 @@ export async function discoverPlugins() {
         let valid = true;
         for (const field of REQUIRED_MANIFEST_FIELDS) {
             if (!manifest[field]) {
-                console.warn(`Plugin "${dir}": missing required field "${field}" in plugin.json — skipping`);
+                const reason = `missing required field "${field}" in plugin.json`;
+                console.warn(`Plugin "${dir}": ${reason} — skipping`);
+                recordPluginLoadFailure(dir, reason);
                 valid = false;
                 break;
             }
@@ -85,14 +109,18 @@ export async function discoverPlugins() {
         try {
             await fs.access(pluginJsPath);
         } catch {
-            console.warn(`Plugin "${dir}": missing required file plugin.js — skipping`);
+            const reason = 'missing required file plugin.js';
+            console.warn(`Plugin "${dir}": ${reason} — skipping`);
+            recordPluginLoadFailure(dir, reason);
             continue;
         }
 
         try {
             await fs.access(configJsPath);
         } catch {
-            console.warn(`Plugin "${dir}": missing required file config.js — skipping`);
+            const reason = 'missing required file config.js';
+            console.warn(`Plugin "${dir}": ${reason} — skipping`);
+            recordPluginLoadFailure(dir, reason);
             continue;
         }
 
@@ -118,7 +146,9 @@ async function loadConfigDefaults(name) {
     const {default: exported} = await import(configJsPath);
     defaults = exported || {};
   } catch (err) {
-    console.warn(`Plugin "${name}": failed to load config.js — ${err.message}`);
+    const reason = `failed to load config.js — ${err.message}`;
+    console.warn(`Plugin "${name}": ${reason}`);
+    recordPluginLoadFailure(name, reason);
   }
   _configDefaultsCache.set(name, defaults);
   return defaults;
@@ -194,7 +224,9 @@ export async function registerPlugins(fastify) {
                 // no public entry — that's fine
             }
         } catch (err) {
-            fastify.log.error(`Plugin "${manifest.name}" server failed to load: ${err.message}`);
+            const reason = `server failed to load: ${err.message}`;
+            fastify.log.error(`Plugin "${manifest.name}" ${reason}`);
+            recordPluginLoadFailure(manifest.name, reason);
         }
     }
 

package/server/services/views.js

@@ -14,6 +14,7 @@
  */
 import {v4 as uuidv4} from 'uuid';
 import {buildRowLevelMatch} from './rowAccess.js';
+import * as cache from './cache/index.js';
 
 /** MongoDB collection where view configs are stored. */
 const VIEWS_COLLECTION = 'cms__views';
@@ -173,6 +174,7 @@ export async function createView(data, userId = null) {
     };
 
     await db.collection(VIEWS_COLLECTION).insertOne({ ...view });
+    await cache.invalidateTags([`view:${slug}`]);
     return view;
 }
 
@@ -206,6 +208,7 @@ export async function updateView(slug, data) {
     };
 
     await db.collection(VIEWS_COLLECTION).replaceOne({ slug }, { ...updated });
+    await cache.invalidateTags([`view:${slug}`]);
     const { _id: _stripped, ...result } = updated;
     return result;
 }
@@ -221,6 +224,7 @@ export async function deleteView(slug) {
     const db = await getMetaDb();
     const result = await db.collection(VIEWS_COLLECTION).deleteOne({ slug });
     if (result.deletedCount === 0) throw new Error(`View "${slug}" not found`);
+    await cache.invalidateTags([`view:${slug}`]);
 }
 
 // ---------------------------------------------------------------------------