domma-cms 0.79.1 → 0.80.0

package/server/routes/api/notifications.js

@@ -9,7 +9,14 @@
  * POST   /api/system/notifications/dismiss-all  - Dismiss every active one, for this user
  * POST   /api/system/notifications/read-all     - Mark every active one read, for this user
  * POST   /api/system/notifications/:id/dismiss  - Mark dismissed
+ * POST   /api/system/notifications/samples      - Add one sample of each severity (admin only)
  * DELETE /api/system/notifications/:id          - Hard delete (admin only)
+ * GET    /api/system/notifications/sources      - What can raise one, with settings (Super Admin)
+ * PUT    /api/system/notifications/sources/:id  - {enabled, audience} (Super Admin)
+ * POST   /api/system/notifications/sources/:id/run - Run a scheduled source now (Super Admin)
+ *
+ * Who sees a notification: its `audience` (services/notify.js). None - manager
+ * pushes and everything before 0.80 - is everyone who can read notifications.
  */
 import {
     authenticate as defaultAuthenticate,
@@ -18,6 +25,8 @@ import {
 import { requireManager } from '../../middleware/managerAuth.js';
 import { randomUUID } from 'crypto';
 import { getAdapter } from '../../services/adapterRegistry.js';
+import {AUDIENCES, isActiveFor, listNotificationSources, runSource, saveSourceSetting} from '../../services/notify.js';
+import {getEffectiveRoles} from '../../services/userRoles.js';
 
 const SLUG = 'notifications';
 
@@ -62,19 +71,6 @@ async function saveData(adapter, entry, data) {
     return adapter.update(SLUG, entry.id, {...entry, data, meta: {...(entry.meta || {}), updatedAt: new Date().toISOString()}});
 }
 
-/**
- * Is this notification live for this user right now: not expired, not dismissed.
- *
- * @param {object} data - A notification payload.
- * @param {string} userId
- * @param {string} now - ISO timestamp.
- * @returns {boolean}
- */
-function isActiveFor(data, userId, now) {
-    if (data.expiresAt && data.expiresAt < now) return false;
-    return !(Array.isArray(data.dismissedBy) && data.dismissedBy.includes(userId));
-}
-
 /**
  * The sidebar badge on Notifications (its countUrl): the unread ones - the same
  * number the sidebar always showed there - red while any of them is critical.
@@ -112,6 +108,42 @@ export function notificationsBadge(active = []) {
     };
 }
 
+/**
+ * One sample of each severity, shaped like what the site's own sources will
+ * send (see the Notifications plan): something to look at on a fresh site, and
+ * a way to try the bell, the badge and desktop notifications. Each ends itself
+ * after a week.
+ *
+ * @param {Date} now
+ * @param {string} origin - the site's own address, for the one sample with a link
+ * @returns {object[]} entries, `{id, data, meta}`
+ */
+export function sampleNotifications(now = new Date(), origin = '') {
+    const expiresAt = new Date(now.getTime() + 7 * 86_400_000).toISOString();
+    const note = `\n\n(A sample - it goes by itself on ${expiresAt.slice(0, 10)}.)`;
+    const samples = [
+        {severity: 'critical', title: 'Plugin failed to load: Calendar',
+            body: 'The Calendar plugin stopped with an error while the site started, so its screens and pages are missing. Check Plugins for the error, then restart the site.',
+            link: origin ? `${origin}/admin/#/plugins` : null},
+        {severity: 'warning', title: 'Invoice INV-0042 is overdue',
+            body: 'INV-0042 for Acme Ltd (£1,250.00) was due 3 days ago and has not been paid.'},
+        {severity: 'info', title: 'New comment awaiting moderation',
+            body: 'Sam left a comment on "Spring opening hours". It will not show on the site until it is approved.'},
+        {severity: 'success', title: 'Payment recorded: INV-0039',
+            body: 'A payment of £480.00 was recorded against INV-0039. It is now paid in full.'}
+    ];
+    // A minute apart, newest first, so the list shows its order.
+    return samples.map((x, i) => {
+        const at = new Date(now.getTime() - i * 60_000).toISOString();
+        return {
+            id: randomUUID(),
+            data: {title: x.title, body: x.body + note, severity: x.severity, source: 'sample', link: x.link || null,
+                createdAt: at, expiresAt, readBy: [], dismissedBy: []},
+            meta: {createdAt: at, updatedAt: at, source: 'sample'}
+        };
+    });
+}
+
 export async function notificationsRoutes(fastify, opts = {}) {
     // Injectable so tests can supply no-ops rather than a seeded roles cache -
     // the same DI pattern as menus.js, projects.js and context-menus.js.
@@ -182,7 +214,7 @@ export async function notificationsRoutes(fastify, opts = {}) {
         return all
             .filter(entry => {
                 const d = notificationData(entry, fastify.log);
-                return !!d && isActiveFor(d, userId, now);
+                return !!d && isActiveFor(d, request.user, now);
             })
             // A record with no createdAt sorts last rather than taking the
             // whole list down with it.
@@ -202,7 +234,7 @@ export async function notificationsRoutes(fastify, opts = {}) {
 
         const count = all.filter(entry => {
             const d = notificationData(entry, fastify.log);
-            if (!d || !isActiveFor(d, userId, now)) return false;
+            if (!d || !isActiveFor(d, request.user, now)) return false;
             return !Array.isArray(d.readBy) || !d.readBy.includes(userId);
         }).length;
 
@@ -210,26 +242,27 @@ export async function notificationsRoutes(fastify, opts = {}) {
     });
 
     /** This user's active notifications, newest first, each flagged `unread`. */
-    async function activeFor(userId) {
+    async function activeFor(user) {
+        const userId = user.id;
         const now = new Date().toISOString();
         const adapter = await getAdapter(SLUG);
         return (await adapter.all(SLUG))
             .filter(entry => {
                 const d = notificationData(entry, fastify.log);
-                return !!d && isActiveFor(d, userId, now);
+                return !!d && isActiveFor(d, user, now);
             })
             .map(entry => ({...entry, unread: !Array.isArray(entry.data.readBy) || !entry.data.readBy.includes(userId)}));
     }
 
     // --- Sidebar badge (static path: GET has no /:id route to shadow) ---
-    fastify.get('/system/notifications/_count', canRead, async (request) => notificationsBadge(await activeFor(request.user.id)));
+    fastify.get('/system/notifications/_count', canRead, async (request) => notificationsBadge(await activeFor(request.user)));
 
     // --- Dismiss everything active, for this user ---
     fastify.post('/system/notifications/dismiss-all', canRead, async (request) => {
         const userId = request.user.id;
         const adapter = await getAdapter(SLUG);
         let dismissed = 0;
-        for (const entry of await activeFor(userId)) {
+        for (const entry of await activeFor(request.user)) {
             const {unread: _u, ...stored} = entry;
             const data = stored.data;
             const dismissedBy = Array.isArray(data.dismissedBy) ? data.dismissedBy : [];
@@ -252,7 +285,7 @@ export async function notificationsRoutes(fastify, opts = {}) {
         const userId = request.user.id;
         const adapter = await getAdapter(SLUG);
         let marked = 0;
-        for (const entry of await activeFor(userId)) {
+        for (const entry of await activeFor(request.user)) {
             if (!entry.unread) continue;
             const {unread: _u, ...stored} = entry;
             const readBy = Array.isArray(stored.data.readBy) ? stored.data.readBy : [];
@@ -317,6 +350,50 @@ export async function notificationsRoutes(fastify, opts = {}) {
         return { ok: true, entry: updated };
     });
 
+    // --- Samples (the settings cog's "Add samples"; same permission as deleting) ---
+    fastify.post('/system/notifications/samples', canDelete, async (request, reply) => {
+        const adapter = await getAdapter(SLUG);
+        const origin = `${request.protocol}://${request.host || request.hostname}`;
+        const made = sampleNotifications(new Date(), origin);
+        // A second click replaces the samples rather than stacking another set.
+        for (const e of await adapter.all(SLUG)) if (e?.data?.source === 'sample') await adapter.remove(SLUG, e.id);
+        for (const entry of made) await adapter.insert(SLUG, entry);
+        return reply.code(201).send({ok: true, added: made.length});
+    });
+
+    // --- Sources: what the site itself raises, and where it goes (Super Admins) ---
+    const superAdminOnly = async (request, reply) => {
+        if (!getEffectiveRoles(request.user || {}).includes('super-admin')) {
+            return reply.code(403).send({error: 'Only a Super Admin can change notification sources.'});
+        }
+    };
+    const canManageSources = {preHandler: [authenticate, requirePermission('notifications', 'read'), superAdminOnly]};
+
+    fastify.get('/system/notifications/sources', canManageSources, async () => ({
+        sources: listNotificationSources(),
+        audiences: Object.keys(AUDIENCES)
+    }));
+
+    fastify.put('/system/notifications/sources/:id', canManageSources, async (request, reply) => {
+        const {id} = request.params;
+        const known = listNotificationSources().find(s => s.id === id);
+        if (!known) return reply.code(404).send({error: 'No such source.'});
+        const {enabled, audience} = request.body || {};
+        if (enabled !== undefined && typeof enabled !== 'boolean') return reply.code(400).send({error: 'enabled must be true or false.'});
+        if (audience !== undefined && AUDIENCES[audience] === undefined) {
+            return reply.code(400).send({error: `audience must be one of: ${Object.keys(AUDIENCES).join(', ')}.`});
+        }
+        return {ok: true, setting: saveSourceSetting(id, {enabled, audience})};
+    });
+
+    fastify.post('/system/notifications/sources/:id/run', canManageSources, async (request, reply) => {
+        const known = listNotificationSources().find(s => s.id === request.params.id);
+        if (!known) return reply.code(404).send({error: 'No such source.'});
+        if (!known.every) return reply.code(400).send({error: 'That source is not a scheduled check - it raises notifications as things happen.'});
+        const result = await runSource(known.id);
+        return {...result, source: listNotificationSources().find(s => s.id === known.id)};
+    });
+
     // --- Hard delete (admin only) ---
     fastify.delete('/system/notifications/:id', canDelete, async (request, reply) => {
         const { id } = request.params;

package/server/routes/api/users.js

@@ -12,6 +12,7 @@ import {getPermissionsFor} from '../../services/roles.js';
 import {createUser, deleteUser, getUserById, listUsers, updateUser} from '../../services/users.js';
 import {getProfile, listProfiles, updateProfile} from '../../services/userProfiles.js';
 import {ago, clip, plural} from '../../services/sidebarBadges.js';
+import * as notices from '../../services/notification-sources.js';
 
 /**
  * The sidebar badge on Users (its countUrl, GET /api/users/_count). The number
@@ -133,6 +134,9 @@ export async function usersRoutes(fastify) {
         } catch (err) {
             return reply.status(409).send({ error: err.message });
         }
+        notices.userCreated(user, request.user?.name || request.user?.email);
+        const newAdmin = [user.role, ...(user.additionalRoles || [])].filter(r => r === 'admin' || r === 'super-admin');
+        if (newAdmin.length) notices.adminRightsGiven(user, newAdmin, request.user?.name || request.user?.email);
         if (profile && typeof profile === 'object' && !Array.isArray(profile)) await updateProfile(user.id, profile);
         return reply.status(201).send(user);
     });
@@ -187,6 +191,12 @@ export async function usersRoutes(fastify) {
             await updateProfile(id, profile);
         }
 
+        // Admin rights given (not kept): the Super Admins hear about it.
+        const adminRoles = (u) => [u?.role, ...(Array.isArray(u?.additionalRoles) ? u.additionalRoles : [])]
+            .filter(r => r === 'admin' || r === 'super-admin');
+        const gained = adminRoles(user).filter(r => !adminRoles(target).includes(r));
+        if (gained.length) notices.adminRightsGiven(user, gained, actor.name || actor.email);
+
         const profileEntry = await getProfile(id);
         return {...user, profile: profileEntry?.data || {}};
     });
@@ -208,6 +218,7 @@ export async function usersRoutes(fastify) {
         }
 
         await deleteUser(id);
+        notices.userDeleted(target, actor.name || actor.email);
         return { success: true };
     });
 }

package/server/server.js

@@ -19,7 +19,8 @@ import fs from 'fs/promises';
 import {fileURLToPath} from 'url';
 import {createRequire} from 'module';
 import {config, getConfig} from './config.js';
-import {getLoadedPlugins, getPluginSettings, registerPlugins} from './services/plugins.js';
+import {getLoadedPlugins, getPluginSettings, recordPluginLoadFailure, registerPlugins} from './services/plugins.js';
+import {notifierFor} from './services/notify.js';
 import {load as loadRoles, seed as seedRoles} from './services/roles.js';
 import {ensureAllProfiles, seed as seedUserProfiles} from './services/userProfiles.js';
 import {seedAll as seedPresetCollections} from './services/presetCollections.js';
@@ -89,13 +90,17 @@ const app = Fastify({
 });
 
 // Register process error handlers immediately so startup errors are captured
+// Each leaves a marker, so the next start can tell the Super Admin (core:crash).
+const {recordCrash} = await import('./services/notification-sources.js');
 process.on('uncaughtException', (err) => {
     app.log.error({ err }, 'Uncaught exception');
+    recordCrash(err);
     process.exit(1);
 });
 
 process.on('unhandledRejection', (reason) => {
     app.log.error({ reason }, 'Unhandled rejection');
+    recordCrash(reason);
     process.exit(1);
 });
 
@@ -321,7 +326,11 @@ try {
     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(', ')}`);
+    if (pending.length) {
+        app.log.warn(`[collections] Number-field repair will retry next start for: ${pending.join(', ')}`);
+        const {startupPending} = await import('./services/notification-sources.js');
+        startupPending(`Number fields stored as text could not be converted in: ${pending.join(', ')} (a database was unreachable).`);
+    }
 } catch (err) {
     app.log.warn(`[collections] Number-field repair skipped: ${err.message}`);
 }
@@ -561,17 +570,25 @@ registerSidebarItem({folder: 'data', item: {source: 'Built in', text: 'Actions',
 registerSidebarItem({folder: 'data', item: {source: 'Built in', text: 'API Builder', url: '#/api-endpoints', icon: 'code', permission: 'api-endpoints', countUrl: '/api/api-endpoints/_count', inventory: true}});
 registerSidebarItem({folder: 'data', item: {source: 'Built in', text: 'Blocks', url: '#/blocks', icon: 'box', permission: 'pages', countUrl: '/api/blocks/_count', inventory: true}});
 registerSidebarItem({folder: 'data', item: {source: 'Built in', text: 'Components', url: '#/components', icon: 'component', permission: 'components', countUrl: '/api/components/_count', inventory: true}});
-// System. Notifications, Site Settings, Layouts and API Tokens are signals (unread, something quietly
-// wrong, pages on a missing layout, tokens expiring), so not `inventory`.
+// System. Notifications, Site Settings and My Profile are signals (unread, something quietly wrong,
+// details not filled in); Layouts and API Tokens are a count while all is well and a signal when not
+// (pages on a missing layout, tokens expiring - the answer says `inventory` in the calm case); Effects
+// is an inventory.
 registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'Notifications', url: '#/system/notifications', icon: 'bell', permission: 'notifications', countUrl: '/api/system/notifications/_count'}});
 registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'Roles', url: '#/roles', icon: 'shield', permission: 'plugins', countUrl: '/api/roles/_count', inventory: true}});
 registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'Users', url: '#/users', icon: 'users', permission: 'users', countUrl: '/api/users/_count', inventory: true}});
 registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'Site Settings', url: '#/settings', icon: 'settings', permission: 'settings', countUrl: '/api/settings/_count'}});
+registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'Effects', url: '#/effects', icon: 'sparkles', permission: 'settings', countUrl: '/api/effects/_count', inventory: true}});
+registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'My Profile', url: '#/my-profile', icon: 'user', countUrl: '/api/auth/me/_count'}});
 registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'Layouts', url: '#/layouts', icon: 'layout', permission: 'layouts', countUrl: '/api/layouts/_count'}});
 registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'Plugins', url: '#/plugins', icon: 'package', permission: 'plugins', countUrl: '/api/plugins/_count', inventory: true}});
 registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'API Tokens', url: '#/api-tokens', icon: 'key', permission: 'api-tokens', countUrl: '/api/api-tokens/_count'}});
 registerSidebarItem({folder: 'system', item: {source: 'Built in', text: 'Search', url: '#/search', icon: 'search', permission: 'settings', countUrl: '/api/search/_count', inventory: true}});
 
+// Core's notification sources, before plugins add theirs (0.80).
+const {registerCoreSources} = await import('./services/notification-sources.js');
+await registerCoreSources();
+
 await registerPlugins(app);
 
 // ---------------------------------------------------------------------------
@@ -589,10 +606,13 @@ for (const [name, plugin] of Object.entries(getLoadedPlugins())) {
             auth: { authenticate: _authenticate, requireAdmin: _requireAdmin, requireVisibility: _requireVisibility },
             // getConfig() requires a name; pass the startup config singleton instead.
             // (Without this every enabled plugin.public.js fails to register.)
-            config
+            config,
+            // notify / resolveNotification / registerNotificationSource, as plugin.js gets them (0.80).
+            hooks: notifierFor(name)
         });
     } catch (err) {
         app.log.error(`[plugins] Failed to register public plugin ${name}: ${err.message}`);
+        recordPluginLoadFailure(name, `public side failed to load: ${err.message}`);
     }
 }
 
@@ -623,6 +643,10 @@ process.on('SIGINT',  () => shutdown('SIGINT'));
 
 try {
     await app.listen({ port: serverConfig.port, host: serverConfig.host });
+    // Notifications: flush what start-up raised, run the boot checks, start the ticker.
+    const {startNotifications} = await import('./services/notify.js');
+    // Its timers are unref'd, so they never hold a shutdown open.
+    startNotifications({log: app.log});
     console.log(`Domma CMS running at http://localhost:${serverConfig.port}`);
     console.log(`  Admin:  http://localhost:${serverConfig.port}/admin/`);
     console.log(`  Public: http://localhost:${serverConfig.port}/`);

package/server/services/adapterRegistry.js

@@ -93,6 +93,7 @@ async function resolveMongoAdapter(schema) {
         return new MongoAdapter(db);
     } catch (err) {
         console.warn(`[adapterRegistry] Failed to load MongoAdapter for "${schema.slug}": ${err.message}. Falling back to FileAdapter.`);
+        import('./notification-sources.js').then(m => m.storageDown(schema.storage?.connection || 'default', err.message)).catch(() => {});
         return fileAdapter;
     }
 }

package/server/services/connectionManager.js

@@ -43,6 +43,7 @@ export async function initialise(connectionsConfig) {
             console.log(`[connectionManager] Connected: ${name} → ${cfg.database}`);
         } catch (err) {
             console.error(`[connectionManager] Failed to connect "${name}": ${err.message}`);
+            import('./notification-sources.js').then(m => m.storageDown(name, err.message)).catch(() => {});
             // Don't throw - allow server to start with degraded MongoDB support.
         }
     }

package/server/services/email.js

@@ -28,6 +28,8 @@ function recordSendResult(ok, info) {
         at: new Date().toISOString(),
         info: info || null
     };
+    // A failed send is the Super Admin's business (at most once a day - see notification-sources.js).
+    if (!ok) import('./notification-sources.js').then(m => m.emailFailed(info)).catch(() => {});
 }
 
 /**
@@ -89,6 +91,7 @@ export async function createTransport(smtp) {
     // same warning on the Email tab, and checkSmtpConfig() surfaces it in
     // Health. A site scaffolded by the CLI or the fleet manager ships with a
     // host precisely so it never lands here.
+    import('./notification-sources.js').then(m => m.emailNotConfigured()).catch(() => {});
     const testAccount = await nodemailer.createTestAccount();
     console.warn('[email] NO SMTP HOST CONFIGURED - mail is going to an Ethereal test inbox '
         + 'and will NOT reach its recipients. Set one in Settings > Email. '