domma-cms 0.55.1 → 0.69.3

package/server/services/renderer.js

@@ -11,6 +11,9 @@ import {applyTransforms} from './hooks.js';
 import {resolveLocation, resolveMenuDecorations, resolveOverlaysForPage} from './menus.js';
 import {buildMenuNav} from './menuRender.js';
 import {getProjectForPage} from './projects.js';
+import {resolveContextMenusForPage} from './contextMenus.js';
+import {buildOverrideStyleTag, getThemeTokenMap, listThemeIds, loadThemeConfig} from './themeSettings.js';
+import {getSearchSettings} from './search.js';
 
 const VALID_LAYOUT_WIDTHS = new Set(['narrow', 'normal', 'wide', 'full']);
 const CUSTOM_CSS_PATH = new URL('../../content/custom.css', import.meta.url).pathname;
@@ -34,6 +37,117 @@ async function getTemplate() {
 }
 let _templateCache = null;
 
+/*
+ * Asset version for the public search UI. Bumped by hand when search.js or
+ * search.css changes - the updater replaces public/ wholesale, and a browser
+ * holding the previous file otherwise keeps it.
+ */
+const SEARCH_ASSET_V = '20260920-search';
+
+/**
+ * The public search UI: stylesheet, settings, script.
+ *
+ * Settings travel INSIDE the page rather than being fetched, so the trigger is
+ * there on first paint instead of a round trip later. Every key is public by
+ * design (see SEARCH_DEFAULTS); nothing sensitive belongs in that object.
+ *
+ * Both render paths need this, and wiring one and not the other is the standing
+ * trap in this file - the same one buildThemeView() carries.
+ *
+ * @returns {{headTag: string, bodyTag: string}} Empty strings when search is off
+ */
+function buildSearchAssets() {
+    let settings;
+    try {
+        settings = getSearchSettings();
+    } catch {
+        // A malformed config/search.json is not worth a blank page.
+        return {headTag: '', bodyTag: ''};
+    }
+    if (settings.enabled === false) return {headTag: '', bodyTag: ''};
+
+    const json = JSON.stringify(settings).replace(/<\/script>/gi, '<\\/script>');
+    return {
+        headTag: `<link rel="stylesheet" href="/public/css/search.css?v=${SEARCH_ASSET_V}">`,
+        bodyTag: `<script>window.__CMS_SEARCH__ = ${json};</script>\n`
+            + `<script src="/public/js/search.js?v=${SEARCH_ASSET_V}"></script>`
+    };
+}
+
+const THEME_SWITCHER_ASSET_V = '20260922-ts';
+const ANALYTICS_ASSET_V = '20260922-analytics';
+
+/**
+ * The page-view beacon.
+ *
+ * Always emitted: analytics was a CORE_PLUGINS member, meaning it could not be
+ * switched off, and promotion should not quietly change that. What it counts is
+ * decided in the browser - Do-Not-Track, per-session dedup and preview renders
+ * all opt out there, where the facts are.
+ *
+ * Both render paths, the standing trap in this file.
+ *
+ * @returns {string} the body tag
+ */
+function buildAnalyticsTag() {
+    return `<script src="/public/js/analytics.js?v=${ANALYTICS_ASSET_V}"></script>`;
+}
+
+/**
+ * The public theme switcher: stylesheet, theme list, script.
+ *
+ * The theme LIST is built here from listThemeIds() rather than being written
+ * out anywhere. The plugin this replaced shipped 26 hand-written dots against a
+ * stylesheet carrying 32 themes, and nothing made the gap visible - deriving it
+ * means a theme added to domma-themes.css simply appears.
+ *
+ * Each dot's colours are that theme's own --dm-primary and --dm-secondary, for
+ * the same reason: no second list of colours to drift.
+ *
+ * Both render paths need this, the same standing trap buildThemeView() and
+ * buildSearchAssets() carry.
+ *
+ * @returns {{headTag: string, bodyTag: string}} Empty strings when it is off
+ */
+function buildThemeSwitcherAssets(themeCfg) {
+    const sw = themeCfg?.switcher;
+    if (!sw || sw.enabled !== true) return {headTag: '', bodyTag: ''};
+
+    let ids;
+    try {
+        ids = listThemeIds();
+    } catch {
+        return {headTag: '', bodyTag: ''};
+    }
+    const wanted = Array.isArray(sw.themes) && sw.themes.length
+        ? ids.filter(id => sw.themes.includes(id))
+        : ids;
+    if (!wanted.length) return {headTag: '', bodyTag: ''};
+
+    const themes = wanted.map(id => {
+        const tokens = getThemeTokenMap(id) || {};
+        return {
+            id,
+            label: id.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' '),
+            from: tokens['--dm-primary'] || tokens['--dm-surface'] || '#888',
+            to: tokens['--dm-secondary'] || tokens['--dm-background'] || '#888'
+        };
+    });
+
+    const payload = {
+        position: sw.position || 'right-center',
+        offsetX: sw.offsetX ?? 32,
+        offsetY: sw.offsetY ?? 32,
+        themes
+    };
+    const json = JSON.stringify(payload).replace(/<\/script>/gi, '<\\/script>');
+    return {
+        headTag: `<link rel="stylesheet" href="/public/css/theme-switcher.css?v=${THEME_SWITCHER_ASSET_V}">`,
+        bodyTag: `<script>window.__CMS_THEME_SWITCHER__ = ${json};</script>\n`
+            + `<script src="/public/js/theme-switcher.js?v=${THEME_SWITCHER_ASSET_V}"></script>`
+    };
+}
+
 /**
  * Strip hidden items from the navigation config before public injection.
  * Returns a shallow clone - never mutates the cached config object.
@@ -191,10 +305,10 @@ export async function renderPage(page, opts = {}) {
 
     const breadcrumbsHtml = buildBreadcrumbsHtml(page, site);
 
-    const {fontLink, fontOverride} = buildFontVars(site.fontFamily, site.fontSize);
-    const fontStyleTag = fontOverride
-      ? `<style>${fontOverride}</style>`
-      : '';
+    const themeView = await buildThemeView(page);
+    const searchAssets = buildSearchAssets();
+    const switcherAssets = buildThemeSwitcherAssets(themeView.cfg);
+    const {fontLink, fontStyleTag, autoTheme, activeTheme, dommaTheme, customThemeClass} = themeView;
 
     const {navbarFontLink, navbarStyleTag} = buildNavbarStyleTag(navigation);
 
@@ -202,16 +316,6 @@ export async function renderPage(page, opts = {}) {
         ? `<style>${customCss.replace(/<\/style>/gi, '<\\/style>')}</style>`
         : '';
 
-    const autoTheme = (!page.theme && site.autoTheme?.enabled) ? site.autoTheme : null;
-    const activeTheme = page.theme
-        || (autoTheme ? autoTheme.dayTheme : site.theme)
-        || 'charcoal-dark';
-    // When a custom theme is active, Domma's theme engine must receive the base
-    // built-in theme (which it recognises). The custom override class is added
-    // separately after Domma's init so _applyTheme() cannot strip it.
-    const dommaTheme = site.baseTheme || activeTheme;
-    const customThemeClass = site.baseTheme ? `dm-theme-${activeTheme}` : '';
-
     // Compose window.__CMS_FOOTER__ from the menus mapped to footer-primary / footer-legal.
     const footer = {
         primary:   footerPrimaryDecorated,
@@ -229,6 +333,26 @@ export async function renderPage(page, opts = {}) {
     // counts for something nobody has published.
     const noTrack = !!opts.preview || opts.noTrack === true;
 
+    /*
+     * Authored context menus. Resolved server-side so a visitor only receives
+     * the menus that apply to this page - a menu bound to /shop/* is not in the
+     * source of /about. Domma does the rest in the browser: which menu answers
+     * a given right-click is decided by walking outward from the click, not here.
+     */
+    let ctxMenus = [];
+    try {
+        ctxMenus = await resolveContextMenusForPage(menuCtx);
+    } catch (err) {
+        // A malformed menu file must not take the page down with it.
+        console.warn(`[context-menus] Resolution skipped: ${err.message}`);
+    }
+    const ctxMenusScript = ctxMenus.length
+        ? `window.__CMS_CTXMENUS__ = ${JSON.stringify(ctxMenus).replace(/<\/script>/gi, '<\\/script>')};`
+        : '';
+    const ctxMenusModule = ctxMenus.length
+        ? '<script src="/public/js/context-menus.js?v=20260918-ctx" type="module"></script>'
+        : '';
+
     const vars = {
         previewFlagScript: noTrack ? '<script>window.__CMS_PREVIEW__ = true;</script>' : '',
         seoTitle,
@@ -252,6 +376,8 @@ export async function renderPage(page, opts = {}) {
         showSidebar: preset.sidebar === true || page.sidebar === true,
         navJson: JSON.stringify(filterHiddenNavItems(navigation)).replace(/<\/script>/gi, '<\\/script>'),
         footerScript: footerJson ? `window.__CMS_FOOTER__ = ${footerJson};` : '',
+        ctxMenusScript: ctxMenusScript,
+        ctxMenusModule: ctxMenusModule,
         siteJson: JSON.stringify(Object.assign(
             {
                 title: site.title,
@@ -268,7 +394,11 @@ export async function renderPage(page, opts = {}) {
             autoTheme ? {autoTheme} : {}
         )).replace(/<\/script>/gi, '<\\/script>'),
         headInject: [injection.head, navbarFontLink].filter(Boolean).join('\n'),
-        headInjectLate: [injection.headLate, customCssTag, navbarStyleTag].filter(Boolean).join('\n'),
+        // Theme overrides land BEFORE content/custom.css: the overrides are
+        // generated, custom.css is hand-written, and the hand-written one stays
+        // the last word.
+        headInjectLate: [injection.headLate, searchAssets.headTag, switcherAssets.headTag, themeView.overrideStyleTag, customCssTag, navbarStyleTag]
+            .filter(Boolean).join('\n'),
         bodyEndInject: [
             // Draft banner - first, so it is the topmost fixed element and a
             // floating overlay menu cannot bury the only affordance telling
@@ -279,6 +409,9 @@ export async function renderPage(page, opts = {}) {
             // content flow.
             overlayMenus,
             injection.bodyEnd,
+            searchAssets.bodyTag,
+            switcherAssets.bodyTag,
+            buildAnalyticsTag(),
             site.backToTop?.enabled    ? '<script src="/public/js/btt.js"></script>'             : '',
             site.cookieConsent?.enabled ? '<script src="/public/js/cookie-consent.js"></script>' : '',
             (page.usedComponents || [])
@@ -641,6 +774,46 @@ function fontFamilyValue(family) {
     return `'${safe}', ${generic}`;
 }
 
+/**
+ * The theme facts one render needs.
+ *
+ * config/theme.json is authoritative. The matching site.json keys still exist
+ * as a one-way mirror for plugins and the fleet manager, so reading them here
+ * would make the mirror load-bearing and give the CMS two sources of truth.
+ *
+ * @param {object} page - Page record; `page.theme` still wins over everything.
+ * @returns {Promise<object>} Template vars plus the compiled override stylesheet.
+ */
+async function buildThemeView(page = {}) {
+    const cfg = await loadThemeConfig();
+
+    // A page pinned to a theme opts out of the automatic pair - otherwise the
+    // pin would silently expire at the day/night boundary.
+    const autoTheme = (!page.theme && cfg.autoTheme?.enabled) ? cfg.autoTheme : null;
+    const activeTheme = page.theme
+        || (autoTheme ? autoTheme.dayTheme : cfg.theme)
+        || 'charcoal-dark';
+
+    // A custom (Theme Roller) theme is not a theme Domma's engine knows, so it
+    // receives the built-in base and the custom class rides along separately,
+    // added after init so _applyTheme() cannot strip it.
+    const dommaTheme = cfg.baseTheme || activeTheme;
+    const customThemeClass = cfg.baseTheme ? `dm-theme-${activeTheme}` : '';
+
+    const {fontLink, fontOverride} = buildFontVars(cfg.font?.family, cfg.font?.size);
+
+    return {
+        cfg,
+        autoTheme,
+        activeTheme,
+        dommaTheme,
+        customThemeClass,
+        fontLink,
+        fontStyleTag: fontOverride ? `<style>${fontOverride}</style>` : '',
+        overrideStyleTag: buildOverrideStyleTag(cfg)
+    };
+}
+
 function buildFontVars(fontFamily, fontSize) {
     const PRECONNECT = '<link rel="preconnect" href="https://fonts.googleapis.com">\n    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>';
     const family = fontFamily || 'Roboto';
@@ -753,18 +926,18 @@ export async function renderBlogPage(templatePath, data = {}, seoMeta = {}) {
     };
     const seoTags = buildSeoTags({page: syntheticPage, site, baseUrl, seoTitle, seoDescription, ogImage});
 
-    const {fontLink, fontOverride} = buildFontVars(site.fontFamily, site.fontSize);
-    const fontStyleTag = fontOverride ? `<style>${fontOverride}</style>` : '';
+    // Both render paths resolve the theme the same way. Wiring one and not the
+    // other is the standing trap in this file.
+    const themeView = await buildThemeView({});
+    const searchAssets = buildSearchAssets();
+    const switcherAssets = buildThemeSwitcherAssets(themeView.cfg);
+    const {fontLink, fontStyleTag, activeTheme, dommaTheme, customThemeClass} = themeView;
     const {navbarFontLink, navbarStyleTag} = buildNavbarStyleTag(navigation);
 
     const customCssTag = customCss.trim()
         ? `<style>${customCss.replace(/<\/style>/gi, '<\\/style>')}</style>`
         : '';
 
-    const activeTheme = site.theme || 'charcoal-dark';
-    const dommaTheme = site.baseTheme || activeTheme;
-    const customThemeClass = site.baseTheme ? `dm-theme-${activeTheme}` : '';
-
     // Compose window.__CMS_FOOTER__ from the menus mapped to footer-primary / footer-legal.
     const footer = {
         primary:   footerPrimaryDecorated,
@@ -776,6 +949,26 @@ export async function renderBlogPage(templatePath, data = {}, seoMeta = {}) {
     };
     const footerJson = JSON.stringify(footer).replace(/<\/script>/gi, '<\\/script>');
 
+    /*
+     * Authored context menus. Resolved server-side so a visitor only receives
+     * the menus that apply to this page - a menu bound to /shop/* is not in the
+     * source of /about. Domma does the rest in the browser: which menu answers
+     * a given right-click is decided by walking outward from the click, not here.
+     */
+    let ctxMenus = [];
+    try {
+        ctxMenus = await resolveContextMenusForPage({urlPath: seoMeta.urlPath || '/'});
+    } catch (err) {
+        // A malformed menu file must not take the page down with it.
+        console.warn(`[context-menus] Resolution skipped: ${err.message}`);
+    }
+    const ctxMenusScript = ctxMenus.length
+        ? `window.__CMS_CTXMENUS__ = ${JSON.stringify(ctxMenus).replace(/<\/script>/gi, '<\\/script>')};`
+        : '';
+    const ctxMenusModule = ctxMenus.length
+        ? '<script src="/public/js/context-menus.js?v=20260918-ctx" type="module"></script>'
+        : '';
+
     const vars = {
         seoTitle,
         seoDescription,
@@ -799,6 +992,8 @@ export async function renderBlogPage(templatePath, data = {}, seoMeta = {}) {
         showSidebar: false,
         navJson: JSON.stringify(filterHiddenNavItems(navigation)).replace(/<\/script>/gi, '<\\/script>'),
         footerScript: footerJson ? `window.__CMS_FOOTER__ = ${footerJson};` : '',
+        ctxMenusScript: ctxMenusScript,
+        ctxMenusModule: ctxMenusModule,
         siteJson: JSON.stringify({
             title: site.title,
             footer: site.footer
@@ -810,10 +1005,17 @@ export async function renderBlogPage(templatePath, data = {}, seoMeta = {}) {
             social: site.social || null
         }).replace(/<\/script>/gi, '<\\/script>'),
         headInject: [injection.head, navbarFontLink].filter(Boolean).join('\n'),
-        headInjectLate: [injection.headLate, customCssTag, navbarStyleTag].filter(Boolean).join('\n'),
+        // Theme overrides land BEFORE content/custom.css: the overrides are
+        // generated, custom.css is hand-written, and the hand-written one stays
+        // the last word.
+        headInjectLate: [injection.headLate, searchAssets.headTag, switcherAssets.headTag, themeView.overrideStyleTag, customCssTag, navbarStyleTag]
+            .filter(Boolean).join('\n'),
         bodyEndInject: [
             overlayMenus,
             injection.bodyEnd,
+            searchAssets.bodyTag,
+            switcherAssets.bodyTag,
+            buildAnalyticsTag(),
             (seoMeta.usedComponents || [])
                 .map(n => `<script type="module" src="/api/components/${n}.js"></script>`)
                 .join('\n')

package/server/services/roles.js

@@ -74,7 +74,7 @@ const SEED_ENTRIES = [
             'pages', 'media', 'blocks', 'components', 'navigation', 'menus',
             'projects', 'layouts', 'collections', 'views', 'actions',
             'users', 'settings', 'notifications', 'plugins',
-            'api-tokens', 'api-endpoints'
+            'api-tokens', 'api-endpoints', 'context-menus', 'theme'
         ],
         badgeClass: 'badge-warning'
     },

package/server/services/search-migration.js

@@ -0,0 +1,82 @@
+/**
+ * Search migration - one-shot lift of the retired `site-search` plugin.
+ *
+ * Search used to be a bundled plugin that the loader force-enabled as a core
+ * feature. It is now part of the CMS, which leaves three traces on an existing
+ * install:
+ *
+ *   1. its settings, stored inside config/plugins.json,
+ *   2. its plugins.json entry, which would otherwise offer a toggle for a
+ *      feature that is no longer a plugin,
+ *   3. plugins/site-search/ itself - the updater replaces the plugins it ships
+ *      and adds new ones, but never removes one that has gone away, so the old
+ *      directory sits there and a click in the admin would run a SECOND copy of
+ *      the search UI on every public page.
+ *
+ * Idempotent: with no plugins.json entry and no plugin directory there is
+ * nothing to do, which is the state of every fresh install.
+ */
+import fs from 'fs';
+import path from 'path';
+import {normaliseSearchSettings} from './search.js';
+
+/**
+ * Run the migration.
+ *
+ * Paths are resolved per call rather than at import: the same process can run
+ * this against more than one install (the tests do), and a path frozen at load
+ * time would point at the first one forever.
+ *
+ * @returns {string[]} What it changed, for the startup log (empty = nothing to do)
+ */
+export function migrateSiteSearchPlugin() {
+    const CONFIG_DIR = path.resolve('config');
+    const SEARCH_CONFIG = path.join(CONFIG_DIR, 'search.json');
+    const PLUGINS_CONFIG = path.join(CONFIG_DIR, 'plugins.json');
+    const RETIRED_PLUGIN_DIR = path.resolve('plugins', 'site-search');
+
+    const changes = [];
+    let plugins = null;
+
+    try {
+        plugins = JSON.parse(fs.readFileSync(PLUGINS_CONFIG, 'utf8'));
+    } catch {
+        // No plugins.json, or a malformed one. Neither is this migration's
+        // business - a broken file is reported loudly elsewhere.
+    }
+
+    const stored = plugins?.['site-search'];
+
+    // 1. Settings. Only ever written when the file is absent: a site that has
+    //    already saved search settings has the newer answer.
+    if (!fs.existsSync(SEARCH_CONFIG)) {
+        const settings = normaliseSearchSettings(stored?.settings || {});
+        fs.writeFileSync(SEARCH_CONFIG, JSON.stringify(settings, null, 2) + '\n');
+        changes.push(stored ? 'lifted settings out of plugins.json' : 'wrote default settings');
+    }
+
+    // 2. The plugins.json entry.
+    if (plugins && stored) {
+        delete plugins['site-search'];
+        fs.writeFileSync(PLUGINS_CONFIG, JSON.stringify(plugins, null, 2) + '\n');
+        changes.push('removed the plugins.json entry');
+    }
+
+    // 3. The plugin directory - but only if it is the bundled one. A directory
+    //    of that name carrying anything else is somebody's own work, and this
+    //    is no place to decide it should go.
+    if (fs.existsSync(RETIRED_PLUGIN_DIR)) {
+        let isBundled = false;
+        try {
+            const manifest = JSON.parse(fs.readFileSync(path.join(RETIRED_PLUGIN_DIR, 'plugin.json'), 'utf8'));
+            isBundled = manifest.name === 'site-search' && manifest.author === 'Darryl Waterhouse';
+        } catch { /* no manifest - leave it alone */ }
+
+        if (isBundled) {
+            fs.rmSync(RETIRED_PLUGIN_DIR, {recursive: true, force: true});
+            changes.push('removed plugins/site-search/');
+        }
+    }
+
+    return changes;
+}