domma-cms 0.77.1 → 0.78.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domma-cms",
-  "version": "0.77.1",
+  "version": "0.78.0",
   "description": "File-based CMS powered by Domma and Fastify. Run npx domma-cms my-site to create a new project.",
   "type": "module",
   "main": "server/server.js",

package/scripts/promote-changelog.mjs

@@ -0,0 +1,71 @@
+/**
+ * Turn the CHANGELOG's `## [Unreleased]` heading into `## [X.Y.Z] - YYYY-MM-DD`.
+ *
+ * The release notes are the one part of a release a workflow cannot write, so
+ * they are written as the work lands, under `[Unreleased]`, and this is what
+ * the "Cut a release" workflow does with them. Refusing to run without them is
+ * the point: a release with no entry is a release nobody can read about.
+ *
+ * With `--print X.Y.Z` it instead prints an already-released section.
+ *
+ * The same script as domma-reactive/scripts/promote-changelog.mjs; both
+ * CHANGELOGs follow Keep a Changelog. Keep the two in step.
+ *
+ *     node scripts/promote-changelog.mjs 1.2.0 2026-10-01
+ *     node scripts/promote-changelog.mjs --print 1.2.0
+ */
+
+import {readFileSync, writeFileSync} from 'node:fs';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+
+const FILE = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'CHANGELOG.md');
+
+const fail = (message) => {
+    console.error(`\n  promote-changelog: ${message}\n`);
+    process.exit(1);
+};
+
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/** The body under a `## [label]` heading, up to the next `## [` heading. */
+function section(source, label) {
+    const heading = new RegExp(`^## \\[${escape(label)}\\][^\\n]*\\n`, 'm');
+    const match = heading.exec(source);
+    if (!match) return null;
+
+    const start = match.index + match[0].length;
+    const next = source.slice(start).search(/^## \[/m);
+    const end = next === -1 ? source.length : start + next;
+    return {heading: match, start, end, body: source.slice(start, end).trim()};
+}
+
+const source = readFileSync(FILE, 'utf8');
+
+if (process.argv[2] === '--print') {
+    const version = process.argv[3];
+    const found = version && section(source, version);
+    if (!found) fail(`no '## [${version}]' section in CHANGELOG.md`);
+    console.log(found.body);
+    process.exit(0);
+}
+
+const [version, date] = process.argv.slice(2);
+if (!/^\d+\.\d+\.\d+$/.test(version || '')) fail('usage: promote-changelog.mjs X.Y.Z YYYY-MM-DD');
+if (!/^\d{4}-\d{2}-\d{2}$/.test(date || '')) fail(`"${date}" is not a YYYY-MM-DD date`);
+
+if (section(source, version)) fail(`CHANGELOG.md already has a '## [${version}]' section`);
+
+const pending = section(source, 'Unreleased');
+if (!pending) {
+    fail("no '## [Unreleased]' section - write the release notes there first, then cut the release");
+}
+if (pending.body === '') {
+    fail("'## [Unreleased]' is empty - write the release notes there first, then cut the release");
+}
+
+writeFileSync(
+    FILE,
+    source.slice(0, pending.heading.index) + `## [${version}] - ${date}\n` + source.slice(pending.start)
+);
+console.log(`\n  CHANGELOG.md: [Unreleased] → [${version}] - ${date}\n`);

package/server/server.js

@@ -314,6 +314,18 @@ try {
 // Initialise response cache (Memory/None/Redis driver per config.cache).
 await cache.initCache(config.cache);
 
+// Number fields saved as text by the pre-0.77.1 entry form - one-shot repair.
+// After the cache: it invalidates the collections it changes.
+try {
+    const {migrateNumberFields} = await import('./services/number-fields-migration.js');
+    const {ran, converted, pending} = await migrateNumberFields();
+    const done = Object.entries(converted).map(([slug, n]) => `${slug} (${n})`);
+    if (ran && done.length) app.log.info(`[collections] Number fields stored as text converted: ${done.join(', ')}`);
+    if (pending.length) app.log.warn(`[collections] Number-field repair will retry next start for: ${pending.join(', ')}`);
+} catch (err) {
+    app.log.warn(`[collections] Number-field repair skipped: ${err.message}`);
+}
+
 /*
  * An admin change clears the response cache.
  *

package/server/services/adapters/FileAdapter.js

@@ -15,6 +15,7 @@
  *   all(slug)                 → entry[]
  *   insertMany(slug, entries) → { imported, skipped, errors }
  *   count(slug)               → number
+ *   replaceAll(slug, entries) → void   (file only - one write for a whole-collection rewrite)
  */
 import fs from 'fs/promises';
 import path from 'path';
@@ -207,6 +208,18 @@ export class FileAdapter {
         const entries = await read(slug);
         return entries.length;
     }
+
+    /**
+     * Replace every entry in one write - for a data migration that touches many
+     * entries, where update() would rewrite the whole file once per entry.
+     *
+     * @param {string}   slug
+     * @param {object[]} entries
+     * @returns {Promise<void>}
+     */
+    async replaceAll(slug, entries) {
+        await write(slug, entries);
+    }
 }
 
 export default new FileAdapter();

package/server/services/collections.js

@@ -12,6 +12,7 @@ import {v4 as uuidv4} from 'uuid';
 import {config} from '../config.js';
 import {getAdapter, invalidate} from './adapterRegistry.js';
 import * as cache from './cache/index.js';
+import {typedEntryData} from './entryValues.js';
 import {toCsv} from '../../public/js/collection-export.mjs';
 
 const COLLECTIONS_DIR = path.resolve(config.content.collectionsDir);
@@ -388,6 +389,7 @@ export async function getEntry(slug, entryId) {
 export async function createEntry(slug, data, { createdBy = null, source = 'admin' } = {}) {
     const schema = await getCollection(slug);
     if (!schema) throw new Error(`Collection "${slug}" not found`);
+    data = typedEntryData(schema, data);
 
     const { valid, errors } = validateEntryData(schema, data);
     if (!valid) throw new Error(`Validation failed: ${errors.join('; ')}`);
@@ -420,6 +422,7 @@ export async function createEntry(slug, data, { createdBy = null, source = 'admi
 export async function updateEntry(slug, entryId, data) {
     const schema = await getCollection(slug);
     if (!schema) throw new Error(`Collection "${slug}" not found`);
+    data = typedEntryData(schema, data);
 
     const { valid, errors } = validateEntryData(schema, data);
     if (!valid) throw new Error(`Validation failed: ${errors.join('; ')}`);
@@ -526,7 +529,7 @@ export async function importEntries(slug, incoming, { createdBy = null } = {}) {
     const valid  = [];
 
     for (const item of incoming) {
-        const data = item.data || item;
+        const data = typedEntryData(schema, item.data || item);
         const { valid: ok, errors: valErrors } = validateEntryData(schema, data);
         if (!ok) {
             skipped++;

package/server/services/entryValues.js

@@ -0,0 +1,54 @@
+/**
+ * Entry values as their field types store them.
+ *
+ * Everything that writes entries through the collections service - the admin,
+ * the external /api/v1 API, form submissions, import, Actions - arrives here
+ * first, so a `number` field sent as text ("42", as HTML forms and CSV-minded
+ * clients send it) is stored as a number and sorts, filters and totals as one.
+ *
+ * Deliberately a conversion, not a check: text that is not a plain decimal
+ * number ("", "abc", "0x10", "Infinity") is stored as sent, exactly as before,
+ * so no existing client starts getting errors. Only top-level `number` fields.
+ */
+
+const DECIMAL = /^[+-]?(\d+\.?\d*|\.\d+)(e[+-]?\d+)?$/i;
+
+/** "42" -> 42; anything that is not plain decimal text is returned unchanged. */
+export function numberFromText(value) {
+    if (typeof value !== 'string') return value;
+    const t = value.trim();
+    if (!DECIMAL.test(t)) return value;
+    const n = Number(t);
+    return Number.isFinite(n) ? n : value;
+}
+
+/** The schema's number field names. */
+export function numberFieldNames(schema) {
+    return (schema?.fields || []).filter(f => f?.type === 'number' && f.name).map(f => f.name);
+}
+
+/**
+ * `data` with its number fields converted - a new object when anything changed,
+ * the same object when nothing did (the caller's object is never modified).
+ *
+ * @param {object} data
+ * @param {string[]} names - from numberFieldNames()
+ */
+export function withNumbers(data, names) {
+    if (!data || typeof data !== 'object' || Array.isArray(data) || !names?.length) return data;
+    let out = data;
+    for (const name of names) {
+        if (!Object.prototype.hasOwnProperty.call(data, name)) continue;
+        const next = numberFromText(data[name]);
+        if (next !== data[name]) {
+            if (out === data) out = {...data};
+            out[name] = next;
+        }
+    }
+    return out;
+}
+
+/** An entry's data typed for its collection's schema. */
+export function typedEntryData(schema, data) {
+    return withNumbers(data, numberFieldNames(schema));
+}

package/server/services/number-fields-migration.js

@@ -0,0 +1,97 @@
+/**
+ * Number-fields migration - one-shot repair of number fields stored as text.
+ *
+ * Before 0.77.1 the admin's entry form read every input as text, so a `number`
+ * field saved from it was stored as "42" rather than 42 - and a stored string
+ * sorts, filters and sums as text in the API, [collection] displays and views.
+ * The form is fixed; this converts what it left behind, in every collection and
+ * through the storage adapter, so MongoDB-backed collections are included.
+ *
+ * Only top-level `number` fields, and only text that is a plain decimal number
+ * (whitespace trimmed): "", "abc", "0x10" and "Infinity" are left exactly as
+ * they are. An entry's `meta.updatedAt` is not touched - this is a repair, not
+ * an edit.
+ *
+ * Runs ONCE per install: the marker (content/.migrations.json) is written only
+ * when every collection was done. From 0.78.0 the collections service converts
+ * on every write (entryValues.js), so nothing new of this kind arrives - this
+ * only mends what was stored before.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import {config} from '../config.js';
+import {numberFieldNames, numberFromText, withNumbers} from './entryValues.js';
+
+export const MIGRATION_ID = 'number-field-types';
+
+export {numberFromText};
+
+/**
+ * An entry with its number fields converted, or null when nothing changed.
+ *
+ * @param {object} entry
+ * @param {string[]} names - the collection's number field names
+ */
+export function convertEntry(entry, names) {
+    const data = entry?.data;
+    if (!data || typeof data !== 'object') return null;
+    const next = withNumbers(data, names);
+    return next === data ? null : {...entry, data: next};
+}
+
+function defaultMarkerPath() {
+    return path.join(path.dirname(path.resolve(config.content.collectionsDir)), '.migrations.json');
+}
+
+async function readMarker(file) {
+    try { return JSON.parse(await fs.readFile(file, 'utf8')) || {}; } catch { return {}; }
+}
+
+/**
+ * Run the migration.
+ *
+ * @param {{markerPath?: string, force?: boolean}} [opts]
+ * @returns {Promise<{ran: boolean, converted: object, pending: string[]}>}
+ *   converted: slug -> entries changed; pending: collections that could not be done
+ *   (they are retried on the next start, because the marker is not written)
+ */
+export async function migrateNumberFields({markerPath = defaultMarkerPath(), force = false} = {}) {
+    const marker = await readMarker(markerPath);
+    if (marker[MIGRATION_ID] && !force) return {ran: false, converted: {}, pending: []};
+
+    const {listCollections} = await import('./collections.js');
+    const {getAdapter} = await import('./adapterRegistry.js');
+    const {default: fileAdapter} = await import('./adapters/FileAdapter.js');
+    const cache = await import('./cache/index.js');
+
+    const converted = {};
+    const pending = [];
+    for (const schema of await listCollections()) {
+        const names = numberFieldNames(schema);
+        if (!names.length) continue;
+        try {
+            const adapter = await getAdapter(schema.slug);
+            // A MongoDB collection whose connection is down resolves to the file adapter,
+            // which would find nothing to do - leave it for a start where Mongo is up.
+            if (schema.storage?.adapter === 'mongodb' && adapter === fileAdapter) { pending.push(schema.slug); continue; }
+            const entries = await adapter.all(schema.slug);
+            const next = entries.map(e => convertEntry(e, names));
+            const count = next.filter(Boolean).length;
+            if (!count) continue;
+            if (typeof adapter.replaceAll === 'function') {
+                await adapter.replaceAll(schema.slug, entries.map((e, i) => next[i] || e));
+            } else {
+                for (const e of next) if (e) await adapter.update(schema.slug, e.id, e);
+            }
+            converted[schema.slug] = count;
+            await cache.invalidateTags([`collection:${schema.slug}`]).catch(() => {});
+        } catch {
+            pending.push(schema.slug);
+        }
+    }
+
+    if (!pending.length) {
+        await fs.writeFile(markerPath, JSON.stringify({...marker, [MIGRATION_ID]: new Date().toISOString()}, null, 2) + '\n');
+    }
+    return {ran: true, converted, pending};
+}