domma-cms 0.116.5 → 0.116.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domma-cms",
-  "version": "0.116.5",
+  "version": "0.116.6",
   "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/services/adapters/FileAdapter.js

@@ -22,6 +22,7 @@ import fs from 'fs/promises';
 import path from 'path';
 import { config } from '../../config.js';
 import { applyFilter } from '../filterEngine.js';
+import { withFileLock, writeFileAtomic } from './fileLock.js';
 
 const COLLECTIONS_DIR = path.resolve(config.content.collectionsDir);
 
@@ -43,9 +44,16 @@ async function read(slug) {
 }
 
 async function write(slug, entries) {
-    await fs.writeFile(dataPath(slug), JSON.stringify(entries, null, 2) + '\n', 'utf8');
+    await writeFileAtomic(dataPath(slug), JSON.stringify(entries, null, 2) + '\n');
 }
 
+/**
+ * Every change is read-modify-write of the whole file, so changes to one
+ * collection run one at a time (./fileLock.js) - overlapping ones used to
+ * lose all but the last. Reads need no lock: writes are atomic renames.
+ */
+const locked = (slug, fn) => withFileLock(dataPath(slug), fn);
+
 // ---------------------------------------------------------------------------
 // Adapter implementation
 // ---------------------------------------------------------------------------
