strapi-plugin-notifier 1.1.0 → 1.2.1

package/README.md

@@ -10,9 +10,10 @@ A first-class notification system for Strapi v5 admin panels. Adds a live bell i
 - **Batch sending** — send multiple notifications in one call, settings fetched once
 - **Merge** — collapse repeated notifications into one item with a count badge (fully configurable)
 - **User opt-out** — each admin user can mute individual notification types or opt out entirely
-- **Configurable** — poll interval, page size, retention policy, UI accent colours, and merge rules
+- **Declarative rules** — trigger notifications from lifecycle hooks, eventHub events, or cron schedules — no code required beyond `config/plugins.ts`
+- **Configurable** — poll interval, page size, retention policy, UI accent colours, merge rules, and cleanup schedule
 - **Settings panel** — runtime configuration via Settings → Notifier (persisted in Strapi plugin store)
-- **Retention cron** — daily cleanup at 3 AM, respects maxDays and maxPerUser limits
+- **Retention cron** — configurable cleanup schedule (default: 3 AM daily), respects maxDays and maxPerUser limits
 - **Strapi v5 only**
 
 ## Installation
@@ -47,8 +48,9 @@ export default {
     enabled: true,
     config: {
       retention: {
-        maxDays: 90,       // delete notifications older than N days
-        maxPerUser: 500,   // cap notifications stored per user
+        maxDays: 90,          // delete notifications older than N days
+        maxPerUser: 500,      // cap notifications stored per user
+        cleanupCron: '0 3 * * *', // cron schedule for cleanup job (default: 3 AM daily)
       },
       delivery: {
         pollIntervalMs: 30_000, // how often the Bell polls (ms)
@@ -214,6 +216,161 @@ Content-Type: application/json
 | `globalOptOut` | `boolean`          | `false` | Suppress all notifications for this user       |
 | `mutedTypes`   | `NotificationType[]` | `[]`  | Suppress only these notification types        |
 
+## Declarative rules
+
+Instead of calling the notifier service in code, you can declare rules in `config/plugins.ts`. The plugin wires up the listeners at bootstrap — notifications fire automatically with no further code changes needed.
+
+Three trigger types are supported: `lifecycle`, `event`, and `cron`.
+
+### `on: 'lifecycle'` — content-type create/update/delete
+
+Fires when Strapi's DB lifecycle executes for a given content-type and action.
+
+```typescript
+// config/plugins.ts
+notifier: {
+  enabled: true,
+  config: {
+    rules: [
+      {
+        on: 'lifecycle',
+        model: 'api::article.article',
+        action: 'afterCreate',          // afterCreate | afterUpdate | afterDelete | afterPublish | afterUnpublish
+        notification: {
+          title: 'New article: {{entry.title}}',
+          message: 'Created by {{entry.createdBy.firstname}}',
+          type: 'info',
+          to: { role: 'strapi-editor' },
+        },
+      },
+    ],
+  },
+},
+```
+
+`entry` in templates is the DB record produced by the lifecycle action (`result` for after-hooks, `params.data` for before-hooks).
+
+### `on: 'event'` — strapi.eventHub subscription
+
+Fires on any named event published to Strapi's internal event hub (lifecycle events, media events, plugin events, or your own custom events emitted with `strapi.eventHub.emit()`).
+
+```typescript
+{
+  on: 'event',
+  event: 'media.upload',              // any strapi.eventHub event name
+  filter: { uid: 'api::article.article' }, // optional shallow key=value filter on payload
+  notification: {
+    title: 'File uploaded: {{media.name}}',
+    type: 'info',
+    to: 'broadcast',
+  },
+},
+```
+
+**Custom events from your own services:**
+
+```typescript
+// In your service
+strapi.eventHub.emit('order.placed', { order });
+
+// In config/plugins.ts
+{
+  on: 'event',
+  event: 'order.placed',
+  notification: {
+    title: 'New order: #{{order.id}}',
+    message: '{{order.customerName}} — €{{order.total}}',
+    type: 'success',
+    to: { role: 'strapi-super-admin' },
+  },
+},
+```
+
+### `on: 'cron'` — time-based notifications
+
+Fires on a cron schedule. Standard 5-field cron expressions.
+
+```typescript
+{
+  on: 'cron',
+  schedule: '0 9 * * 1',   // Every Monday at 9 AM
+  notification: {
+    title: 'Weekly reminder: review pending content',
+    type: 'warning',
+    to: { role: 'strapi-editor' },
+  },
+},
+```
+
+### Notification templates
+
+Every field in `notification` accepts either a **static value** or a **function** for dynamic content.
+
+**String interpolation** — use `{{path.to.field}}` dot-notation to resolve values from the event context:
+
+```typescript
+notification: {
+  title: 'New order from {{entry.customer.name}}',
+  message: 'Total: {{entry.total}} — shipped to {{entry.address.city}}',
+}
+```
+
+**Function templates** — for logic that can't be expressed as a template string:
+
+```typescript
+notification: {
+  title: (ctx) => `${ctx.entry.priority === 'high' ? '🔴' : ''} Order #${ctx.entry.id}`,
+  type: (ctx) => ctx.entry.priority === 'high' ? 'error' : 'info',
+}
+```
+
+### Targeting in rules
+
+The `to` field supports the same options as the programmatic API, plus a `userIdFrom` path resolver:
+
+| Value                       | Behaviour                                               |
+|-----------------------------|---------------------------------------------------------|
+| `'broadcast'` (or omitted)  | Send to all admin users                                 |
+| `{ role: 'strapi-editor' }` | Send to all users with this role code                   |
+| `{ userId: 42 }`            | Send to a specific admin user                           |
+| `{ userIdFrom: 'entry.createdBy.id' }` | Resolve user ID via dot-path into the event context — useful for "notify the author" patterns |
+
+```typescript
+// Notify the author when their content is rejected
+{
+  on: 'lifecycle',
+  model: 'api::article.article',
+  action: 'afterUpdate',
+  when: (ctx) => ctx.entry.status === 'rejected',
+  notification: {
+    title: 'Your article was rejected',
+    to: { userIdFrom: 'entry.createdBy.id' },
+  },
+},
+```
+
+### `when` guard
+
+Add a `when` function to conditionally skip the notification. Return `false` to suppress it.
+
+```typescript
+{
+  on: 'lifecycle',
+  model: 'api::article.article',
+  action: 'afterUpdate',
+  when: (ctx) => ctx.entry.publishedAt != null,   // only fire when published
+  notification: {
+    title: 'Article published: {{entry.title}}',
+    type: 'success',
+    to: 'broadcast',
+  },
+},
+```
+
+`when` is not available on `cron` rules (there is no event context to filter on).
+
+---
+
 ## API routes
 
 All routes require `admin::isAuthenticatedAdmin`. The plugin mounts under `/notifier/`.

package/dist/_chunks/{Index-_PTtaZsz.mjs → Index-1ChU1M3b.mjs}

@@ -2,7 +2,7 @@ import { jsxs, jsx } from "react/jsx-runtime";
 import { useState, useRef, useCallback, useEffect } from "react";
 import { Box, Flex, Typography, Button, IconButton, Loader } from "@strapi/design-system";
 import { useFetchClient } from "@strapi/admin/strapi-admin";
-import { g as getConfig, s as setNotifications, a as getNotifications, m as markAsRead, b as markAllAsRead, c as clearNotification, d as clearAll, e as subscribeToNotifications, u as usePluginConfig } from "./index-BgPnE501.mjs";
+import { g as getConfig, s as setNotifications, a as getNotifications, m as markAsRead, b as markAllAsRead, c as clearNotification, d as clearAll, e as subscribeToNotifications, u as usePluginConfig } from "./index-BauNAWBC.mjs";
 import { Cross } from "@strapi/icons";
 const toStoreItem = (n) => ({
   id: String(n.id),
@@ -186,7 +186,7 @@ function NotificationItem({
       style: {
         borderLeft: `4px solid ${accent}`,
         backgroundColor: bg,
-        cursor: notification.url ? "pointer" : "default",
+        cursor: "pointer",
         transition: "background 0.15s"
       },
       padding: 4,
@@ -222,8 +222,8 @@ function NotificationItem({
             ),
             notification.url && /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral500", children: "↗" })
           ] }),
-          notification.message && /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral600", style: { marginTop: 2 }, children: notification.message }),
-          /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral400", style: { marginTop: 4 }, children: new Date(notification.createdAt).toLocaleString() })
+          notification.message && /* @__PURE__ */ jsx(Box, { paddingTop: 1, children: /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral600", children: notification.message }) }),
+          /* @__PURE__ */ jsx(Box, { paddingTop: 2, children: /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral400", children: new Date(notification.createdAt).toLocaleString() }) })
         ] }),
         /* @__PURE__ */ jsx(
           IconButton,

package/dist/_chunks/{Index-DVk2enQ2.js → Index-cFnGw4rg.js}

@@ -4,7 +4,7 @@ const jsxRuntime = require("react/jsx-runtime");
 const react = require("react");
 const designSystem = require("@strapi/design-system");
 const strapiAdmin = require("@strapi/admin/strapi-admin");
-const index = require("./index-CKh_iBP2.js");
+const index = require("./index-BMiYJk-5.js");
 const icons = require("@strapi/icons");
 const toStoreItem = (n) => ({
   id: String(n.id),
@@ -188,7 +188,7 @@ function NotificationItem({
       style: {
         borderLeft: `4px solid ${accent}`,
         backgroundColor: bg,
-        cursor: notification.url ? "pointer" : "default",
+        cursor: "pointer",
         transition: "background 0.15s"
       },
       padding: 4,
@@ -224,8 +224,8 @@ function NotificationItem({
             ),
             notification.url && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral500", children: "↗" })
           ] }),
-          notification.message && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral600", style: { marginTop: 2 }, children: notification.message }),
-          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral400", style: { marginTop: 4 }, children: new Date(notification.createdAt).toLocaleString() })
+          notification.message && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 1, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral600", children: notification.message }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 2, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral400", children: new Date(notification.createdAt).toLocaleString() }) })
         ] }),
         /* @__PURE__ */ jsxRuntime.jsx(
           designSystem.IconButton,

package/dist/_chunks/{SettingsPage-DYxNBA3h.js → SettingsPage-DKTIHVrI.js}

@@ -5,7 +5,7 @@ const react = require("react");
 const designSystem = require("@strapi/design-system");
 const strapiAdmin = require("@strapi/admin/strapi-admin");
 const DEFAULT = {
-  retention: { maxDays: 90, maxPerUser: 500 },
+  retention: { maxDays: 90, maxPerUser: 500, cleanupCron: "0 3 * * *" },
   delivery: { pollIntervalMs: 3e4, pageSize: 20 },
   merge: {
     enabled: false,
@@ -104,7 +104,16 @@ function SettingsPage() {
             style: { flex: 1 }
           }
         )
-      ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 4, children: /* @__PURE__ */ jsxRuntime.jsx(
+        designSystem.TextInput,
+        {
+          label: "Cleanup schedule (cron)",
+          hint: 'Standard 5-field cron expression. Default "0 3 * * *" runs at 3 AM daily. Takes effect on next restart.',
+          value: settings.retention.cleanupCron,
+          onChange: (e) => set("retention.cleanupCron", e.target.value)
+        }
+      ) })
     ] }),
     /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { background: "neutral0", padding: 6, hasRadius: true, marginTop: 4, children: [
       /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "delta", paddingBottom: 4, as: "h2", children: "Delivery" }),

package/dist/_chunks/{SettingsPage-CuTIslG0.mjs → SettingsPage-DVaHqffU.mjs}

@@ -1,9 +1,9 @@
 import { jsxs, jsx, Fragment } from "react/jsx-runtime";
 import { useState, useEffect } from "react";
-import { Box, Flex, Typography, Button, NumberInput, Toggle, Divider, Checkbox, TextInput } from "@strapi/design-system";
+import { Box, Flex, Typography, Button, NumberInput, TextInput, Toggle, Divider, Checkbox } from "@strapi/design-system";
 import { useFetchClient } from "@strapi/admin/strapi-admin";
 const DEFAULT = {
-  retention: { maxDays: 90, maxPerUser: 500 },
+  retention: { maxDays: 90, maxPerUser: 500, cleanupCron: "0 3 * * *" },
   delivery: { pollIntervalMs: 3e4, pageSize: 20 },
   merge: {
     enabled: false,
@@ -102,7 +102,16 @@ function SettingsPage() {
             style: { flex: 1 }
           }
         )
-      ] })
+      ] }),
+      /* @__PURE__ */ jsx(Box, { paddingTop: 4, children: /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          label: "Cleanup schedule (cron)",
+          hint: 'Standard 5-field cron expression. Default "0 3 * * *" runs at 3 AM daily. Takes effect on next restart.',
+          value: settings.retention.cleanupCron,
+          onChange: (e) => set("retention.cleanupCron", e.target.value)
+        }
+      ) })
     ] }),
     /* @__PURE__ */ jsxs(Box, { background: "neutral0", padding: 6, hasRadius: true, marginTop: 4, children: [
       /* @__PURE__ */ jsx(Typography, { variant: "delta", paddingBottom: 4, as: "h2", children: "Delivery" }),

package/dist/_chunks/{index-CKh_iBP2.js → index-BMiYJk-5.js}

@@ -177,7 +177,7 @@ const index = {
         defaultMessage: "Notifications"
       },
       permissions: [],
-      Component: () => Promise.resolve().then(() => require("./Index-DVk2enQ2.js"))
+      Component: () => Promise.resolve().then(() => require("./Index-cFnGw4rg.js"))
     });
     app.createSettingSection(
       {
@@ -195,7 +195,7 @@ const index = {
           },
           id: `${pluginId}.settings`,
           to: `/settings/${pluginId}`,
-          Component: () => Promise.resolve().then(() => require("./SettingsPage-DYxNBA3h.js")),
+          Component: () => Promise.resolve().then(() => require("./SettingsPage-DKTIHVrI.js")),
           permissions: [
             { action: `plugin::${pluginId}.settings.read`, subject: null }
           ]

package/dist/_chunks/{index-BgPnE501.mjs → index-BauNAWBC.mjs}

@@ -176,7 +176,7 @@ const index = {
         defaultMessage: "Notifications"
       },
       permissions: [],
-      Component: () => import("./Index-_PTtaZsz.mjs")
+      Component: () => import("./Index-1ChU1M3b.mjs")
     });
     app.createSettingSection(
       {
@@ -194,7 +194,7 @@ const index = {
           },
           id: `${pluginId}.settings`,
           to: `/settings/${pluginId}`,
-          Component: () => import("./SettingsPage-CuTIslG0.mjs"),
+          Component: () => import("./SettingsPage-DVaHqffU.mjs"),
           permissions: [
             { action: `plugin::${pluginId}.settings.read`, subject: null }
           ]

package/dist/admin/index.js

@@ -1,3 +1,3 @@
 "use strict";
-const index = require("../_chunks/index-CKh_iBP2.js");
+const index = require("../_chunks/index-BMiYJk-5.js");
 module.exports = index.index;

package/dist/admin/index.mjs

@@ -1,4 +1,4 @@
-import { i } from "../_chunks/index-BgPnE501.mjs";
+import { i } from "../_chunks/index-BauNAWBC.mjs";
 export {
   i as default
 };

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,6 +21,21 @@ 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$1 = "collectionType";
 const collectionName$1 = "notifier_notifications";
@@ -340,7 +342,8 @@ const notifier = ({ strapi }) => {
 const DEFAULT_SETTINGS = {
   retention: {
     maxDays: 90,
-    maxPerUser: 500
+    maxPerUser: 500,
+    cleanupCron: "0 3 * * *"
   },
   delivery: {
     defaultRecipient: "broadcast",
@@ -491,7 +494,108 @@ const preference$2 = ({ strapi }) => ({
     return pref.globalOptOut || pref.mutedTypes.includes(type);
   }
 });
-const services = { notification: notification$2, notifier, settings: settings$2, preference: preference$2 };
+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 },

package/dist/server/index.mjs

@@ -13,19 +13,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" });
@@ -33,6 +20,21 @@ 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$1 = "collectionType";
 const collectionName$1 = "notifier_notifications";
@@ -339,7 +341,8 @@ const notifier = ({ strapi }) => {
 const DEFAULT_SETTINGS = {
   retention: {
     maxDays: 90,
-    maxPerUser: 500
+    maxPerUser: 500,
+    cleanupCron: "0 3 * * *"
   },
   delivery: {
     defaultRecipient: "broadcast",
@@ -490,7 +493,108 @@ const preference$2 = ({ strapi }) => ({
     return pref.globalOptOut || pref.mutedTypes.includes(type);
   }
 });
-const services = { notification: notification$2, notifier, settings: settings$2, preference: preference$2 };
+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 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strapi-plugin-notifier",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "A highly configurable notification inbox plugin for the Strapi v5 admin panel",
   "keywords": [
     "strapi",

package/tests/unit/rules.test.ts

@@ -0,0 +1,470 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import makeRulesService, { interpolate, getByPath } from '../../server/src/services/rules';
+import type { NotifierRule } from '../../server/src/config';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const makeSend = () => vi.fn().mockResolvedValue({ id: 1 });
+
+/** Builds a minimal strapi mock and returns it alongside a reference to `send`. */
+const makeStrapi = (send = makeSend()) => {
+  let lifecycleCallback: ((event: any) => Promise<void>) | undefined;
+  let eventCallback: ((data: any) => Promise<void>) | undefined;
+  let cronTask: ((ctx: { strapi: any }) => Promise<void>) | undefined;
+
+  const strapi = {
+    db: {
+      lifecycles: {
+        subscribe: vi.fn((opts: any) => {
+          // Capture whichever action key is present (afterCreate, afterUpdate, …)
+          const actionKey = Object.keys(opts).find((k) => k !== 'models');
+          if (actionKey) lifecycleCallback = opts[actionKey];
+        }),
+      },
+    },
+    eventHub: {
+      on: vi.fn((_event: string, cb: any) => { eventCallback = cb; }),
+    },
+    cron: {
+      add: vi.fn((tasks: any) => {
+        const key = Object.keys(tasks)[0];
+        cronTask = tasks[key].task;
+      }),
+    },
+    plugin: vi.fn().mockReturnValue({
+      service: vi.fn().mockReturnValue({ send }),
+    }),
+    log: { error: vi.fn() },
+  };
+
+  return { strapi, send, getLifecycleCallback: () => lifecycleCallback, getEventCallback: () => eventCallback, getCronTask: () => cronTask };
+};
+
+// ---------------------------------------------------------------------------
+// Unit: interpolate / getByPath
+// ---------------------------------------------------------------------------
+
+describe('getByPath', () => {
+  it('resolves shallow key', () => expect(getByPath({ a: 1 }, 'a')).toBe(1));
+  it('resolves nested key', () => expect(getByPath({ a: { b: 2 } }, 'a.b')).toBe(2));
+  it('returns undefined for missing path', () => expect(getByPath({ a: 1 }, 'a.b.c')).toBeUndefined());
+  it('returns undefined for null intermediate', () => expect(getByPath({ a: null }, 'a.b')).toBeUndefined());
+});
+
+describe('interpolate', () => {
+  it('replaces a simple token', () => {
+    expect(interpolate('Hello {{name}}', { name: 'World' })).toBe('Hello World');
+  });
+
+  it('replaces a nested token', () => {
+    expect(interpolate('Title: {{entry.title}}', { entry: { title: 'My Post' } })).toBe('Title: My Post');
+  });
+
+  it('replaces multiple tokens', () => {
+    expect(interpolate('{{a}} and {{b}}', { a: 'foo', b: 'bar' })).toBe('foo and bar');
+  });
+
+  it('replaces missing token with empty string', () => {
+    expect(interpolate('{{missing}}', {})).toBe('');
+  });
+
+  it('leaves non-token text unchanged', () => {
+    expect(interpolate('plain text', {})).toBe('plain text');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Lifecycle rules
+// ---------------------------------------------------------------------------
+
+describe('lifecycle rule', () => {
+  it('subscribes to the correct model and action', () => {
+    const { strapi } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle',
+      model: 'api::article.article',
+      action: 'afterCreate',
+      notification: { title: 'Created', type: 'info' },
+    }]);
+
+    expect(strapi.db.lifecycles.subscribe).toHaveBeenCalledOnce();
+    const opts = strapi.db.lifecycles.subscribe.mock.calls[0][0];
+    expect(opts.models).toEqual(['api::article.article']);
+    expect(typeof opts.afterCreate).toBe('function');
+  });
+
+  it('fires send with interpolated title', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle',
+      model: 'api::article.article',
+      action: 'afterCreate',
+      notification: { title: 'New: {{entry.title}}', type: 'success' },
+    }]);
+
+    await getLifecycleCallback()!({ result: { title: 'Hello World' } });
+
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ title: 'New: Hello World', type: 'success' }));
+  });
+
+  it('fires send with function title', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle',
+      model: 'api::article.article',
+      action: 'afterCreate',
+      notification: { title: (ctx) => `Entry #${ctx.entry.id}`, type: 'info' },
+    }]);
+
+    await getLifecycleCallback()!({ result: { id: 42 } });
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ title: 'Entry #42' }));
+  });
+
+  it('skips send when when() returns false', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle',
+      model: 'api::article.article',
+      action: 'afterCreate',
+      when: (ctx) => ctx.entry.published === true,
+      notification: { title: 'Published', type: 'info' },
+    }]);
+
+    await getLifecycleCallback()!({ result: { published: false } });
+    expect(send).not.toHaveBeenCalled();
+  });
+
+  it('fires send when when() returns true', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle',
+      model: 'api::article.article',
+      action: 'afterCreate',
+      when: (ctx) => ctx.entry.status === 'published',
+      notification: { title: 'Published', type: 'success' },
+    }]);
+
+    await getLifecycleCallback()!({ result: { status: 'published' } });
+    expect(send).toHaveBeenCalledOnce();
+  });
+
+  it('resolves userIdFrom target from entry', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle',
+      model: 'api::article.article',
+      action: 'afterCreate',
+      notification: {
+        title: 'Your article was created',
+        to: { userIdFrom: 'entry.createdBy.id' },
+      },
+    }]);
+
+    await getLifecycleCallback()!({ result: { createdBy: { id: 7 } } });
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ to: { userId: 7 } }));
+  });
+
+  it('uses params.data as entry fallback for before-hooks', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle',
+      model: 'api::article.article',
+      action: 'beforeCreate',
+      notification: { title: '{{entry.title}}' },
+    }]);
+
+    // beforeCreate has no result, only params.data
+    await getLifecycleCallback()!({ params: { data: { title: 'Draft' } } });
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ title: 'Draft' }));
+  });
+
+  it('catches errors and logs them without throwing', async () => {
+    const send = vi.fn().mockRejectedValue(new Error('boom'));
+    const { strapi, getLifecycleCallback } = makeStrapi(send);
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle',
+      model: 'api::article.article',
+      action: 'afterCreate',
+      notification: { title: 'Test' },
+    }]);
+
+    await expect(getLifecycleCallback()!({ result: {} })).resolves.toBeUndefined();
+    expect(strapi.log.error).toHaveBeenCalledOnce();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Event rules
+// ---------------------------------------------------------------------------
+
+describe('event rule', () => {
+  it('subscribes to the event hub with the given event name', () => {
+    const { strapi } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'event',
+      event: 'media.upload',
+      notification: { title: 'Upload' },
+    }]);
+
+    expect(strapi.eventHub.on).toHaveBeenCalledWith('media.upload', expect.any(Function));
+  });
+
+  it('fires send with interpolated title from event payload', async () => {
+    const { strapi, send, getEventCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'event',
+      event: 'entry.create',
+      notification: { title: 'New entry: {{entry.title}}', type: 'info' },
+    }]);
+
+    await getEventCallback()!({ entry: { title: 'My Post' } });
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ title: 'New entry: My Post' }));
+  });
+
+  it('applies filter — skips when payload does not match', async () => {
+    const { strapi, send, getEventCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'event',
+      event: 'entry.create',
+      filter: { uid: 'api::article.article' },
+      notification: { title: 'Article created' },
+    }]);
+
+    await getEventCallback()!({ uid: 'api::comment.comment' });
+    expect(send).not.toHaveBeenCalled();
+  });
+
+  it('applies filter — fires when payload matches', async () => {
+    const { strapi, send, getEventCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'event',
+      event: 'entry.create',
+      filter: { uid: 'api::article.article' },
+      notification: { title: 'Article created' },
+    }]);
+
+    await getEventCallback()!({ uid: 'api::article.article', entry: { title: 'Hello' } });
+    expect(send).toHaveBeenCalledOnce();
+  });
+
+  it('respects when() guard', async () => {
+    const { strapi, send, getEventCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'event',
+      event: 'entry.update',
+      when: (ctx) => (ctx.entry as any)?.status === 'published',
+      notification: { title: 'Published' },
+    }]);
+
+    await getEventCallback()!({ entry: { status: 'draft' } });
+    expect(send).not.toHaveBeenCalled();
+
+    await getEventCallback()!({ entry: { status: 'published' } });
+    expect(send).toHaveBeenCalledOnce();
+  });
+
+  it('catches errors and logs them without throwing', async () => {
+    const send = vi.fn().mockRejectedValue(new Error('net'));
+    const { strapi, getEventCallback } = makeStrapi(send);
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{ on: 'event', event: 'media.upload', notification: { title: 'Upload' } }]);
+
+    await expect(getEventCallback()!({})).resolves.toBeUndefined();
+    expect(strapi.log.error).toHaveBeenCalledOnce();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Cron rules
+// ---------------------------------------------------------------------------
+
+describe('cron rule', () => {
+  it('registers a cron task with the given schedule', () => {
+    const { strapi } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{ on: 'cron', schedule: '0 9 * * 1', notification: { title: 'Weekly' } }]);
+
+    expect(strapi.cron.add).toHaveBeenCalledOnce();
+    const tasks = strapi.cron.add.mock.calls[0][0];
+    const key = Object.keys(tasks)[0];
+    expect(tasks[key].options.rule).toBe('0 9 * * 1');
+  });
+
+  it('fires send when the task runs', async () => {
+    const { strapi, send, getCronTask } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'cron',
+      schedule: '0 9 * * 1',
+      notification: { title: 'Weekly reminder', type: 'warning', to: 'broadcast' },
+    }]);
+
+    await getCronTask()!({ strapi: strapi as any });
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ title: 'Weekly reminder', type: 'warning' }));
+  });
+
+  it('uses distinct keys for multiple cron rules', () => {
+    const { strapi } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    const rules: NotifierRule[] = [
+      { on: 'cron', schedule: '0 9 * * 1', notification: { title: 'A' } },
+      { on: 'cron', schedule: '0 17 * * 5', notification: { title: 'B' } },
+    ];
+    svc.setup(rules);
+
+    const keys = strapi.cron.add.mock.calls.map((c: any) => Object.keys(c[0])[0]);
+    expect(new Set(keys).size).toBe(2);
+  });
+
+  it('catches errors and logs them without throwing', async () => {
+    const send = vi.fn().mockRejectedValue(new Error('oops'));
+    const { strapi, getCronTask } = makeStrapi(send);
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{ on: 'cron', schedule: '* * * * *', notification: { title: 'Fail' } }]);
+
+    await expect(getCronTask()!({ strapi: strapi as any })).resolves.toBeUndefined();
+    expect(strapi.log.error).toHaveBeenCalledOnce();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Targeting
+// ---------------------------------------------------------------------------
+
+describe('rule targeting', () => {
+  it('broadcast: sends with no `to` key', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle', model: 'api::x.x', action: 'afterCreate',
+      notification: { title: 'T', to: 'broadcast' },
+    }]);
+
+    await getLifecycleCallback()!({ result: {} });
+    const args = send.mock.calls[0][0];
+    expect(args.to).toBeUndefined();
+  });
+
+  it('role: sends with to.role', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle', model: 'api::x.x', action: 'afterCreate',
+      notification: { title: 'T', to: { role: 'strapi-editor' } },
+    }]);
+
+    await getLifecycleCallback()!({ result: {} });
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ to: { role: 'strapi-editor' } }));
+  });
+
+  it('userId: sends with to.userId', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle', model: 'api::x.x', action: 'afterCreate',
+      notification: { title: 'T', to: { userId: 3 } },
+    }]);
+
+    await getLifecycleCallback()!({ result: {} });
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ to: { userId: 3 } }));
+  });
+
+  it('userIdFrom missing path: sends with no to key (falls back to broadcast)', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle', model: 'api::x.x', action: 'afterCreate',
+      notification: { title: 'T', to: { userIdFrom: 'entry.author.id' } },
+    }]);
+
+    await getLifecycleCallback()!({ result: {} });
+    const args = send.mock.calls[0][0];
+    expect(args.to).toBeUndefined();
+  });
+
+  it('function to: resolves dynamically', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle', model: 'api::x.x', action: 'afterCreate',
+      notification: {
+        title: 'T',
+        to: (ctx) => (ctx as any).entry.vip ? { role: 'strapi-super-admin' } : 'broadcast',
+      },
+    }]);
+
+    await getLifecycleCallback()!({ result: { vip: true } });
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ to: { role: 'strapi-super-admin' } }));
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Mixed rule sets
+// ---------------------------------------------------------------------------
+
+describe('setup with mixed rule types', () => {
+  it('wires all three trigger types independently', () => {
+    const { strapi } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    const rules: NotifierRule[] = [
+      { on: 'lifecycle', model: 'api::a.a', action: 'afterCreate', notification: { title: 'L' } },
+      { on: 'event', event: 'media.upload', notification: { title: 'E' } },
+      { on: 'cron', schedule: '0 3 * * *', notification: { title: 'C' } },
+    ];
+    svc.setup(rules);
+
+    expect(strapi.db.lifecycles.subscribe).toHaveBeenCalledOnce();
+    expect(strapi.eventHub.on).toHaveBeenCalledOnce();
+    expect(strapi.cron.add).toHaveBeenCalledOnce();
+  });
+
+  it('returns immediately without registering anything for empty rules array', () => {
+    const { strapi } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([]);
+
+    expect(strapi.db.lifecycles.subscribe).not.toHaveBeenCalled();
+    expect(strapi.eventHub.on).not.toHaveBeenCalled();
+    expect(strapi.cron.add).not.toHaveBeenCalled();
+  });
+});