strapi-plugin-notifier 1.0.3 → 1.1.0

package/dist/server/index.mjs

@@ -34,18 +34,18 @@ const bootstrap = async ({ strapi }) => {
     await strapi.store({ environment: "", type: "plugin", name: "notifier" }).set({ key: "settings", value: effective });
   }
 };
-const kind = "collectionType";
-const collectionName = "notifier_notifications";
-const info = {
+const kind$1 = "collectionType";
+const collectionName$1 = "notifier_notifications";
+const info$1 = {
   singularName: "notification",
   pluralName: "notifications",
   displayName: "Notification",
   description: "Admin-panel notifications managed by strapi-plugin-notifier"
 };
-const options = {
+const options$1 = {
   draftAndPublish: false
 };
-const pluginOptions = {
+const pluginOptions$1 = {
   "content-manager": {
     visible: false
   },
@@ -53,7 +53,7 @@ const pluginOptions = {
     visible: false
   }
 };
-const attributes = {
+const attributes$1 = {
   title: {
     type: "string",
     required: true
@@ -84,6 +84,56 @@ const attributes = {
   },
   recipientRole: {
     type: "string"
+  },
+  mergeKey: {
+    type: "string"
+  },
+  mergeCount: {
+    type: "integer",
+    "default": 1
+  }
+};
+const schema$1 = {
+  kind: kind$1,
+  collectionName: collectionName$1,
+  info: info$1,
+  options: options$1,
+  pluginOptions: pluginOptions$1,
+  attributes: attributes$1
+};
+const notification$3 = { schema: schema$1 };
+const kind = "collectionType";
+const collectionName = "notifier_preferences";
+const info = {
+  singularName: "notification-preference",
+  pluralName: "notification-preferences",
+  displayName: "Notification Preference",
+  description: "Per-user notification opt-out preferences for strapi-plugin-notifier"
+};
+const options = {
+  draftAndPublish: false
+};
+const pluginOptions = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes = {
+  userId: {
+    type: "integer",
+    required: true,
+    unique: true
+  },
+  globalOptOut: {
+    type: "boolean",
+    "default": false,
+    required: true
+  },
+  mutedTypes: {
+    type: "json"
   }
 };
 const schema = {
@@ -94,9 +144,9 @@ const schema = {
   pluginOptions,
   attributes
 };
-const notification$3 = { schema };
-const contentTypes = { notification: notification$3 };
-const UID = "plugin::notifier.notification";
+const notificationPreference = { schema };
+const contentTypes = { notification: notification$3, "notification-preference": notificationPreference };
+const UID$1 = "plugin::notifier.notification";
 const accessFilter = (userId, roleCodes = []) => ({
   $or: [
     { recipientId: userId },
@@ -104,99 +154,185 @@ const accessFilter = (userId, roleCodes = []) => ({
     { recipientId: null, recipientRole: null }
   ]
 });
-const notification$2 = ({ strapi }) => ({
-  findByRecipient(userId, roleCodes, { page = 1, pageSize = 20 } = {}) {
-    return strapi.db.query(UID).findMany({
-      where: accessFilter(userId, roleCodes),
-      orderBy: { createdAt: "desc" },
-      limit: pageSize,
-      offset: (page - 1) * pageSize
-    });
-  },
-  countByRecipient(userId, roleCodes) {
-    return strapi.db.query(UID).count({ where: accessFilter(userId, roleCodes) });
-  },
-  countUnread(userId, roleCodes) {
-    return strapi.db.query(UID).count({
-      where: { ...accessFilter(userId, roleCodes), read: false }
-    });
-  },
-  async markAsRead(id, userId, roleCodes) {
-    const existing = await strapi.db.query(UID).findOne({ where: { id, ...accessFilter(userId, roleCodes) } });
-    if (!existing) return null;
-    return strapi.db.query(UID).update({ where: { id }, data: { read: true } });
-  },
-  markAllAsRead(userId, roleCodes) {
-    return strapi.db.query(UID).updateMany({
-      where: { ...accessFilter(userId, roleCodes), read: false },
-      data: { read: true }
-    });
-  },
-  async delete(id, userId, roleCodes) {
-    const existing = await strapi.db.query(UID).findOne({ where: { id, ...accessFilter(userId, roleCodes) } });
-    if (!existing) return null;
-    return strapi.db.query(UID).delete({ where: { id } });
-  },
-  clearAll(userId, roleCodes) {
-    return strapi.db.query(UID).deleteMany({ where: accessFilter(userId, roleCodes) });
-  },
-  create({ title, message, type = "info", url, recipientId, recipientRole }) {
-    return strapi.db.query(UID).create({
-      data: { title, message, type, url, read: false, recipientId, recipientRole }
-    });
-  },
-  /** Retention cleanup: remove notifications older than maxDays and enforce per-user cap. */
-  async cleanupOld(maxDays, maxPerUser) {
-    if (maxDays > 0) {
-      const cutoff = /* @__PURE__ */ new Date();
-      cutoff.setDate(cutoff.getDate() - maxDays);
-      await strapi.db.query(UID).deleteMany({
-        where: { createdAt: { $lt: cutoff.toISOString() } }
+const notification$2 = ({ strapi }) => {
+  const prefSvc = () => strapi.plugin("notifier").service("preference");
+  const optOutFilter = (pref) => {
+    if (pref.mutedTypes.length === 0) return {};
+    return { type: { $notIn: pref.mutedTypes } };
+  };
+  return {
+    async findByRecipient(userId, roleCodes, { page = 1, pageSize = 20 } = {}) {
+      const pref = await prefSvc().get(userId);
+      if (pref.globalOptOut) return [];
+      return strapi.db.query(UID$1).findMany({
+        where: { ...accessFilter(userId, roleCodes), ...optOutFilter(pref) },
+        orderBy: { createdAt: "desc" },
+        limit: pageSize,
+        offset: (page - 1) * pageSize
       });
-    }
-    if (maxPerUser > 0) {
-      const rows = await strapi.db.query(UID).findMany({
-        select: ["recipientId"],
-        where: { recipientId: { $notNull: true } }
+    },
+    async countByRecipient(userId, roleCodes) {
+      const pref = await prefSvc().get(userId);
+      if (pref.globalOptOut) return 0;
+      return strapi.db.query(UID$1).count({
+        where: { ...accessFilter(userId, roleCodes), ...optOutFilter(pref) }
+      });
+    },
+    async countUnread(userId, roleCodes) {
+      const pref = await prefSvc().get(userId);
+      if (pref.globalOptOut) return 0;
+      return strapi.db.query(UID$1).count({
+        where: { ...accessFilter(userId, roleCodes), ...optOutFilter(pref), read: false }
       });
-      const ids = [...new Set(rows.map((r) => r.recipientId))];
-      for (const recipientId of ids) {
-        const total = await strapi.db.query(UID).count({ where: { recipientId } });
-        if (total > maxPerUser) {
-          const excess = await strapi.db.query(UID).findMany({
-            where: { recipientId },
-            orderBy: { createdAt: "asc" },
-            limit: total - maxPerUser,
-            select: ["id"]
-          });
-          const excessIds = excess.map((e) => e.id);
-          await strapi.db.query(UID).deleteMany({ where: { id: { $in: excessIds } } });
+    },
+    async markAsRead(id, userId, roleCodes) {
+      const existing = await strapi.db.query(UID$1).findOne({ where: { id, ...accessFilter(userId, roleCodes) } });
+      if (!existing) return null;
+      return strapi.db.query(UID$1).update({ where: { id }, data: { read: true } });
+    },
+    markAllAsRead(userId, roleCodes) {
+      return strapi.db.query(UID$1).updateMany({
+        where: { ...accessFilter(userId, roleCodes), read: false },
+        data: { read: true }
+      });
+    },
+    async delete(id, userId, roleCodes) {
+      const existing = await strapi.db.query(UID$1).findOne({ where: { id, ...accessFilter(userId, roleCodes) } });
+      if (!existing) return null;
+      return strapi.db.query(UID$1).delete({ where: { id } });
+    },
+    clearAll(userId, roleCodes) {
+      return strapi.db.query(UID$1).deleteMany({ where: accessFilter(userId, roleCodes) });
+    },
+    /**
+     * Find a recent notification with the same merge key and recipient.
+     * Used by the notifier service to decide whether to merge or create.
+     */
+    findMergeCandidate(mergeKey, recipientId, recipientRole, windowMs) {
+      const cutoff = new Date(Date.now() - windowMs);
+      return strapi.db.query(UID$1).findOne({
+        where: {
+          mergeKey,
+          ...recipientId != null ? { recipientId } : { recipientId: null },
+          ...recipientRole != null ? { recipientRole } : { recipientRole: null },
+          createdAt: { $gt: cutoff.toISOString() }
+        },
+        orderBy: { createdAt: "desc" }
+      });
+    },
+    /** Increment mergeCount on an existing notification and optionally rewrite its message. */
+    mergeInto(id, newCount, cfg, title) {
+      const data = { mergeCount: newCount };
+      if (cfg.rewriteMessage) {
+        data.message = `${newCount}× ${title}`;
+      }
+      return strapi.db.query(UID$1).update({ where: { id }, data });
+    },
+    create({ title, message, type = "info", url, recipientId, recipientRole, mergeKey }) {
+      return strapi.db.query(UID$1).create({
+        data: { title, message, type, url, read: false, recipientId, recipientRole, mergeKey, mergeCount: 1 }
+      });
+    },
+    /** Batch-insert multiple notifications in parallel. Does NOT apply opt-out or merge — callers must handle that. */
+    createMany(items) {
+      return Promise.all(items.map((item) => this.create(item)));
+    },
+    /** Retention cleanup: remove notifications older than maxDays and enforce per-user cap. */
+    async cleanupOld(maxDays, maxPerUser) {
+      if (maxDays > 0) {
+        const cutoff = /* @__PURE__ */ new Date();
+        cutoff.setDate(cutoff.getDate() - maxDays);
+        await strapi.db.query(UID$1).deleteMany({
+          where: { createdAt: { $lt: cutoff.toISOString() } }
+        });
+      }
+      if (maxPerUser > 0) {
+        const rows = await strapi.db.query(UID$1).findMany({
+          select: ["recipientId"],
+          where: { recipientId: { $notNull: true } }
+        });
+        const ids = [...new Set(rows.map((r) => r.recipientId))];
+        for (const recipientId of ids) {
+          const total = await strapi.db.query(UID$1).count({ where: { recipientId } });
+          if (total > maxPerUser) {
+            const excess = await strapi.db.query(UID$1).findMany({
+              where: { recipientId },
+              orderBy: { createdAt: "asc" },
+              limit: total - maxPerUser,
+              select: ["id"]
+            });
+            const excessIds = excess.map((e) => e.id);
+            await strapi.db.query(UID$1).deleteMany({ where: { id: { $in: excessIds } } });
+          }
         }
       }
     }
-  }
-});
+  };
+};
 const notifier = ({ strapi }) => {
   const svc = () => strapi.plugin("notifier").service("notification");
-  return {
-    send({ title, message, type, url, to }) {
+  const prefSvc = () => strapi.plugin("notifier").service("preference");
+  const settingsSvc = () => strapi.plugin("notifier").service("settings");
+  const computeMergeKey = (opts, keyFields) => keyFields.map((f) => opts[f] ?? "").join("\0");
+  const applySend = async (opts, mergeCfg) => {
+    const recipientId = opts.to?.userId ?? null;
+    const recipientRole = opts.to?.role ?? null;
+    const type = opts.type ?? "info";
+    if (recipientId != null) {
+      const pref = await prefSvc().get(recipientId);
+      if (prefSvc().isOptedOut(pref, type)) return null;
+    }
+    if (mergeCfg.enabled) {
+      const mergeKey = computeMergeKey(opts, mergeCfg.keyFields);
+      const windowMs = mergeCfg.windowMinutes * 60 * 1e3;
+      const candidate = await svc().findMergeCandidate(mergeKey, recipientId, recipientRole, windowMs);
+      if (candidate) {
+        const newCount = (candidate.mergeCount ?? 1) + 1;
+        return svc().mergeInto(candidate.id, newCount, mergeCfg, opts.title);
+      }
       return svc().create({
-        title,
-        message,
+        title: opts.title,
+        message: opts.message,
         type,
-        url,
-        recipientId: to?.userId,
-        recipientRole: to?.role
+        url: opts.url,
+        recipientId: recipientId ?? void 0,
+        recipientRole: recipientRole ?? void 0,
+        mergeKey
       });
+    }
+    return svc().create({
+      title: opts.title,
+      message: opts.message,
+      type,
+      url: opts.url,
+      recipientId: recipientId ?? void 0,
+      recipientRole: recipientRole ?? void 0
+    });
+  };
+  return {
+    async send(opts) {
+      const { merge } = await settingsSvc().getEffective();
+      return applySend(opts, merge);
+    },
+    async broadcast(opts) {
+      const { merge } = await settingsSvc().getEffective();
+      return applySend(opts, merge);
     },
-    broadcast(opts) {
-      return svc().create({ ...opts });
+    async toRole(role, opts) {
+      const { merge } = await settingsSvc().getEffective();
+      return applySend({ ...opts, to: { role } }, merge);
     },
-    toRole(role, opts) {
-      return svc().create({ ...opts, recipientRole: role });
+    async toUser(userId, opts) {
+      const { merge } = await settingsSvc().getEffective();
+      return applySend({ ...opts, to: { userId } }, merge);
     },
-    toUser(userId, opts) {
-      return svc().create({ ...opts, recipientId: userId });
+    /**
+     * Send multiple notifications in one call. Opt-out and merge are applied per item.
+     * Settings are fetched once and reused across all items.
+     */
+    async sendBatch(items) {
+      const { merge } = await settingsSvc().getEffective();
+      return Promise.all(items.map((item) => applySend(item, merge)));
     }
   };
 };
@@ -209,6 +345,13 @@ const DEFAULT_SETTINGS = {
     defaultRecipient: "broadcast",
     allowedRoles: []
   },
+  merge: {
+    enabled: false,
+    windowMinutes: 60,
+    keyFields: ["title", "type"],
+    countBadge: true,
+    rewriteMessage: false
+  },
   ui: {
     pollInterval: 3e4,
     pageSize: 20,
@@ -231,6 +374,7 @@ const DEFAULT_SETTINGS = {
 const mergeWithDefaults = (overrides = {}) => ({
   retention: { ...DEFAULT_SETTINGS.retention, ...overrides.retention ?? {} },
   delivery: { ...DEFAULT_SETTINGS.delivery, ...overrides.delivery ?? {} },
+  merge: { ...DEFAULT_SETTINGS.merge, ...overrides.merge ?? {} },
   ui: {
     ...DEFAULT_SETTINGS.ui,
     ...overrides.ui ?? {},
@@ -262,6 +406,7 @@ const settings$2 = ({ strapi }) => ({
     return {
       retention: { ...withPluginsConfig.retention, ...fromStore.retention ?? {} },
       delivery: { ...withPluginsConfig.delivery, ...fromStore.delivery ?? {} },
+      merge: { ...withPluginsConfig.merge, ...fromStore.merge ?? {} },
       ui: {
         ...withPluginsConfig.ui,
         ...fromStore.ui ?? {},
@@ -283,6 +428,7 @@ const settings$2 = ({ strapi }) => ({
     const next = {
       retention: { ...current.retention, ...patch.retention ?? {} },
       delivery: { ...current.delivery, ...patch.delivery ?? {} },
+      merge: { ...current.merge, ...patch.merge ?? {} },
       ui: {
         ...current.ui,
         ...patch.ui ?? {},
@@ -302,7 +448,49 @@ const settings$2 = ({ strapi }) => ({
     await getStore(strapi).delete({ key: STORE_KEY });
   }
 });
-const services = { notification: notification$2, notifier, settings: settings$2 };
+const UID = "plugin::notifier.notification-preference";
+const DEFAULT_PREF = (userId) => ({
+  userId,
+  globalOptOut: false,
+  mutedTypes: []
+});
+const preference$2 = ({ strapi }) => ({
+  async get(userId) {
+    const row = await strapi.db.query(UID).findOne({ where: { userId } });
+    if (!row) return DEFAULT_PREF(userId);
+    return {
+      userId: row.userId,
+      globalOptOut: row.globalOptOut ?? false,
+      mutedTypes: row.mutedTypes ?? []
+    };
+  },
+  async upsert(userId, patch) {
+    const existing = await strapi.db.query(UID).findOne({ where: { userId } });
+    if (existing) {
+      const updated = await strapi.db.query(UID).update({
+        where: { id: existing.id },
+        data: patch
+      });
+      return {
+        userId: updated.userId,
+        globalOptOut: updated.globalOptOut ?? false,
+        mutedTypes: updated.mutedTypes ?? []
+      };
+    }
+    const created = await strapi.db.query(UID).create({
+      data: { userId, globalOptOut: false, mutedTypes: [], ...patch }
+    });
+    return {
+      userId: created.userId,
+      globalOptOut: created.globalOptOut ?? false,
+      mutedTypes: created.mutedTypes ?? []
+    };
+  },
+  isOptedOut(pref, type) {
+    return pref.globalOptOut || pref.mutedTypes.includes(type);
+  }
+});
+const services = { notification: notification$2, notifier, settings: settings$2, preference: preference$2 };
 const getUserRoleCodes = async (strapi, userId) => {
   const user = await strapi.db.query("admin::user").findOne({
     where: { id: userId },
@@ -383,7 +571,25 @@ const settings$1 = ({ strapi }) => ({
     ctx.body = { data: defaults };
   }
 });
-const controllers = { notification: notification$1, config: config$1, settings: settings$1 };
+const preference$1 = ({ strapi }) => ({
+  async findMine(ctx) {
+    const adminUser = ctx.state.user;
+    if (!adminUser) return ctx.unauthorized();
+    const pref = await strapi.plugin("notifier").service("preference").get(adminUser.id);
+    ctx.body = { data: pref };
+  },
+  async updateMine(ctx) {
+    const adminUser = ctx.state.user;
+    if (!adminUser) return ctx.unauthorized();
+    const { globalOptOut, mutedTypes } = ctx.request.body;
+    const patch = {};
+    if (typeof globalOptOut === "boolean") patch.globalOptOut = globalOptOut;
+    if (Array.isArray(mutedTypes)) patch.mutedTypes = mutedTypes;
+    const updated = await strapi.plugin("notifier").service("preference").upsert(adminUser.id, patch);
+    ctx.body = { data: updated };
+  }
+});
+const controllers = { notification: notification$1, config: config$1, settings: settings$1, preference: preference$1 };
 const notification = {
   type: "admin",
   routes: [
@@ -453,7 +659,24 @@ const settings = {
     }
   ]
 };
-const adminRoutes = { notification, config, settings };
+const preference = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/preferences/me",
+      handler: "preference.findMine",
+      config: { policies: ["admin::isAuthenticatedAdmin"] }
+    },
+    {
+      method: "PUT",
+      path: "/preferences/me",
+      handler: "preference.updateMine",
+      config: { policies: ["admin::isAuthenticatedAdmin"] }
+    }
+  ]
+};
+const adminRoutes = { notification, config, settings, preference };
 const index = {
   register,
   bootstrap,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strapi-plugin-notifier",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "A highly configurable notification inbox plugin for the Strapi v5 admin panel",
   "keywords": [
     "strapi",
@@ -41,6 +41,8 @@
     "watch": "npx strapi-plugin watch",
     "watch:link": "npx strapi-plugin watch:link",
     "verify": "npx strapi-plugin verify",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "prepublishOnly": "npm run build"
   },
   "devDependencies": {
@@ -58,7 +60,8 @@
     "react-dom": "^18.0.0",
     "react-router-dom": "^6.0.0",
     "styled-components": "^6.4.2",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^4.1.8"
   },
   "peerDependencies": {
     "@strapi/admin": "^5.0.0",

package/tests/helpers.ts

@@ -0,0 +1,145 @@
+import { vi } from 'vitest';
+import type { NotificationType } from '../server/src/config';
+import type { UserPreference } from '../server/src/services/preference';
+
+// ---------------------------------------------------------------------------
+// DB query mock
+// ---------------------------------------------------------------------------
+
+export const makeDbQuery = (overrides: Record<string, unknown> = {}) => ({
+  findOne: vi.fn().mockResolvedValue(null),
+  findMany: vi.fn().mockResolvedValue([]),
+  create: vi.fn().mockImplementation(({ data }: { data: Record<string, unknown> }) =>
+    Promise.resolve({ id: 1, ...data })
+  ),
+  update: vi.fn().mockImplementation(({ data }: { data: Record<string, unknown> }) =>
+    Promise.resolve({ id: 1, ...data })
+  ),
+  updateMany: vi.fn().mockResolvedValue({ count: 0 }),
+  delete: vi.fn().mockResolvedValue({ id: 1 }),
+  deleteMany: vi.fn().mockResolvedValue({ count: 0 }),
+  count: vi.fn().mockResolvedValue(0),
+  ...overrides,
+});
+
+// ---------------------------------------------------------------------------
+// Preference helpers
+// ---------------------------------------------------------------------------
+
+export const makeDefaultPref = (overrides: Partial<UserPreference> = {}): UserPreference => ({
+  userId: 1,
+  globalOptOut: false,
+  mutedTypes: [],
+  ...overrides,
+});
+
+export const makePrefService = (prefOverrides: Partial<UserPreference> = {}) => {
+  const pref = makeDefaultPref(prefOverrides);
+  return {
+    get: vi.fn().mockResolvedValue(pref),
+    isOptedOut: (p: UserPreference, type: NotificationType) =>
+      p.globalOptOut || p.mutedTypes.includes(type),
+    upsert: vi.fn().mockResolvedValue(pref),
+  };
+};
+
+// ---------------------------------------------------------------------------
+// Notification service mock (for notifier tests)
+// ---------------------------------------------------------------------------
+
+export const makeNotificationService = (overrides: Record<string, unknown> = {}) => ({
+  create: vi.fn().mockResolvedValue({ id: 1, mergeCount: 1 }),
+  createMany: vi.fn().mockResolvedValue([{ id: 1 }]),
+  findMergeCandidate: vi.fn().mockResolvedValue(null),
+  mergeInto: vi.fn().mockResolvedValue({ id: 1, mergeCount: 2 }),
+  findByRecipient: vi.fn().mockResolvedValue([]),
+  countByRecipient: vi.fn().mockResolvedValue(0),
+  countUnread: vi.fn().mockResolvedValue(0),
+  markAsRead: vi.fn().mockResolvedValue({ id: 1, read: true }),
+  markAllAsRead: vi.fn().mockResolvedValue({}),
+  delete: vi.fn().mockResolvedValue({ id: 1 }),
+  clearAll: vi.fn().mockResolvedValue({}),
+  ...overrides,
+});
+
+// ---------------------------------------------------------------------------
+// Settings mock
+// ---------------------------------------------------------------------------
+
+export const makeSettingsService = (overrides: Record<string, unknown> = {}) => ({
+  getEffective: vi.fn().mockResolvedValue({
+    retention: { maxDays: 90, maxPerUser: 500 },
+    delivery: { defaultRecipient: 'broadcast', allowedRoles: [] },
+    merge: {
+      enabled: false,
+      windowMinutes: 60,
+      keyFields: ['title', 'type'],
+      countBadge: true,
+      rewriteMessage: false,
+    },
+    ui: {
+      pollInterval: 30000,
+      pageSize: 20,
+      defaultFilter: 'all',
+      badge: { enabled: true, color: '#ee5e52' },
+      theme: {
+        bellSize: '1.5em',
+        accent: { info: '#4945ff', success: '#328048', warning: '#d97706', error: '#d02b20' },
+      },
+    },
+    ...overrides,
+  }),
+  get: vi.fn(),
+  update: vi.fn(),
+  reset: vi.fn(),
+});
+
+// ---------------------------------------------------------------------------
+// Strapi instance mocks
+// ---------------------------------------------------------------------------
+
+/** Minimal strapi mock for notification service tests. */
+export const makeNotificationStrapi = (
+  dbOverrides: Record<string, unknown> = {},
+  prefOverrides: Partial<UserPreference> = {}
+) => {
+  const db = makeDbQuery(dbOverrides);
+  const prefSvc = makePrefService(prefOverrides);
+  const strapi = {
+    db: { query: vi.fn().mockReturnValue(db) },
+    plugin: vi.fn().mockReturnValue({ service: vi.fn().mockReturnValue(prefSvc) }),
+  };
+  return { strapi, _db: db, _prefSvc: prefSvc };
+};
+
+/** Minimal strapi mock for preference service tests. */
+export const makePreferenceStrapi = (dbOverrides: Record<string, unknown> = {}) => {
+  const db = makeDbQuery(dbOverrides);
+  const strapi = { db: { query: vi.fn().mockReturnValue(db) } };
+  return { strapi, _db: db };
+};
+
+/** Minimal strapi mock for notifier service tests. */
+export const makeNotifierStrapi = (
+  notifOverrides: Record<string, unknown> = {},
+  prefOverrides: Partial<UserPreference> = {},
+  settingsOverrides: Record<string, unknown> = {}
+) => {
+  const notifSvc = makeNotificationService(notifOverrides);
+  const prefSvc = makePrefService(prefOverrides);
+  const settSvc = makeSettingsService(settingsOverrides);
+
+  const serviceMap: Record<string, unknown> = {
+    notification: notifSvc,
+    preference: prefSvc,
+    settings: settSvc,
+  };
+
+  const strapi = {
+    plugin: vi.fn().mockReturnValue({
+      service: vi.fn().mockImplementation((name: string) => serviceMap[name]),
+    }),
+  };
+
+  return { strapi, _notifSvc: notifSvc, _prefSvc: prefSvc, _settSvc: settSvc };
+};