@@ -125,10 +133,12 @@ export class FileAdapter {
      * @returns {Promise<object>}
      */
     async insert(slug, entry) {
-        const entries = await read(slug);
-        entries.push(entry);
-        await write(slug, entries);
-        return entry;
+        return locked(slug, async () => {
+            const entries = await read(slug);
+            entries.push(entry);
+            await write(slug, entries);
+            return entry;
+        });
     }
 
     /**
@@ -141,12 +151,14 @@ export class FileAdapter {
      * @throws {Error} If entry not found
      */
     async update(slug, entryId, updated) {
-        const entries = await read(slug);
-        const idx = entries.findIndex(e => e.id === entryId);
-        if (idx === -1) throw new Error('Entry not found');
-        entries[idx] = updated;
-        await write(slug, entries);
-        return updated;
+        return locked(slug, async () => {
+            const entries = await read(slug);
+            const idx = entries.findIndex(e => e.id === entryId);
+            if (idx === -1) throw new Error('Entry not found');
+            entries[idx] = updated;
+            await write(slug, entries);
+            return updated;
+        });
     }
 
     /**
@@ -158,11 +170,13 @@ export class FileAdapter {
      * @throws {Error} If entry not found
      */
     async remove(slug, entryId) {
-        const entries = await read(slug);
-        const idx = entries.findIndex(e => e.id === entryId);
-        if (idx === -1) throw new Error('Entry not found');
-        entries.splice(idx, 1);
-        await write(slug, entries);
+        return locked(slug, async () => {
+            const entries = await read(slug);
+            const idx = entries.findIndex(e => e.id === entryId);
+            if (idx === -1) throw new Error('Entry not found');
+            entries.splice(idx, 1);
+            await write(slug, entries);
+        });
     }
 
     /**
@@ -172,7 +186,7 @@ export class FileAdapter {
      * @returns {Promise<void>}
      */
     async clear(slug) {
-        await write(slug, []);
+        return locked(slug, () => write(slug, []));
     }
 
     /**
@@ -193,10 +207,12 @@ export class FileAdapter {
      * @returns {Promise<{ imported: number, skipped: number, errors: string[] }>}
      */
     async insertMany(slug, entries) {
-        const existing = await read(slug);
-        existing.push(...entries);
-        await write(slug, existing);
-        return { imported: entries.length, skipped: 0, errors: [] };
+        return locked(slug, async () => {
+            const existing = await read(slug);
+            existing.push(...entries);
+            await write(slug, existing);
+            return { imported: entries.length, skipped: 0, errors: [] };
+        });
     }
 
     /**
@@ -219,7 +235,7 @@ export class FileAdapter {
      * @returns {Promise<void>}
      */
     async replaceAll(slug, entries) {
-        await write(slug, entries);
+        return locked(slug, () => write(slug, entries));
     }
 
     /**
@@ -231,6 +247,10 @@ export class FileAdapter {
      * @returns {Promise<string|null>} The backup's file name, or null if there was no data.json
      */
     async archive(slug) {
+        return locked(slug, () => this.#archive(slug));
+    }
+
+    async #archive(slug) {
         const from = dataPath(slug);
         let to = `${from}.bak`;
         try {

package/server/services/adapters/fileLock.js

@@ -0,0 +1,63 @@
+/**
+ * One writer at a time per JSON file, and no half-written file ever on disk.
+ *
+ * A collection's `data.json` is changed by reading the whole file, changing it
+ * in memory and writing it back. Two of those overlapping - two form
+ * submissions, two imports, a save during a migration - each read the same
+ * starting file, and the second write silently drops the first one's change.
+ * `withFileLock()` queues them per file, so each read sees the last write.
+ *
+ * `writeFileAtomic()` writes a temporary file beside the target and renames
+ * it over, so a crash mid-write leaves the old file whole rather than a
+ * truncated one that reads as "no entries".
+ *
+ * The queue is in-process: one site is one Node process, which is how every
+ * site runs. Anything else writing the same file must go through here too
+ * (userProfiles.js does).
+ *
+ * @module server/services/adapters/fileLock
+ */
+import fs from 'fs/promises';
+import path from 'path';
+
+/** file path -> the tail of its queue */
+const queues = new Map();
+
+/**
+ * Run `fn` once every earlier call for the same file has finished (resolved
+ * or thrown). A failure is passed to this caller only; the queue goes on.
+ *
+ * @template T
+ * @param   {string} file
+ * @param   {() => Promise<T>} fn
+ * @returns {Promise<T>}
+ */
+export function withFileLock(file, fn) {
+    const key = path.resolve(file);
+    const prev = queues.get(key) ?? Promise.resolve();
+    const run = prev.then(fn, fn);
+    const tail = run.then(() => {}, () => {});
+    queues.set(key, tail);
+    tail.then(() => { if (queues.get(key) === tail) queues.delete(key); });
+    return run;
+}
+
+let seq = 0;
+
+/**
+ * Write `text` to `file` atomically: a temporary file in the same directory,
+ * then a rename over the target.
+ *
+ * @param {string} file
+ * @param {string} text
+ */
+export async function writeFileAtomic(file, text) {
+    const tmp = `${file}.${process.pid}.${Date.now().toString(36)}${(seq++).toString(36)}.tmp`;
+    try {
+        await fs.writeFile(tmp, text, 'utf8');
+        await fs.rename(tmp, file);
+    } catch (err) {
+        await fs.rm(tmp, {force: true}).catch(() => {});
+        throw err;
+    }
+}

package/server/services/userProfiles.js

@@ -6,6 +6,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import {config} from '../config.js';
+import {withFileLock, writeFileAtomic} from './adapters/fileLock.js';
 
 const COLLECTIONS_DIR = path.resolve(config.content.collectionsDir);
 const SLUG = 'user-profiles';
@@ -54,9 +55,12 @@ async function readData() {
  * @returns {Promise<void>}
  */
 async function writeData(entries) {
-    await fs.writeFile(DATA_PATH, JSON.stringify(entries, null, 2) + '\n', 'utf8');
+    await writeFileAtomic(DATA_PATH, JSON.stringify(entries, null, 2) + '\n');
 }
 
+/** Changes go one at a time, sharing the FileAdapter's queue for this file (adapters/fileLock.js). */
+const locked = (fn) => withFileLock(DATA_PATH, fn);
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -93,6 +97,10 @@ export async function seed() {
  * @returns {Promise<void>}
  */
 export async function ensureProfile(userId) {
+    return locked(() => ensureProfileUnlocked(userId));
+}
+
+async function ensureProfileUnlocked(userId) {
     const entries = await readData();
     const exists = entries.some(e => e.id === userId);
     if (!exists) {
@@ -125,6 +133,10 @@ export async function getProfile(userId) {
  * @returns {Promise<object>} Updated profile entry
  */
 export async function updateProfile(userId, data) {
+    return locked(() => updateProfileUnlocked(userId, data));
+}
+
+async function updateProfileUnlocked(userId, data) {
     const entries = await readData();
     const index = entries.findIndex(e => e.id === userId);
 
@@ -155,11 +167,13 @@ export async function updateProfile(userId, data) {
  * @returns {Promise<void>}
  */
 export async function deleteProfile(userId) {
-    const entries = await readData();
-    const filtered = entries.filter(e => e.id !== userId);
-    if (filtered.length !== entries.length) {
-        await writeData(filtered);
-    }
+    return locked(async () => {
+        const entries = await readData();
+        const filtered = entries.filter(e => e.id !== userId);
+        if (filtered.length !== entries.length) {
+            await writeData(filtered);
+        }
+    });
 }
 
 /**