domma-cms 0.77.1 → 0.77.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domma-cms",
-  "version": "0.77.1",
+  "version": "0.77.2",
   "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/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/number-fields-migration.js

@@ -0,0 +1,109 @@
+/**
+ * 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. It is deliberately not a standing coercion -
+ * what an API client writes after this is the client's business.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import {config} from '../config.js';
+
+export const MIGRATION_ID = 'number-field-types';
+
+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;
+}
+
+/**
+ * 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;
+    let changed = null;
+    for (const name of names) {
+        if (!(name in data)) continue;
+        const next = numberFromText(data[name]);
+        if (next !== data[name]) (changed ||= {...data})[name] = next;
+    }
+    return changed ? {...entry, data: changed} : null;
+}
+
+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 = (schema.fields || []).filter(f => f?.type === 'number' && f.name).map(f => f.name);
+        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};
+}