strapi-plugin-notifier 1.0.3 → 1.2.0

package/dist/server/index.js

@@ -14,19 +14,6 @@ const register = async ({ strapi }) => {
       pluginName: "notifier"
     }
   ]);
-  strapi.cron.add({
-    notifierCleanup: {
-      task: async ({ strapi: s }) => {
-        const settings2 = await s.plugin("notifier").service("settings").getEffective();
-        const { maxDays, maxPerUser } = settings2.retention;
-        await s.plugin("notifier").service("notification").cleanupOld(maxDays, maxPerUser);
-      },
-      options: {
-        rule: "0 3 * * *"
-        // 3 AM daily — configurable in cron settings if needed
-      }
-    }
-  });
 };
 const bootstrap = async ({ strapi }) => {
   const stored = await strapi.store({ environment: "", type: "plugin", name: "notifier" }).get({ key: "settings" });
@@ -34,19 +21,34 @@ const bootstrap = async ({ strapi }) => {
     const effective = await strapi.plugin("notifier").service("settings").getEffective();
     await strapi.store({ environment: "", type: "plugin", name: "notifier" }).set({ key: "settings", value: effective });
   }
+  const pluginConfig = strapi.config.get("plugin::notifier", {});
+  const rules2 = pluginConfig.rules ?? [];
+  if (rules2.length > 0) {
+    strapi.plugin("notifier").service("rules").setup(rules2);
+  }
+  const { retention } = await strapi.plugin("notifier").service("settings").getEffective();
+  strapi.cron.add({
+    notifierCleanup: {
+      task: async ({ strapi: s }) => {
+        const s_retention = (await s.plugin("notifier").service("settings").getEffective()).retention;
+        await s.plugin("notifier").service("notification").cleanupOld(s_retention.maxDays, s_retention.maxPerUser);
+      },
+      options: { rule: retention.cleanupCron }
+    }
+  });
 };
-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
   },
@@ -54,7 +56,7 @@ const pluginOptions = {
     visible: false
   }
 };
-const attributes = {
+const attributes$1 = {
   title: {
     type: "string",
     required: true
@@ -85,6 +87,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 = {
@@ -95,9 +147,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 },
@@ -105,111 +157,205 @@ 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)));
     }
   };
 };
 const DEFAULT_SETTINGS = {
   retention: {
     maxDays: 90,
-    maxPerUser: 500
+    maxPerUser: 500,
+    cleanupCron: "0 3 * * *"
   },
   delivery: {
     defaultRecipient: "broadcast",
     allowedRoles: []
   },
+  merge: {
+    enabled: false,
+    windowMinutes: 60,
+    keyFields: ["title", "type"],
+    countBadge: true,
+    rewriteMessage: false
+  },
   ui: {
     pollInterval: 3e4,
     pageSize: 20,
@@ -232,6 +378,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 ?? {},
@@ -263,6 +410,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 ?? {},
@@ -284,6 +432,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 ?? {},
@@ -303,7 +452,150 @@ 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);
+  }
+});
+function getByPath(obj, path) {
+  return path.split(".").reduce((acc, key) => {
+    if (acc == null || typeof acc !== "object") return void 0;
+    return acc[key];
+  }, obj);
+}
+function interpolate(template, ctx) {
+  return template.replace(/\{\{([^}]+)\}\}/g, (_, path) => {
+    const val = getByPath(ctx, path.trim());
+    return val == null ? "" : String(val);
+  });
+}
+function resolveStr(tpl, ctx, flat) {
+  return typeof tpl === "function" ? tpl(ctx) : interpolate(tpl, flat);
+}
+function resolve(tpl, ctx) {
+  return typeof tpl === "function" ? tpl(ctx) : tpl;
+}
+function resolveTarget(tpl, ctx, flat) {
+  const target = typeof tpl === "function" ? tpl(ctx) : tpl;
+  if (!target || target === "broadcast") return {};
+  if ("userId" in target) return { to: { userId: target.userId } };
+  if ("role" in target) return { to: { role: target.role } };
+  if ("userIdFrom" in target) {
+    const val = getByPath(flat, target.userIdFrom);
+    if (val != null) return { to: { userId: Number(val) } };
+  }
+  return {};
+}
+async function fire(strapi, notification2, ctx) {
+  const flat = ctx;
+  const title = resolveStr(notification2.title, ctx, flat);
+  const message = notification2.message ? resolveStr(notification2.message, ctx, flat) : void 0;
+  const type = resolve(notification2.type, ctx) ?? "info";
+  const url = notification2.url ? resolveStr(notification2.url, ctx, flat) : void 0;
+  const targeting = resolveTarget(notification2.to, ctx, flat);
+  await strapi.plugin("notifier").service("notifier").send({
+    title,
+    ...message !== void 0 && { message },
+    type,
+    ...url !== void 0 && { url },
+    ...targeting
+  });
+}
+const rules = ({ strapi }) => ({
+  setup(rules2) {
+    for (const rule of rules2) {
+      if (rule.on === "lifecycle") {
+        const { model, action, when, notification: notification2 } = rule;
+        strapi.db.lifecycles.subscribe({
+          models: [model],
+          async [action](event) {
+            try {
+              const ctx = {
+                entry: event.result ?? event.params?.data ?? {},
+                params: event.params,
+                model
+              };
+              if (when && !when(ctx)) return;
+              await fire(strapi, notification2, ctx);
+            } catch (err) {
+              strapi.log.error(`[notifier] lifecycle rule ${model}:${action} failed — ${err}`);
+            }
+          }
+        });
+      } else if (rule.on === "event") {
+        const { event, filter, when, notification: notification2 } = rule;
+        strapi.eventHub.on(event, async (data) => {
+          try {
+            if (filter) {
+              for (const [k, v] of Object.entries(filter)) {
+                if (data[k] !== v) return;
+              }
+            }
+            const ctx = { event, ...data };
+            if (when && !when(ctx)) return;
+            await fire(strapi, notification2, ctx);
+          } catch (err) {
+            strapi.log.error(`[notifier] event rule "${event}" failed — ${err}`);
+          }
+        });
+      } else if (rule.on === "cron") {
+        const { schedule, notification: notification2 } = rule;
+        const key = `notifierCron_${Math.random().toString(36).slice(2, 9)}`;
+        strapi.cron.add({
+          [key]: {
+            task: async ({ strapi: s }) => {
+              try {
+                const ctx = { scheduledAt: /* @__PURE__ */ new Date() };
+                await fire(s, notification2, ctx);
+              } catch (err) {
+                strapi.log.error(`[notifier] cron rule "${schedule}" failed — ${err}`);
+              }
+            },
+            options: { rule: schedule }
+          }
+        });
+      }
+    }
+  }
+});
+const services = { notification: notification$2, notifier, settings: settings$2, preference: preference$2, rules };
 const getUserRoleCodes = async (strapi, userId) => {
   const user = await strapi.db.query("admin::user").findOne({
     where: { id: userId },
@@ -384,7 +676,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: [
@@ -454,7 +764,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,