domma-cms 1.6.49 → 1.6.51

package/server/services/listTags.js

@@ -0,0 +1,220 @@
+/**
+ * List tags - admin-only labels that link pages (or blocks) together so the
+ * Pages and Blocks lists can be narrowed to one tag. Nothing on the public
+ * site reads them.
+ *
+ * An item may carry several. They live on the item itself: a page's
+ * frontmatter `adminTags`, a block's sidecar `meta.adminTags`. A page's own
+ * `tags` are a different thing - editorial, public (search, the Content API) -
+ * and are never touched here.
+ *
+ * config/list-tags.json keeps the names per kind (`{pages: [], blocks: []}`)
+ * so a tag can exist before anything wears it; a tag found on an item but not
+ * in the file is still listed. Absence of the file = no names yet.
+ *
+ * Tagging is metadata, not an edit: a page's tags are written without a
+ * revision and without moving its updatedAt.
+ */
+import {getConfig, saveConfig} from '../config.js';
+import {getPage, listPages, setPageFrontmatter} from './content.js';
+import {getBlock, listBlocks, setBlockMeta} from './blocks.js';
+
+export const KINDS = ['pages', 'blocks'];
+export const MAX_TAG = 40;
+const CONFIG_NAME = 'list-tags';
+
+/** One tag name as stored: trimmed, inner whitespace collapsed, capped. '' when unusable. */
+export function normaliseTag(name) {
+    if (typeof name !== 'string') return '';
+    // eslint-disable-next-line no-control-regex
+    return name.replace(/[\u0000-\u001f\u007f]/g, '').replace(/\s+/g, ' ').trim().slice(0, MAX_TAG);
+}
+
+/** A tag list: normalised, no blanks, no case-insensitive duplicates (the first spelling wins). */
+export function cleanTagList(list) {
+    if (!Array.isArray(list)) return [];
+    const seen = new Set();
+    const out = [];
+    for (const raw of list) {
+        const t = normaliseTag(raw);
+        if (!t || seen.has(t.toLowerCase())) continue;
+        seen.add(t.toLowerCase());
+        out.push(t);
+    }
+    return out;
+}
+
+const same = (a, b) => String(a).toLowerCase() === String(b).toLowerCase();
+
+function assertKind(kind) {
+    if (KINDS.includes(kind)) return;
+    const err = new Error(`Unknown kind "${kind}"`);
+    err.code = 'BAD_KIND';
+    throw err;
+}
+
+function readRegistry() {
+    let raw = {};
+    try {
+        raw = getConfig(CONFIG_NAME);
+    } catch { /* absent or unreadable = no names yet */ }
+    return Object.fromEntries(KINDS.map(k => [k, cleanTagList(raw?.[k])]));
+}
+
+function writeRegistry(reg) {
+    saveConfig(CONFIG_NAME, Object.fromEntries(KINDS.map(k => [k, cleanTagList(reg[k])])));
+}
+
+/** The items of a kind as `{id, tags}`, through the same listers the routes use. */
+async function items(kind) {
+    if (kind === 'pages') return (await listPages()).map(p => ({id: p.urlPath, tags: cleanTagList(p.adminTags), raw: p}));
+    return (await listBlocks()).map(b => ({id: b.name, tags: cleanTagList(b.meta?.adminTags), raw: b}));
+}
+
+async function writeItemTags(kind, id, tags) {
+    const clean = cleanTagList(tags);
+    if (kind === 'pages') await setPageFrontmatter(id, {adminTags: clean.length ? clean : undefined});
+    else await setBlockMeta(id, {adminTags: clean.length ? clean : undefined});
+    return clean;
+}
+
+/**
+ * Every tag of a kind with how many items wear it: the registry's names in
+ * alphabetical order, plus any name only found on items.
+ *
+ * @param {string} kind
+ * @param {(item: object) => boolean} [visible] - the caller's scope filter
+ * @returns {Promise<{name: string, count: number}[]>}
+ */
+export async function listTags(kind, visible = () => true) {
+    assertKind(kind);
+    const names = [...readRegistry()[kind]];
+    const counts = new Map();
+    for (const it of await items(kind)) {
+        if (!visible(it.raw)) continue;
+        for (const t of it.tags) {
+            const known = names.find(n => same(n, t));
+            if (!known) names.push(t);
+            const key = (known || t).toLowerCase();
+            counts.set(key, (counts.get(key) || 0) + 1);
+        }
+    }
+    return cleanTagList(names)
+        .sort((a, b) => a.localeCompare(b, undefined, {sensitivity: 'base'}))
+        .map(name => ({name, count: counts.get(name.toLowerCase()) || 0}));
+}
+
+/** Add a name to the registry (no item changes). Returns the stored spelling. */
+async function addTagNow(kind, name) {
+    assertKind(kind);
+    const tag = normaliseTag(name);
+    if (!tag) {
+        const err = new Error('A tag needs a name.');
+        err.code = 'BAD_TAG';
+        throw err;
+    }
+    const reg = readRegistry();
+    const existing = reg[kind].find(n => same(n, tag));
+    if (existing) return existing;
+    reg[kind].push(tag);
+    writeRegistry(reg);
+    return tag;
+}
+
+/**
+ * Change one item's tags: `tags` replaces the list, `add` / `remove` patch the
+ * stored one (read afresh here, so two quick changes from the menu both land).
+ * Names it brings that the registry lacks are added to it.
+ *
+ * @param {string} kind
+ * @param {string} id - urlPath or block name
+ * @param {{tags?: string[], add?: string[], remove?: string[]}} change
+ * @returns {Promise<string[]>} the stored list
+ */
+async function changeItemTagsNow(kind, id, {tags, add = [], remove = []} = {}) {
+    assertKind(kind);
+    let next;
+    if (Array.isArray(tags)) next = tags;
+    else {
+        const item = kind === 'pages' ? await getPage(id) : await getBlock(id).catch(() => null);
+        if (!item) {
+            const err = new Error(`Not found: ${id}`);
+            err.code = 'ENOENT';
+            throw err;
+        }
+        const stored = cleanTagList(kind === 'pages' ? item.adminTags : item.meta?.adminTags);
+        next = [...stored, ...(Array.isArray(add) ? add : [])]
+            .filter(t => !(Array.isArray(remove) ? remove : []).some(r => same(r, t)));
+    }
+    const clean = await writeItemTags(kind, id, next);
+    const reg = readRegistry();
+    const fresh = clean.filter(t => !reg[kind].some(n => same(n, t)));
+    if (fresh.length) {
+        reg[kind].push(...fresh);
+        writeRegistry(reg);
+    }
+    return clean;
+}
+
+/**
+ * Rename a tag on every item the caller may see. Renaming onto an existing
+ * tag merges the two. An item outside the caller's projects keeps the old
+ * name, which then still lists (found on an item).
+ *
+ * @returns {Promise<{name: string, changed: number}>}
+ */
+async function renameTagNow(kind, from, to, visible = () => true) {
+    assertKind(kind);
+    const target = normaliseTag(to);
+    if (!target) {
+        const err = new Error('A tag needs a name.');
+        err.code = 'BAD_TAG';
+        throw err;
+    }
+    let changed = 0;
+    for (const it of await items(kind)) {
+        if (!visible(it.raw) || !it.tags.some(t => same(t, from))) continue;
+        await writeItemTags(kind, it.id, it.tags.map(t => (same(t, from) ? target : t)));
+        changed++;
+    }
+    const reg = readRegistry();
+    reg[kind] = reg[kind].filter(n => !same(n, from) && !same(n, target)).concat(target);
+    writeRegistry(reg);
+    return {name: target, changed};
+}
+
+/**
+ * Delete a tag: it comes off every item the caller may see. The items stay.
+ *
+ * @returns {Promise<{changed: number}>}
+ */
+async function deleteTagNow(kind, name, visible = () => true) {
+    assertKind(kind);
+    let changed = 0;
+    for (const it of await items(kind)) {
+        if (!visible(it.raw) || !it.tags.some(t => same(t, name))) continue;
+        await writeItemTags(kind, it.id, it.tags.filter(t => !same(t, name)));
+        changed++;
+    }
+    const reg = readRegistry();
+    reg[kind] = reg[kind].filter(n => !same(n, name));
+    writeRegistry(reg);
+    return {changed};
+}
+
+// Every change runs one after another: each is a read-modify-write of item
+// files and the registry, and two interleaved (a rename while someone tags a
+// page) would lose one of them.
+let queue = Promise.resolve();
+function serial(fn) {
+    const run = queue.then(fn, fn);
+    queue = run.catch(() => {});
+    return run;
+}
+
+export const addTag = (kind, name) => serial(() => addTagNow(kind, name));
+export const changeItemTags = (kind, id, change) => serial(() => changeItemTagsNow(kind, id, change));
+/** Replace one item's tags. */
+export const setItemTags = (kind, id, tags) => changeItemTags(kind, id, {tags});
+export const renameTag = (kind, from, to, visible) => serial(() => renameTagNow(kind, from, to, visible));
+export const deleteTag = (kind, name, visible) => serial(() => deleteTagNow(kind, name, visible));

