domma-cms 0.15.0 → 0.17.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

@@ -763,7 +763,7 @@ export function scrubCodeRegions(markdown) {
  * @param {string} markdown
  * @returns {string}
  */
-function processPluginShortcodes(markdown) {
+async function processPluginShortcodes(markdown) {
   const processors = getShortcodeProcessors();
   if (!processors.length) return markdown;
 
@@ -771,14 +771,34 @@ function processPluginShortcodes(markdown) {
   let result = scrubbed;
   const context = {parseShortcodeAttrs, scrubCodeRegions, marked, processCardBlocks, processGridBlocks, escapeAttr};
 
+  async function replaceAsync(input, regex, mapMatch) {
+    const matches = [];
+    input.replace(regex, (...args) => {
+      const offset = args[args.length - 2];
+      matches.push({ args: args.slice(0, -2), full: args[0], offset });
+      return args[0];
+    });
+    if (!matches.length) return input;
+    const out = await Promise.all(matches.map((m) => Promise.resolve(mapMatch(...m.args))));
+    let res = '';
+    let lastEnd = 0;
+    matches.forEach((m, i) => {
+      res += input.slice(lastEnd, m.offset) + out[i];
+      lastEnd = m.offset + m.full.length;
+    });
+    return res + input.slice(lastEnd);
+  }
+
   for (const {name, handler} of processors) {
     // Self-closing: [name attrs /]
-    result = result.replace(
+    result = await replaceAsync(
+      result,
       new RegExp(`\\[${name}([^\\]]*)\\s*\\/\\]`, 'gi'),
       (_, attrStr) => handler(attrStr, null, context)
     );
     // Wrapping: [name attrs]...[/name]
-    result = result.replace(
+    result = await replaceAsync(
+      result,
       new RegExp(`\\[${name}([^\\]]*)\\]([\\s\\S]*?)\\[\\/${name}\\]`, 'gi'),
       (_, attrStr, body) => handler(attrStr, body, context)
     );
@@ -2901,7 +2921,7 @@ export async function parseMarkdown(raw) {
   const withStaticBlock = await processStaticBlocks(withView);
   const withDconfig = processDConfigBlocks(withStaticBlock);
     const withEffects = processEffectsBlocks(withDconfig);
-    const withPluginShortcodes = processPluginShortcodes(withEffects);
+    const withPluginShortcodes = await processPluginShortcodes(withEffects);
   const withTabs = processTabsBlocks(withPluginShortcodes);
   const withAccordion = processAccordionBlocks(withTabs);
   const withCarousel = processCarouselBlocks(withAccordion);

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/renderer.js

@@ -312,11 +312,17 @@ export async function renderBlogPage(templatePath, data = {}, seoMeta = {}) {
     const seoDescription = escapeHtml(seoMeta.description ?? site.seo?.defaultDescription ?? '');
     const ogImage = escapeHtml(seoMeta.ogImage ?? '');
 
+    const ogType = escapeHtml(seoMeta.ogType ?? 'website');
     const ogTags = [
         `<meta property="og:title" content="${seoTitle}">`,
         `<meta property="og:description" content="${seoDescription}">`,
-        `<meta property="og:image" content="${ogImage}">`
-    ].join('\n');
+        `<meta property="og:type" content="${ogType}">`,
+        ogImage ? `<meta property="og:image" content="${ogImage}">` : '',
+        `<meta name="twitter:card" content="${ogImage ? 'summary_large_image' : 'summary'}">`,
+        `<meta name="twitter:title" content="${seoTitle}">`,
+        `<meta name="twitter:description" content="${seoDescription}">`,
+        ogImage ? `<meta name="twitter:image" content="${ogImage}">` : ''
+    ].filter(Boolean).join('\n');
 
     const {fontLink, fontOverride} = buildFontVars(site.fontFamily, site.fontSize);
     const fontStyleTag = fontOverride ? `<style>${fontOverride}</style>` : '';
@@ -363,7 +369,7 @@ export async function renderBlogPage(templatePath, data = {}, seoMeta = {}) {
         headInjectLate: [injection.headLate, customCssTag, navbarStyleTag].filter(Boolean).join('\n'),
         bodyEndInject: [
             injection.bodyEnd,
-            (page.usedComponents || [])
+            (seoMeta.usedComponents || [])
                 .map(n => `<script type="module" src="/api/components/${n}.js"></script>`)
                 .join('\n')
         ].filter(Boolean).join('\n'),