domma-cms 0.54.2 → 0.66.0

package/server/services/contextMenus.js

@@ -0,0 +1,477 @@
+/**
+ * Context menus - right-click menus bound to a region of a page.
+ *
+ * Deliberately NOT part of the menu system. A nav menu renders into a named
+ * slot and has a server render path; a context menu has neither. It binds to a
+ * CSS selector, exists only in the browser, and is resolved at right-click time
+ * by Domma walking outward from the clicked element. So `resolveLocation` and
+ * `buildMenuNav` are not reused here - see the domma-menus skill, which says as
+ * much.
+ *
+ * What IS reused is `binding`, in exactly the shape menus already use, so
+ * per-page and per-project scoping behaves identically and editors only learn
+ * it once.
+ *
+ * Storage mirrors menus: one file per menu under config/context-menus/.
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import {fileURLToPath} from 'url';
+import * as cache from './cache/index.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CONFIG_DIR = path.resolve(__dirname, '..', '..', 'config');
+const CTX_DIR = path.join(CONFIG_DIR, 'context-menus');
+
+const SLUG_RE = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+
+/** Cached index, invalidated on every write. Mirrors getAllMenus(). */
+let _index = null;
+
+export function invalidateContextMenuIndex() {
+    _index = null;
+}
+
+/**
+ * Drop every cached page so an edited menu reaches the front end.
+ *
+ * `site` is the tag to use: routes/public.js stores each page under
+ * [`page:<urlPath>`, ...page.cacheTags, 'nav', 'site'], so `site` is the only
+ * one that covers all of them, and a context menu can apply to any page.
+ *
+ * This was two bugs in one line. It called `invalidateTag` (singular), which
+ * the cache module does not export, and it passed 'pages', which nothing is
+ * ever tagged with - so even the corrected call would have matched nothing.
+ * The catch swallowed the TypeError, and because the cache is off in dev and
+ * on in production, editing a menu worked locally and did nothing live for an
+ * hour. Failures are logged now: "the cache is optional" is a reason to carry
+ * on after a cache error, not a reason to hide one.
+ */
+async function invalidatePageCache() {
+    try {
+        await cache.invalidateTags(['site']);
+    } catch (err) {
+        console.warn(`[context-menus] Page cache not invalidated: ${err.message}`);
+    }
+}
+
+export function validateSlug(slug) {
+    return typeof slug === 'string' && slug.length <= 64 && SLUG_RE.test(slug);
+}
+
+export async function ensureContextMenusDir() {
+    await fs.mkdir(CTX_DIR, {recursive: true});
+}
+
+function ctxPath(slug) {
+    return path.join(CTX_DIR, `${slug}.json`);
+}
+
+async function readCtxFile(slug) {
+    return JSON.parse(await fs.readFile(ctxPath(slug), 'utf8'));
+}
+
+async function writeCtxFile(menu) {
+    await ensureContextMenusDir();
+    await fs.writeFile(ctxPath(menu.slug), JSON.stringify(menu, null, 2) + '\n', 'utf8');
+    invalidateContextMenuIndex();
+    await invalidatePageCache();
+}
+
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+
+const INHERIT = new Set(['append', 'prepend', false]);
+const TRANSITIONS = new Set(['scale', 'fade', 'slide', 'none']);
+const DENSITIES = new Set(['comfortable', 'compact']);
+const SCALE = new Set(['none', 'sm', 'md', 'lg', 'xl']);
+const ACCENTS = new Set(['primary', 'success', 'danger', 'warning', 'info']);
+const HEX_RE = /^#[0-9a-fA-F]{6}$/;
+
+/*
+ * Action types an authored item may carry. Arbitrary JavaScript is deliberately
+ * not one of them: admin/ is replaced wholesale by the updater, so anything an
+ * editor pasted would be lost on the next update, and a stored script running
+ * on public pages is a cross-site scripting hole with extra steps. Anything
+ * bespoke goes through `run-action`, which names an Actions artefact that has
+ * its own permissions.
+ */
+export const ACTION_TYPES = new Set([
+    'navigate',      // {url}
+    'filter',        // {field, op, value} - collection displays
+    'search',        // opens the display's search
+    'sort',          // {field, dir}
+    'export',        // {format}
+    'copy-link',
+    'print',
+    'open-modal',    // {block} - renders a block into a modal
+    'run-action',    // {slug} - an Actions artefact
+    'mark-as-spam',  // {field} - flags the clicked entry, default field `spam`
+
+    /*
+     * Specials - the things a browser's own context menu offers. They take no
+     * arguments and each decides for itself whether it applies to the click:
+     * back greys out with no history behind it, paste unless the click landed
+     * in something editable. That is `disabled` rather than hidden, so the menu
+     * keeps a stable shape and reads the way a native one does.
+     */
+    'reload',
+    'back',
+    'forward',
+    'copy',          // the current selection
+    'cut',
+    'paste',
+    'select-all',
+    'site-search'    // opens the public search overlay (public/js/search.js)
+]);
+
+const ITEM_TYPES = new Set(['item', 'divider', 'header', 'checkbox', 'radio']);
+
+/*
+ * A selector an editor types is applied with querySelector at right-click time.
+ * These are the ones that would bind the menu to the entire document and make
+ * every other menu on the page unreachable - a mistake that looks like "context
+ * menus are broken" rather than like a typo.
+ */
+const FORBIDDEN_SELECTORS = new Set(['*', 'html', 'body', ':root', 'head']);
+
+function isPlainObject(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+/**
+ * Validate a context menu. Returns an array of human-readable errors; empty
+ * means valid. Mirrors validateMenu()'s contract so the routes handle both the
+ * same way.
+ *
+ * @param   {object} menu
+ * @returns {string[]}
+ */
+export function validateContextMenu(menu) {
+    const errors = [];
+
+    if (!isPlainObject(menu)) return ['Context menu must be an object'];
+    if (!validateSlug(menu.slug)) errors.push(`Invalid slug: ${menu.slug}`);
+    if (!menu.name || typeof menu.name !== 'string') errors.push('Name is required');
+
+    // --- target ---
+    const t = menu.target;
+    if (!isPlainObject(t)) {
+        errors.push('target is required');
+    } else {
+        if (!t.selector || typeof t.selector !== 'string') {
+            errors.push('target.selector is required');
+        } else {
+            const sel = t.selector.trim();
+            if (FORBIDDEN_SELECTORS.has(sel.toLowerCase())) {
+                errors.push(`target.selector "${sel}" would bind the whole page`);
+            }
+            for (const key of ['selector', 'match', 'exclude']) {
+                const v = t[key];
+                if (v === undefined || v === null || v === '') continue;
+                if (typeof v !== 'string') { errors.push(`target.${key} must be a string`); continue; }
+                try {
+                    document?.querySelector?.(v);
+                } catch { /* no DOM on the server - checked below instead */ }
+                // Cheap structural check: a selector with unbalanced brackets is
+                // a typo that would otherwise throw inside the visitor's browser.
+                const balanced = (a, b) => (v.split(a).length === v.split(b).length);
+                if (!balanced('[', ']') || !balanced('(', ')')) {
+                    errors.push(`target.${key} is not a valid selector: ${v}`);
+                }
+            }
+        }
+    }
+
+    // --- cascade ---
+    if (menu.inherit !== undefined && !INHERIT.has(menu.inherit)) {
+        errors.push('inherit must be "append", "prepend" or false');
+    }
+    if (menu.priority !== undefined && !Number.isInteger(menu.priority)) {
+        errors.push('priority must be an integer');
+    }
+
+    // --- theme ---
+    const th = menu.theme;
+    if (th !== undefined) {
+        if (!isPlainObject(th)) {
+            errors.push('theme must be an object');
+        } else {
+            if (th.accent && !ACCENTS.has(th.accent) && !HEX_RE.test(th.accent)) {
+                errors.push(`theme.accent must be a preset key or #rrggbb: ${th.accent}`);
+            }
+            for (const key of ['radius', 'shadow']) {
+                if (th[key] && !SCALE.has(th[key])) {
+                    errors.push(`theme.${key} must be one of none, sm, md, lg, xl`);
+                }
+            }
+            if (th.density && !DENSITIES.has(th.density)) {
+                errors.push('theme.density must be "comfortable" or "compact"');
+            }
+            if (th.transition && !TRANSITIONS.has(th.transition)) {
+                errors.push('theme.transition must be scale, fade, slide or none');
+            }
+            if (th.opacity !== undefined && th.opacity !== null) {
+                const n = Number(th.opacity);
+                if (!Number.isFinite(n) || n < 20 || n > 100) {
+                    errors.push('theme.opacity must be between 20 and 100');
+                }
+            }
+        }
+    }
+
+    // --- items ---
+    if (!Array.isArray(menu.items)) {
+        errors.push('items must be an array');
+    } else {
+        validateItems(menu.items, errors, 'items');
+        const usable = menu.items.filter(
+            (i) => isPlainObject(i) && !['divider', 'header'].includes(i.type)
+        );
+        if (!usable.length) {
+            errors.push('A menu needs at least one item that is not a divider or header');
+        }
+    }
+
+    return errors;
+}
+
+function validateItems(items, errors, trail, depth = 0) {
+    if (depth > 4) { errors.push(`${trail}: submenus nested more than 4 deep`); return; }
+
+    items.forEach((item, i) => {
+        const at = `${trail}[${i}]`;
+        if (!isPlainObject(item)) { errors.push(`${at} must be an object`); return; }
+
+        const type = item.type || 'item';
+        if (!ITEM_TYPES.has(type)) { errors.push(`${at}.type "${type}" is not recognised`); return; }
+        if (type === 'divider') return;
+        if (!item.text || typeof item.text !== 'string') errors.push(`${at}.text is required`);
+        if (type === 'header') return;
+
+        const hasSub = Array.isArray(item.submenu) && item.submenu.length;
+        if (hasSub) {
+            validateItems(item.submenu, errors, `${at}.submenu`, depth + 1);
+            return;   // a parent carries its children, not an action
+        }
+
+        const a = item.action;
+        if (!isPlainObject(a)) {
+            errors.push(`${at}.action is required (or give it a submenu)`);
+        } else if (!ACTION_TYPES.has(a.type)) {
+            errors.push(`${at}.action.type "${a.type}" is not recognised`);
+        } else {
+            if (a.type === 'navigate' && !a.url) errors.push(`${at}.action.url is required`);
+            if (a.type === 'run-action' && !a.slug) errors.push(`${at}.action.slug is required`);
+            if (a.type === 'open-modal' && !a.block) errors.push(`${at}.action.block is required`);
+        }
+    });
+}
+
+function normaliseBinding(binding) {
+    if (!isPlainObject(binding)) return undefined;
+    const out = {};
+    if (Array.isArray(binding.projects)) out.projects = binding.projects.filter((p) => typeof p === 'string');
+    if (Array.isArray(binding.pages)) out.pages = binding.pages.filter((p) => typeof p === 'string');
+    return (out.projects?.length || out.pages?.length) ? out : undefined;
+}
+
+function shape(input) {
+    const menu = {
+        slug: input.slug,
+        name: input.name,
+        description: input.description || '',
+        enabled: input.enabled !== false,
+        target: {
+            selector: String(input.target?.selector || '').trim(),
+            ...(input.target?.match && {match: String(input.target.match).trim()}),
+            ...(input.target?.exclude && {exclude: String(input.target.exclude).trim()})
+        },
+        inherit: input.inherit === undefined ? 'append' : input.inherit,
+        ...(Number.isInteger(input.priority) && input.priority !== 0 && {priority: input.priority}),
+        ...(isPlainObject(input.theme) && Object.keys(input.theme).length && {theme: input.theme}),
+        items: Array.isArray(input.items) ? input.items : []
+    };
+    const binding = normaliseBinding(input.binding);
+    if (binding) menu.binding = binding;
+    if (isPlainObject(input.meta) && Object.keys(input.meta).length) menu.meta = input.meta;
+    return menu;
+}
+
+// ---------------------------------------------------------------------------
+// CRUD
+// ---------------------------------------------------------------------------
+
+/** List all context menus, metadata only. Sorted by slug. */
+export async function listContextMenus() {
+    await ensureContextMenusDir();
+    const files = await fs.readdir(CTX_DIR);
+    const out = [];
+    for (const file of files) {
+        if (!file.endsWith('.json')) continue;
+        const slug = file.slice(0, -5);
+        if (!validateSlug(slug)) continue;
+        try {
+            const menu = await readCtxFile(slug);
+            out.push({
+                slug:        menu.slug || slug,
+                name:        menu.name || '',
+                description: menu.description || '',
+                enabled:     menu.enabled !== false,
+                selector:    menu.target?.selector || '',
+                match:       menu.target?.match || '',
+                itemsCount:  Array.isArray(menu.items) ? menu.items.length : 0,
+                ...(menu.binding && {binding: menu.binding}),
+                meta:        menu.meta || {}
+            });
+        } catch (err) {
+            console.warn(`[context-menus] Skipping malformed menu "${slug}": ${err.message}`);
+        }
+    }
+    return out.sort((a, b) => a.slug.localeCompare(b.slug));
+}
+
+/** Every menu in full, cached in-process. Used by the page resolver. */
+export async function getAllContextMenus() {
+    if (_index) return _index;
+    await ensureContextMenusDir();
+    const files = await fs.readdir(CTX_DIR);
+    const out = [];
+    for (const file of files) {
+        if (!file.endsWith('.json')) continue;
+        const slug = file.slice(0, -5);
+        if (!validateSlug(slug)) continue;
+        try {
+            out.push(await readCtxFile(slug));
+        } catch { /* listContextMenus() already warns */ }
+    }
+    _index = out;
+    return out;
+}
+
+export async function getContextMenu(slug) {
+    if (!validateSlug(slug)) return null;
+    try {
+        return await readCtxFile(slug);
+    } catch (err) {
+        if (err.code === 'ENOENT') return null;
+        throw err;
+    }
+}
+
+export async function createContextMenu(input) {
+    if (!validateSlug(input?.slug)) throw new Error(`Invalid slug: ${input?.slug}`);
+    if (await getContextMenu(input.slug)) throw new Error(`Context menu "${input.slug}" already exists`);
+
+    const menu = shape(input);
+    const errors = validateContextMenu(menu);
+    if (errors.length) throw new Error(errors.join('; '));
+
+    await writeCtxFile(menu);
+    return menu;
+}
+
+export async function updateContextMenu(slug, input) {
+    const existing = await getContextMenu(slug);
+    if (!existing) throw new Error(`Context menu "${slug}" not found`);
+
+    // The slug is the filename and the identity; renaming is a delete plus a
+    // create, not an edit.
+    const menu = shape({...existing, ...input, slug});
+    const errors = validateContextMenu(menu);
+    if (errors.length) throw new Error(errors.join('; '));
+
+    await writeCtxFile(menu);
+    return menu;
+}
+
+export async function deleteContextMenu(slug) {
+    if (!validateSlug(slug)) throw new Error(`Invalid slug: ${slug}`);
+    try {
+        await fs.unlink(ctxPath(slug));
+    } catch (err) {
+        if (err.code === 'ENOENT') throw new Error(`Context menu "${slug}" not found`);
+        throw err;
+    }
+    invalidateContextMenuIndex();
+    await invalidatePageCache();
+    return true;
+}
+
+export async function duplicateContextMenu(slug) {
+    const source = await getContextMenu(slug);
+    if (!source) throw new Error(`Context menu "${slug}" not found`);
+
+    let candidate = `${slug}-copy`;
+    let n = 2;
+    while (await getContextMenu(candidate)) candidate = `${slug}-copy-${n++}`;
+
+    return createContextMenu({...source, slug: candidate, name: `${source.name} (copy)`});
+}
+
+// ---------------------------------------------------------------------------
+// Page resolution
+// ---------------------------------------------------------------------------
+
+/** `/shop/*` matches `/shop/thing`; an exact path matches itself. */
+function matchesPage(pattern, urlPath) {
+    if (!pattern || !urlPath) return false;
+    if (pattern === urlPath) return true;
+    if (pattern.endsWith('/*')) return urlPath.startsWith(pattern.slice(0, -1));
+    return false;
+}
+
+/**
+ * Every context menu that applies to a page.
+ *
+ * Unlike a slot, this is NOT one-menu-wins: several can apply at once and
+ * Domma decides which answers a given right-click by walking outward from the
+ * click. That is the same resolution the `overlay` slot uses, one level down -
+ * region rather than slot.
+ *
+ * A menu with no binding is site-wide. A menu with a binding applies only where
+ * it matches, so binding is a narrowing, never a widening.
+ *
+ * @param   {{urlPath?: string, project?: string}} ctx
+ * @returns {Promise<object[]>} payloads for the browser, in binding order
+ */
+export async function resolveContextMenusForPage(ctx = {}) {
+    const all = await getAllContextMenus();
+    const {urlPath, project} = ctx;
+
+    const applies = all.filter((menu) => {
+        if (menu.enabled === false) return false;
+        const b = menu.binding;
+        if (!b) return true;                       // site-wide
+        if (b.pages?.length && urlPath && b.pages.some((p) => matchesPage(p, urlPath))) return true;
+        if (b.projects?.length && project && b.projects.includes(project)) return true;
+        return false;
+    });
+
+    /*
+     * A bound menu is more specific than a site-wide one, so it is sent later:
+     * where two menus bind the same element Domma breaks the tie on `priority`
+     * and then on registration order, and the more specific one should win.
+     */
+    applies.sort((a, b) => Number(Boolean(a.binding)) - Number(Boolean(b.binding)));
+
+    return applies.map(toClientPayload);
+}
+
+/**
+ * The browser needs the binding and the items, not the editor's metadata.
+ * Keeping the payload narrow also keeps it out of the page source for menus a
+ * visitor cannot use.
+ */
+export function toClientPayload(menu) {
+    return {
+        slug: menu.slug,
+        target: menu.target,
+        inherit: menu.inherit === undefined ? 'append' : menu.inherit,
+        ...(menu.priority && {priority: menu.priority}),
+        ...(menu.theme && {theme: menu.theme}),
+        items: menu.items || []
+    };
+}

package/server/services/email.js

@@ -45,6 +45,21 @@ export function escapeHtml(str) {
         .replace(/'/g, ''');
 }
 
+/**
+ * Does this site have somewhere real to send mail?
+ *
+ * The host is the only field that decides it: everything else has a usable
+ * default, and an empty host is what sends the whole site to Ethereal. Shared
+ * with the health check and the admin so all three agree on what "configured"
+ * means.
+ *
+ * @param   {{host?: string}} smtp
+ * @returns {boolean}
+ */
+export function isSmtpConfigured(smtp) {
+    return typeof smtp?.host === 'string' && smtp.host.trim() !== '';
+}
+
 /**
  * Create a nodemailer transport.
  * Falls back to an Ethereal test account when no SMTP host is configured.
@@ -54,7 +69,7 @@ export function escapeHtml(str) {
  * @throws {Error} If Ethereal test account creation fails.
  */
 export async function createTransport(smtp) {
-    if (smtp?.host) {
+    if (isSmtpConfigured(smtp)) {
         return nodemailer.createTransport({
             host: smtp.host,
             port: smtp.port || 587,
@@ -64,9 +79,20 @@ export async function createTransport(smtp) {
         });
     }
 
-    // No SMTP configured - use Ethereal for dev/demo
+    // No SMTP configured - use Ethereal for dev/demo.
+    //
+    // This is the quiet failure mode of the whole email feature: Ethereal
+    // accepts the message, nodemailer reports success, the health check records
+    // a good send, and nothing is delivered to anyone. Password resets and form
+    // notifications all "work". Say so at warn level rather than as a friendly
+    // info line, and say it in terms of the consequence - the admin carries the
+    // same warning on the Email tab, and checkSmtpConfig() surfaces it in
+    // Health. A site scaffolded by the CLI or the fleet manager ships with a
+    // host precisely so it never lands here.
     const testAccount = await nodemailer.createTestAccount();
-    console.log('[email] No SMTP configured. Using Ethereal test account:', testAccount.user);
+    console.warn('[email] NO SMTP HOST CONFIGURED - mail is going to an Ethereal test inbox '
+        + 'and will NOT reach its recipients. Set one in Settings > Email. '
+        + 'Ethereal account: ' + testAccount.user);
     return nodemailer.createTransport({
         host: 'smtp.ethereal.email',
         port: 587,

package/server/services/health.js

@@ -6,8 +6,8 @@
 import fs from 'fs/promises';
 import path from 'path';
 import {fileURLToPath} from 'url';
-import {config} from '../config.js';
-import {getLastSendResult} from './email.js';
+import {config, getConfig} from '../config.js';
+import {getLastSendResult, isSmtpConfigured} from './email.js';
 import {listPages} from './content.js';
 import {getPluginLoadFailures} from './plugins.js';
 import {FORMS_DIR} from './forms.js';
@@ -203,6 +203,26 @@ async function checkSmtp() {
     };
 }
 
+// Distinct from checkSmtp above, which reports the LAST SEND. That check goes
+// green on an Ethereal send, because as far as nodemailer is concerned the
+// message was accepted - so on a site with no relay the two checks disagree on
+// purpose: "last email send: ok" next to "SMTP host: not configured" is the
+// whole story, and neither half tells it alone.
+async function checkSmtpConfig() {
+    const smtp = getConfig('site')?.smtp;
+    if (isSmtpConfigured(smtp)) {
+        return { id: 'smtp-config', level: 'ok', label: 'SMTP host', value: smtp.host };
+    }
+    return {
+        id: 'smtp-config',
+        level: 'warn',
+        label: 'SMTP host',
+        value: 'not configured',
+        detail: ['Mail is going to an Ethereal test inbox and will not reach its recipients.',
+                 'Set a host in Settings > Email.']
+    };
+}
+
 async function checkPluginLoad() {
     const failures = getPluginLoadFailures();
     return {
@@ -265,6 +285,7 @@ export async function getHealth() {
         safeCheck('missing-meta', checkMissingMeta),
         safeCheck('last-form',    checkLastForm),
         safeCheck('smtp',         checkSmtp),
+        safeCheck('smtp-config',  checkSmtpConfig),
         safeCheck('plugin-load',  checkPluginLoad)
     ]);
     const value = { status: worstLevel(checks), checks };