package/server/services/versions.js

@@ -5,6 +5,7 @@
  */
 import fs from 'fs/promises';
 import path from 'path';
+import matter from 'gray-matter';
 import {config} from '../config.js';
 import {hooks} from './hooks.js';
 import {getUserById} from './users.js';
@@ -243,6 +244,27 @@ export async function deleteVersion(urlPath, filename) {
     await writeMeta(dir, meta.filter(m => m.filename !== filename));
 }
 
+/**
+ * A restore brings back the page, not its list tags: tagging adds no
+ * revision (services/listTags.js), so no snapshot holds the current tags,
+ * and restoring one would quietly drop or un-rename them. The live
+ * `adminTags` are carried onto the restored source.
+ *
+ * @param {string} livePath
+ * @param {string} restored - the version's file content
+ * @returns {Promise<string>}
+ */
+async function keepLiveAdminTags(livePath, restored) {
+    let live;
+    try { live = matter(await fs.readFile(livePath, 'utf8')).data?.adminTags; } catch { return restored; }
+    const old = matter(restored);
+    if (JSON.stringify(old.data?.adminTags ?? null) === JSON.stringify(live ?? null)) return restored;
+    const data = {...old.data};
+    if (Array.isArray(live) && live.length) data.adminTags = live;
+    else delete data.adminTags;
+    return matter.stringify(old.content, data);
+}
+
 /**
  * Restore a version: snapshot current state first, then overwrite the live page.
  *
@@ -260,8 +282,9 @@ export async function restoreVersion(urlPath, filename, author) {
     await createVersion(urlPath, {author, type: 'auto', label: 'Pre-restore snapshot'});
 
     // Overwrite live page with version content
-    const content = await fs.readFile(filePath, 'utf8');
+    let content = await fs.readFile(filePath, 'utf8');
     const livePath = pageFilePath(urlPath);
+    content = await keepLiveAdminTags(livePath, content);
     await fs.writeFile(livePath, content, 'utf8');
 
     hooks.emit('content:pageUpdated', {urlPath});