strapi-plugin-notifier 1.0.0

package/dist/server/index.mjs

@@ -0,0 +1,467 @@
+const register = async ({ strapi }) => {
+  strapi.admin?.services?.permission?.actionProvider?.registerMany([
+    {
+      section: "plugins",
+      displayName: "Read settings",
+      uid: "settings.read",
+      pluginName: "notifier"
+    },
+    {
+      section: "plugins",
+      displayName: "Update settings",
+      uid: "settings.update",
+      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" });
+  if (!stored) {
+    const effective = await strapi.plugin("notifier").service("settings").getEffective();
+    await strapi.store({ environment: "", type: "plugin", name: "notifier" }).set({ key: "settings", value: effective });
+  }
+};
+const kind = "collectionType";
+const collectionName = "notifier_notifications";
+const info = {
+  singularName: "notification",
+  pluralName: "notifications",
+  displayName: "Notification",
+  description: "Admin-panel notifications managed by strapi-plugin-notifier"
+};
+const options = {
+  draftAndPublish: false
+};
+const pluginOptions = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes = {
+  title: {
+    type: "string",
+    required: true
+  },
+  message: {
+    type: "text"
+  },
+  type: {
+    type: "enumeration",
+    "enum": [
+      "info",
+      "success",
+      "warning",
+      "error"
+    ],
+    "default": "info"
+  },
+  read: {
+    type: "boolean",
+    "default": false,
+    required: true
+  },
+  url: {
+    type: "string"
+  },
+  recipientId: {
+    type: "integer"
+  },
+  recipientRole: {
+    type: "string"
+  }
+};
+const schema = {
+  kind,
+  collectionName,
+  info,
+  options,
+  pluginOptions,
+  attributes
+};
+const notification$3 = { schema };
+const contentTypes = { notification: notification$3 };
+const UID = "plugin::notifier.notification";
+const accessFilter = (userId, roleCodes = []) => ({
+  $or: [
+    { recipientId: userId },
+    ...roleCodes.length ? [{ recipientRole: { $in: 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() } }
+      });
+    }
+    if (maxPerUser > 0) {
+      const rows = await strapi.db.query(UID).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).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 } } });
+        }
+      }
+    }
+  }
+});
+const notifier = ({ strapi }) => {
+  const svc = () => strapi.plugin("notifier").service("notification");
+  return {
+    send({ title, message, type, url, to }) {
+      return svc().create({
+        title,
+        message,
+        type,
+        url,
+        recipientId: to?.userId,
+        recipientRole: to?.role
+      });
+    },
+    broadcast(opts) {
+      return svc().create({ ...opts });
+    },
+    toRole(role, opts) {
+      return svc().create({ ...opts, recipientRole: role });
+    },
+    toUser(userId, opts) {
+      return svc().create({ ...opts, recipientId: userId });
+    }
+  };
+};
+const DEFAULT_SETTINGS = {
+  retention: {
+    maxDays: 90,
+    maxPerUser: 500
+  },
+  delivery: {
+    defaultRecipient: "broadcast",
+    allowedRoles: []
+  },
+  ui: {
+    pollInterval: 3e4,
+    pageSize: 20,
+    defaultFilter: "all",
+    badge: {
+      enabled: true,
+      color: "#ee5e52"
+    },
+    theme: {
+      bellSize: "1.5em",
+      accent: {
+        info: "#4945ff",
+        success: "#328048",
+        warning: "#d97706",
+        error: "#d02b20"
+      }
+    }
+  }
+};
+const mergeWithDefaults = (overrides = {}) => ({
+  retention: { ...DEFAULT_SETTINGS.retention, ...overrides.retention ?? {} },
+  delivery: { ...DEFAULT_SETTINGS.delivery, ...overrides.delivery ?? {} },
+  ui: {
+    ...DEFAULT_SETTINGS.ui,
+    ...overrides.ui ?? {},
+    badge: { ...DEFAULT_SETTINGS.ui.badge, ...overrides.ui?.badge ?? {} },
+    theme: {
+      ...DEFAULT_SETTINGS.ui.theme,
+      ...overrides.ui?.theme ?? {},
+      accent: { ...DEFAULT_SETTINGS.ui.theme.accent, ...overrides.ui?.theme?.accent ?? {} }
+    }
+  }
+});
+const STORE_KEY = "settings";
+const getStore = (strapi) => strapi.store({ environment: "", type: "plugin", name: "notifier" });
+const settings$2 = ({ strapi }) => ({
+  /** Returns settings from the plugin store, falling back to defaults. */
+  async get() {
+    const stored = await getStore(strapi).get({ key: STORE_KEY });
+    return stored ?? { ...DEFAULT_SETTINGS };
+  },
+  /**
+   * Returns the effective settings: defaults → config/plugins.ts → plugin store (highest priority).
+   * This is the source of truth used by all server-side logic.
+   */
+  async getEffective() {
+    const fromPluginsConfig = strapi.config.get("plugin::notifier", {});
+    const fromStore = await getStore(strapi).get({ key: STORE_KEY });
+    const withPluginsConfig = mergeWithDefaults(fromPluginsConfig);
+    if (!fromStore) return withPluginsConfig;
+    return {
+      retention: { ...withPluginsConfig.retention, ...fromStore.retention ?? {} },
+      delivery: { ...withPluginsConfig.delivery, ...fromStore.delivery ?? {} },
+      ui: {
+        ...withPluginsConfig.ui,
+        ...fromStore.ui ?? {},
+        badge: { ...withPluginsConfig.ui.badge, ...fromStore.ui?.badge ?? {} },
+        theme: {
+          ...withPluginsConfig.ui.theme,
+          ...fromStore.ui?.theme ?? {},
+          accent: {
+            ...withPluginsConfig.ui.theme.accent,
+            ...fromStore.ui?.theme?.accent ?? {}
+          }
+        }
+      }
+    };
+  },
+  /** Persists a full or partial settings update to the plugin store. */
+  async update(patch) {
+    const current = await this.get();
+    const next = {
+      retention: { ...current.retention, ...patch.retention ?? {} },
+      delivery: { ...current.delivery, ...patch.delivery ?? {} },
+      ui: {
+        ...current.ui,
+        ...patch.ui ?? {},
+        badge: { ...current.ui.badge, ...patch.ui?.badge ?? {} },
+        theme: {
+          ...current.ui.theme,
+          ...patch.ui?.theme ?? {},
+          accent: { ...current.ui.theme.accent, ...patch.ui?.theme?.accent ?? {} }
+        }
+      }
+    };
+    await getStore(strapi).set({ key: STORE_KEY, value: next });
+    return next;
+  },
+  /** Resets plugin store settings, reverting to config/plugins.ts + built-in defaults. */
+  async reset() {
+    await getStore(strapi).delete({ key: STORE_KEY });
+  }
+});
+const services = { notification: notification$2, notifier, settings: settings$2 };
+const getUserRoleCodes = async (strapi, userId) => {
+  const user = await strapi.db.query("admin::user").findOne({
+    where: { id: userId },
+    populate: ["roles"]
+  });
+  return user?.roles?.map((r) => r.code) ?? [];
+};
+const notification$1 = ({ strapi }) => ({
+  async find(ctx) {
+    const adminUser = ctx.state.user;
+    if (!adminUser) return ctx.unauthorized();
+    const settings2 = await strapi.plugin("notifier").service("settings").getEffective();
+    const page = Math.max(1, Number(ctx.query.page ?? 1));
+    const pageSize = Math.min(100, Math.max(1, Number(ctx.query.pageSize ?? settings2.ui.pageSize)));
+    const roleCodes = await getUserRoleCodes(strapi, adminUser.id);
+    const svc = strapi.plugin("notifier").service("notification");
+    const [data, total] = await Promise.all([
+      svc.findByRecipient(adminUser.id, roleCodes, { page, pageSize }),
+      svc.countByRecipient(adminUser.id, roleCodes)
+    ]);
+    ctx.body = {
+      data,
+      pagination: { page, pageSize, total, pageCount: Math.ceil(total / pageSize) }
+    };
+  },
+  async markAsRead(ctx) {
+    const adminUser = ctx.state.user;
+    if (!adminUser) return ctx.unauthorized();
+    const id = Number(ctx.params.id);
+    const roleCodes = await getUserRoleCodes(strapi, adminUser.id);
+    const notification2 = await strapi.plugin("notifier").service("notification").markAsRead(id, adminUser.id, roleCodes);
+    if (!notification2) return ctx.notFound();
+    ctx.body = { data: notification2 };
+  },
+  async markAllAsRead(ctx) {
+    const adminUser = ctx.state.user;
+    if (!adminUser) return ctx.unauthorized();
+    const roleCodes = await getUserRoleCodes(strapi, adminUser.id);
+    await strapi.plugin("notifier").service("notification").markAllAsRead(adminUser.id, roleCodes);
+    ctx.body = { ok: true };
+  },
+  async clear(ctx) {
+    const adminUser = ctx.state.user;
+    if (!adminUser) return ctx.unauthorized();
+    const id = Number(ctx.params.id);
+    const roleCodes = await getUserRoleCodes(strapi, adminUser.id);
+    const deleted = await strapi.plugin("notifier").service("notification").delete(id, adminUser.id, roleCodes);
+    if (!deleted) return ctx.notFound();
+    ctx.body = { ok: true };
+  },
+  async clearAll(ctx) {
+    const adminUser = ctx.state.user;
+    if (!adminUser) return ctx.unauthorized();
+    const roleCodes = await getUserRoleCodes(strapi, adminUser.id);
+    await strapi.plugin("notifier").service("notification").clearAll(adminUser.id, roleCodes);
+    ctx.body = { ok: true };
+  }
+});
+const config$1 = ({ strapi }) => ({
+  async find(ctx) {
+    const settings2 = await strapi.plugin("notifier").service("settings").getEffective();
+    ctx.body = { data: settings2.ui };
+  }
+});
+const settings$1 = ({ strapi }) => ({
+  async find(ctx) {
+    const settings2 = await strapi.plugin("notifier").service("settings").getEffective();
+    ctx.body = { data: settings2 };
+  },
+  async update(ctx) {
+    const patch = ctx.request.body;
+    const updated = await strapi.plugin("notifier").service("settings").update(patch);
+    ctx.body = { data: updated };
+  },
+  async reset(ctx) {
+    await strapi.plugin("notifier").service("settings").reset();
+    const defaults = await strapi.plugin("notifier").service("settings").getEffective();
+    ctx.body = { data: defaults };
+  }
+});
+const controllers = { notification: notification$1, config: config$1, settings: settings$1 };
+const notification = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/notifications",
+      handler: "notification.find",
+      config: { policies: ["admin::isAuthenticatedAdmin"] }
+    },
+    {
+      method: "PUT",
+      path: "/notifications/read-all",
+      handler: "notification.markAllAsRead",
+      config: { policies: ["admin::isAuthenticatedAdmin"] }
+    },
+    {
+      method: "DELETE",
+      path: "/notifications",
+      handler: "notification.clearAll",
+      config: { policies: ["admin::isAuthenticatedAdmin"] }
+    },
+    {
+      method: "PUT",
+      path: "/notifications/:id/read",
+      handler: "notification.markAsRead",
+      config: { policies: ["admin::isAuthenticatedAdmin"] }
+    },
+    {
+      method: "DELETE",
+      path: "/notifications/:id",
+      handler: "notification.clear",
+      config: { policies: ["admin::isAuthenticatedAdmin"] }
+    }
+  ]
+};
+const config = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/config",
+      handler: "config.find",
+      config: { policies: ["admin::isAuthenticatedAdmin"] }
+    }
+  ]
+};
+const settings = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/settings",
+      handler: "settings.find",
+      config: { policies: ["admin::hasPermissions"], config: { actions: ["plugin::notifier.settings.read"] } }
+    },
+    {
+      method: "PUT",
+      path: "/settings",
+      handler: "settings.update",
+      config: { policies: ["admin::hasPermissions"], config: { actions: ["plugin::notifier.settings.update"] } }
+    },
+    {
+      method: "DELETE",
+      path: "/settings",
+      handler: "settings.reset",
+      config: { policies: ["admin::hasPermissions"], config: { actions: ["plugin::notifier.settings.update"] } }
+    }
+  ]
+};
+const adminRoutes = [notification, config, settings];
+const index = {
+  register,
+  bootstrap,
+  contentTypes,
+  services,
+  controllers,
+  routes: adminRoutes
+};
+export {
+  index as default
+};

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "strapi-plugin-notifier",
+  "version": "1.0.0",
+  "description": "A highly configurable notification inbox plugin for the Strapi v5 admin panel",
+  "keywords": [
+    "strapi",
+    "strapi-plugin",
+    "notifications",
+    "inbox",
+    "admin"
+  ],
+  "homepage": "https://github.com/datrine/strapi-plugin-notifier#readme",
+  "bugs": {
+    "url": "https://github.com/datrine/strapi-plugin-notifier/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/datrine/strapi-plugin-notifier.git"
+  },
+  "license": "MIT",
+  "author": "datrine",
+  "type": "commonjs",
+  "exports": {
+    "./strapi-admin": {
+      "source": "./admin/src/index.ts",
+      "import": "./dist/admin/index.mjs",
+      "require": "./dist/admin/index.js",
+      "default": "./dist/admin/index.js"
+    },
+    "./strapi-server": {
+      "source": "./server/src/index.ts",
+      "import": "./dist/server/index.mjs",
+      "require": "./dist/server/index.js",
+      "default": "./dist/server/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/server/index.js",
+  "scripts": {
+    "build": "npx strapi-plugin build",
+    "watch": "npx strapi-plugin watch",
+    "watch:link": "npx strapi-plugin watch:link",
+    "verify": "npx strapi-plugin verify",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@radix-ui/react-dialog": "^1.1.16",
+    "@radix-ui/react-popover": "^1.1.16",
+    "@radix-ui/react-toolbar": "^1.1.12",
+    "@strapi/admin": "^5.0.0",
+    "@strapi/design-system": "^2.2.0",
+    "@strapi/icons": "^2.2.0",
+    "@strapi/sdk-plugin": "^5.2.6",
+    "@strapi/strapi": "^5.0.0",
+    "@types/react": "^18.0.0",
+    "@types/react-dom": "^18.0.0",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
+    "react-router-dom": "^6.0.0",
+    "styled-components": "^6.4.2",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "@strapi/design-system": "^2.0.0",
+    "@strapi/icons": "^2.0.0",
+    "@strapi/strapi": "^5.0.0",
+    "framer-motion": "*",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0 <=22.x.x",
+    "npm": ">=6.0.0"
+  },
+  "module": "./dist/server/index.mjs",
+  "source": "./server/src/index.ts",
+  "strapi": {
+    "kind": "plugin",
+    "displayName": "Notifier",
+    "description": "A highly configurable notification inbox plugin for the Strapi v5 admin panel"
+  },
+  "dependencies": {
+    "browserslist": "^4.28.2",
+    "caniuse-lite": "^1.0.30001797"
+  }
+}