domma-cms 1.10.22 → 1.10.23

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [1.10.23] - 2026-10-25
+
+- **One plugin's broken event listener no longer stops the others.** Every `hooks.on(...)` listener now runs on its own: one that throws, or an async one that rejects, is logged, and the listeners after it still hear the event. Before, the first throw stopped the rest and reached the code that emitted it.
+
 ## [1.10.22] - 2026-10-25
 
 - Survey definition exports and imports preserve public or invitation-only access, supporting keyless public surveys in Surveys 1.8.0. Imported surveys still start as drafts.

package/docs/plugin-development.md

@@ -375,7 +375,8 @@ export default async function myPlugin(fastify, options) {
 ### 1. Event Bus
 
 Subscribe to fire-and-forget lifecycle events emitted by the CMS. Handlers receive a payload object and must not return
-a value - errors thrown inside handlers are caught and logged.
+a value - an error thrown inside a handler (or a rejected promise from an async one) is logged, and the other
+handlers still run.
 
 ```js
 options.hooks.on('content:pageCreated', ({ page, urlPath }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domma-cms",
-  "version": "1.10.22",
+  "version": "1.10.23",
   "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/content.js

@@ -409,19 +409,6 @@ export async function listMedia() {
     return stats.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
 }
 
-/**
- * Emit a media event without letting a listener undo the work: the hooks are a plain
- * EventEmitter, so a plugin's listener that throws would throw out of saveMedia after the
- * file was written - the caller would report a failure and never clean the file up.
- */
-function tellListeners(event, data) {
-    try {
-        hooks.emit(event, data);
-    } catch (err) {
-        console.warn(`[media] A ${event} listener failed: ${err?.message || err}`);
-    }
-}
-
 /**
  * Save an uploaded file to the media directory.
  *
@@ -444,7 +431,7 @@ export async function saveMedia(filename, buffer, {exclusive = false} = {}) {
     } else {
         await fs.writeFile(filePath, buffer);
     }
-    tellListeners('content:mediaUploaded', {filename});
+    hooks.emit('content:mediaUploaded', {filename});
     return { name: filename, url: `/media/${filename}` };
 }
 
@@ -457,7 +444,7 @@ export async function saveMedia(filename, buffer, {exclusive = false} = {}) {
 export async function deleteMedia(filename) {
     const filePath = path.join(MEDIA_DIR, filename);
     await fs.unlink(filePath);
-    tellListeners('content:mediaDeleted', {filename});
+    hooks.emit('content:mediaDeleted', {filename});
 }
 
 /**

package/server/services/hooks.js

@@ -12,7 +12,30 @@ import {EventEmitter} from 'node:events';
 // 1. Event bus
 // ---------------------------------------------------------------------------
 
-const hooks = new EventEmitter();
+/**
+ * The events are fire-and-forget, so one listener must not stop the others or reach the code
+ * that emitted: a plain EventEmitter stops at the first listener that throws and throws out of
+ * emit(). Each listener runs on its own here; a throw or a rejected promise is logged.
+ */
+class HookBus extends EventEmitter {
+    emit(event, ...args) {
+        if (event === 'error') return super.emit(event, ...args);
+        const listeners = this.rawListeners(event);
+        if (!listeners.length) return false;
+        const failed = (err) => console.warn(`[hooks] A ${String(event)} listener failed: ${err?.message || err}`);
+        for (const listener of listeners) {
+            try {
+                const result = listener.apply(this, args);
+                if (typeof result?.then === 'function') result.then(null, failed);
+            } catch (err) {
+                failed(err);
+            }
+        }
+        return true;
+    }
+}
+
+const hooks = new HookBus();
 hooks.on('error', (err) => console.error('[hooks]', err));
 
 export {hooks};