domma-cms 0.16.0 → 0.17.0

package/server/services/email.js

@@ -4,6 +4,32 @@
  */
 import nodemailer from 'nodemailer';
 
+let lastSendResult = null;
+
+/**
+ * Return the most recent email send result, or null if no send has occurred.
+ *
+ * @returns {{ ok: boolean, at: string, info: string|null } | null}
+ */
+export function getLastSendResult() {
+    return lastSendResult;
+}
+
+/**
+ * Record the outcome of an email send for health reporting.
+ *
+ * @param {boolean} ok
+ * @param {string|null} info
+ * @returns {void}
+ */
+function recordSendResult(ok, info) {
+    lastSendResult = {
+        ok,
+        at: new Date().toISOString(),
+        info: info || null
+    };
+}
+
 /**
  * Escape HTML special characters for safe use in email bodies.
  *
@@ -58,17 +84,24 @@ export async function createTransport(smtp) {
  * @throws {Error} If sending the email fails.
  */
 export async function sendEmail(transport, {from, fromName, to, subject, html, text}) {
-    const info = await transport.sendMail({
-        from: `"${fromName}" <${from}>`,
-        to,
-        subject,
-        text,
-        html
-    });
+    try {
+        const info = await transport.sendMail({
+            from: `"${fromName}" <${from}>`,
+            to,
+            subject,
+            text,
+            html
+        });
+        recordSendResult(true, info.messageId);
 
-    const previewUrl = nodemailer.getTestMessageUrl(info);
-    if (previewUrl) {
-        console.log('[email] Preview URL:', previewUrl);
+        const previewUrl = nodemailer.getTestMessageUrl(info);
+        if (previewUrl) {
+            console.log('[email] Preview URL:', previewUrl);
+        }
+        return info;
+    } catch (err) {
+        recordSendResult(false, err.message);
+        throw err;
     }
 }
 
@@ -112,16 +145,23 @@ export async function sendFormEmail(transport, { from, fromName, to, subject, fo
 
     const text = `New form submission: ${formTitle}\n\n${plainRows}`;
 
-    const info = await transport.sendMail({
-        from: `"${fromName}" <${from}>`,
-        to,
-        subject,
-        text,
-        html
-    });
+    try {
+        const info = await transport.sendMail({
+            from: `"${fromName}" <${from}>`,
+            to,
+            subject,
+            text,
+            html
+        });
+        recordSendResult(true, info.messageId);
 
-    const previewUrl = nodemailer.getTestMessageUrl(info);
-    if (previewUrl) {
-        console.log('[email] Preview URL:', previewUrl);
+        const previewUrl = nodemailer.getTestMessageUrl(info);
+        if (previewUrl) {
+            console.log('[email] Preview URL:', previewUrl);
+        }
+        return info;
+    } catch (err) {
+        recordSendResult(false, err.message);
+        throw err;
     }
 }

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/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);
         }
     }