domma-cms 0.116.8 → 0.118.0

package/server/services/pagePublishing.js

@@ -0,0 +1,85 @@
+/**
+ * Page publishing - may this viewer see this page?
+ *
+ * The one implementation of the public page access decision. The public site
+ * (routes/public.js) calls it, and so will the Content API, so a page
+ * reachable over the API is reachable on the site by the same viewer and the
+ * reverse. It decides; it never replies or renders.
+ *
+ * Order matters and matches what the site has always done:
+ *   1. the page (with the directory-index fallback)
+ *   2. its project's kill-switch - a disabled project is a 404, no oracle
+ *   3. drafts - anything not `published` is a 404 unless drafts are allowed
+ *      AND the viewer holds pages.read
+ *   4. visibility - checkVisibility(), the ladder / `=role` rule
+ */
+import {getPage} from './content.js';
+import {getProjectForPage, isProjectEnabled} from './projects.js';
+import {checkVisibility} from '../middleware/auth.js';
+import {getPermissionsFor} from './roles.js';
+import {getEffectiveRoles} from './userRoles.js';
+
+/**
+ * Does a visibility value let everyone in? Missing, 'public', an empty array,
+ * or an array containing 'public'.
+ *
+ * @param {string|string[]|undefined} vis
+ * @returns {boolean}
+ */
+export function isEffectivelyPublic(vis) {
+    return !vis
+        || vis === 'public'
+        || (Array.isArray(vis) && (vis.length === 0 || vis.includes('public')));
+}
+
+/**
+ * May this viewer see unpublished pages?
+ *
+ * Gated on `pages.read` - the same permission that opens the Pages list in the
+ * admin. Anyone who can already read the draft's source there loses nothing by
+ * seeing it rendered, and nobody else gains anything.
+ *
+ * @param {object|null} user - Resolved viewer (`{role, additionalRoles}`) or null
+ * @returns {boolean}
+ */
+export function canPreviewDrafts(user) {
+    if (!user) return false;
+    const allowed = getPermissionsFor('pages', 'read');
+    return getEffectiveRoles(user).some(role => allowed.includes(role));
+}
+
+/**
+ * The page is fetched anonymously: the verdict needs only its metadata. A
+ * caller rendering the body for a signed-in viewer re-fetches it with
+ * `getPage(page.urlPath, {user})` so `[menu]` and row-scoped `[view]` see them.
+ *
+ * A `forbidden` verdict carries no page, so nothing downstream can render it
+ * by mistake.
+ *
+ * @param {string} urlPath - '/about', '/services', '/'
+ * @param {object|null} viewer - resolveViewer() result, a JWT user, or null
+ * @param {{allowDrafts?: boolean}} [opts]
+ * @returns {Promise<
+ *   {status: 'ok', page: object, project: string, isDraft: boolean, isPublic: boolean} |
+ *   {status: 'not-found'} |
+ *   {status: 'forbidden'}
+ * >}
+ */
+export async function resolvePublishedPage(urlPath, viewer, {allowDrafts = false} = {}) {
+    let page = await getPage(urlPath);
+    if (!page && !urlPath.endsWith('/index')) {
+        page = await getPage(urlPath.replace(/\/$/, '') || '/');
+    }
+    if (!page) return {status: 'not-found'};
+
+    const project = await getProjectForPage(page.urlPath || urlPath, page.project);
+    if (!(await isProjectEnabled(project))) return {status: 'not-found'};
+
+    const isDraft = page.status !== 'published';
+    if (isDraft && !(allowDrafts && canPreviewDrafts(viewer))) return {status: 'not-found'};
+
+    const isPublic = isEffectivelyPublic(page.visibility);
+    if (!isPublic && !checkVisibility(viewer, page.visibility)) return {status: 'forbidden'};
+
+    return {status: 'ok', page, project, isDraft, isPublic};
+}

package/server/services/permissionRegistry.js

@@ -314,7 +314,7 @@ export const REGISTRY = [
     {
         key: 'api-tokens',
         label: 'API Tokens',
-        description: 'Manage project-scoped tokens for the external collections API.',
+        description: 'Manage project-scoped tokens for the external collections API and the Content API.',
         icon: 'key',
         group: 'Configuration',
         actions: [

package/server/services/renderer.js

@@ -266,6 +266,8 @@ export async function renderPage(page, opts = {}) {
             // Item highlighting: the navbar is built in the browser, so the
             // config has to travel to site.js rather than being rendered here.
             ...(navMenu.highlight && {highlight: navMenu.highlight}),
+            // Designer classes for the navbar element itself (site.js adds them).
+            ...(navMenu.class && {class: navMenu.class}),
             ...(navMenu.style && {style: navMenu.style})
         }
         : (await readLegacyNavBackup()) || {brand: site.brand || {}, items: []};
@@ -333,7 +335,10 @@ export async function renderPage(page, opts = {}) {
         copyright: site.footer?.copyright || '',
         // Highlighting is per menu, and the two footer columns are two menus.
         ...(footerPrimary?.highlight && {primaryHighlight: footerPrimary.highlight}),
-        ...(footerLegal?.highlight   && {legalHighlight:   footerLegal.highlight})
+        ...(footerLegal?.highlight   && {legalHighlight:   footerLegal.highlight}),
+        // Each column's menu-level designer classes, for its <nav>.
+        ...(footerPrimary?.class && {primaryClass: footerPrimary.class}),
+        ...(footerLegal?.class   && {legalClass:   footerLegal.class})
     };
     const footerJson = JSON.stringify(footer).replace(/<\/script>/gi, '<\\/script>');
 
@@ -993,6 +998,8 @@ export async function renderBlogPage(templatePath, data = {}, seoMeta = {}) {
             // Item highlighting: the navbar is built in the browser, so the
             // config has to travel to site.js rather than being rendered here.
             ...(navMenu.highlight && {highlight: navMenu.highlight}),
+            // Designer classes for the navbar element itself (site.js adds them).
+            ...(navMenu.class && {class: navMenu.class}),
             ...(navMenu.style && {style: navMenu.style})
         }
         : (await readLegacyNavBackup()) || {brand: site.brand || {}, items: []};
@@ -1048,7 +1055,10 @@ export async function renderBlogPage(templatePath, data = {}, seoMeta = {}) {
         copyright: site.footer?.copyright || '',
         // Highlighting is per menu, and the two footer columns are two menus.
         ...(footerPrimary?.highlight && {primaryHighlight: footerPrimary.highlight}),
-        ...(footerLegal?.highlight   && {legalHighlight:   footerLegal.highlight})
+        ...(footerLegal?.highlight   && {legalHighlight:   footerLegal.highlight}),
+        // Each column's menu-level designer classes, for its <nav>.
+        ...(footerPrimary?.class && {primaryClass: footerPrimary.class}),
+        ...(footerLegal?.class   && {legalClass:   footerLegal.class})
     };
     const footerJson = JSON.stringify(footer).replace(/<\/script>/gi, '<\\/script>');
 

package/server/services/search.js

@@ -457,25 +457,43 @@ export function isOffline(page, exclusions = null) {
 }
 
 /**
- * May this page appear in this viewer's search results? Drafts never; pages
- * in a disabled project never; pages that ask not to be indexed (frontmatter
- * or the SEO screen) never; otherwise exactly when the viewer could open the
- * page - checkVisibility() is the one visibility rule, the same the public
- * page renderer applies, so a role-gated page (`member`, `=candidate`,
- * `private`) is found only by someone it would be served to.
+ * Could this viewer open this page from a list? Published, in an enabled
+ * project, and visible to them. Site search and the Content API's page list
+ * share it; noindex is search's own business and is not part of it.
+ *
+ * `status !== 'published'`, not `=== 'draft'`: the public route has always
+ * 404ed every unpublished status, and search used to find a `scheduled` or
+ * status-less page that then 404ed.
+ *
+ * checkVisibility() is the one visibility rule, the same the public page
+ * renderer applies, so a role-gated page (`member`, `=candidate`, `private`)
+ * is listed only for someone it would be served to.
  *
  * @param {object} page
  * @param {object|null} [viewer] - resolved viewer, null for anonymous
  * @param {{offline?: Set<string>, noindex?: Set<string>}|null} [exclusions] - searchExclusions()
  * @returns {boolean}
  */
-export function isSearchable(page, viewer = null, exclusions = null) {
-    if (!page || page.status === 'draft') return false;
+export function isPubliclyListed(page, viewer = null, exclusions = null) {
+    if (!page || page.status !== 'published') return false;
     if (isOffline(page, exclusions)) return false;
-    if (isNoindex(page, exclusions)) return false;
     return checkVisibility(viewer, page.visibility);
 }
 
+/**
+ * May this page appear in this viewer's search results? Exactly when it is
+ * publicly listed for them (isPubliclyListed) and does not ask not to be
+ * indexed (frontmatter or the SEO screen).
+ *
+ * @param {object} page
+ * @param {object|null} [viewer] - resolved viewer, null for anonymous
+ * @param {{offline?: Set<string>, noindex?: Set<string>}|null} [exclusions] - searchExclusions()
+ * @returns {boolean}
+ */
+export function isSearchable(page, viewer = null, exclusions = null) {
+    return isPubliclyListed(page, viewer, exclusions) && !isNoindex(page, exclusions);
+}
+
 /**
  * Search a set of pages.
  *
@@ -536,8 +554,9 @@ export function searchPages(pages, query, {maxResults = 10, onError = () => {},
  * Which pages an anonymous visitor's search can return, and which it leaves
  * out - the same rule searchPages() applies (isSearchable() with no viewer).
  * Each page left out is counted once, under the first reason that applies:
- * a draft, then offline (its project is disabled), then restricted (private
- * or role-gated), then noindex (frontmatter or the SEO screen). A signed-in
+ * unpublished (`drafts` - any status but `published`, as isPubliclyListed()),
+ * then offline (its project is disabled), then restricted (private or
+ * role-gated), then noindex (frontmatter or the SEO screen). A signed-in
  * visitor may find more than `searchable` - the gated pages they can open.
  *
  * @param {object[]} pages
@@ -550,7 +569,7 @@ export function searchCoverage(pages = [], exclusions = null) {
     let restricted = 0;
     let noindex = 0;
     for (const p of pages) {
-        if (p?.status === 'draft') drafts++;
+        if (p?.status !== 'published') drafts++;
         else if (isOffline(p, exclusions)) offline++;
         else if (!checkVisibility(null, p?.visibility)) restricted++;
         else if (isNoindex(p, exclusions)) noindex++;

package/server/templates/page.html

@@ -137,7 +137,7 @@
     </script>
 
     <!-- Site initialisation -->
-    <script src="/public/js/site.js?v=20261004-countdown" type="module"></script>
+    <script src="/public/js/site.js?v=20261009-menu-classes" type="module"></script>
     <script src="/public/js/collection-context.js?v=20260927-ctx" type="module"></script>
     {{ctxMenusModule}}