@easy-cms/plugin-notify 0.0.0-stage → 1.32.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kanawoot K.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,31 @@
-# Temporary Holding Version
+# @easy-cms/plugin-notify
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Notifications for Easy CMS admins: a Telegram message when a form is sent, an order comes in, or something fails (scheduled publishing, webhooks and email, backups, integrations). Admins connect the chat on the Integrations page. Part of [Easy CMS](https://github.com/maritonx/easy-cms), the embedded, code-first headless CMS for Nuxt and Next.js.
+
+## Install
+
+```bash
+npm install @easy-cms/plugin-notify
+```
+
+Or `pnpm add`, `yarn add` or `bun add`.
+
+## Usage
+
+```ts
+import { notifyPlugin } from '@easy-cms/plugin-notify'
+
+export default defineConfig({
+  serverURL: 'https://example.com', // for links to the admin
+  // …
+  plugins: [notifyPlugin()],
+})
+```
+
+Then create a migration (`easy-cms migrate:create notify`), and in the admin go to **Settings → Integrations → Telegram**: paste the bot token from @BotFather, press **Find Chat ID**, and choose the events.
+
+## Links
+
+[Notifications](https://easycms.dev/docs/notifications) · [Documentation](https://easycms.dev/docs) ([ภาษาไทย](https://easycms.dev/th/docs)) · [GitHub](https://github.com/maritonx/easy-cms)
+
+MIT License

package/dist/index.d.ts

@@ -0,0 +1,62 @@
+import * as _easy_cms_core from '@easy-cms/core';
+import { IntegrationConfig } from '@easy-cms/core';
+
+type Language = 'en' | 'th';
+/** The events admins can be told about. */
+declare const NOTIFY_EVENTS: readonly ["form.submitted", "order.created", "scheduled.failed", "delivery.failed", "backup.failed", "integration.failed"];
+type NotifyEvent = (typeof NOTIFY_EVENTS)[number];
+declare const EVENT_LABELS: Record<NotifyEvent, {
+    en: string;
+    th: string;
+}>;
+/** A message for people: a title, some lines, and a page of the admin. */
+interface Notice {
+    readonly title: string;
+    readonly lines: readonly string[];
+    /** A path of the admin, e.g. `/backups`. */
+    readonly path?: string | undefined;
+    /** The link's words. */
+    readonly open: string;
+}
+
+/**
+ * A place notifications go (Telegram first; LINE, Slack and Discord later). Its integration
+ * gives the fields admins fill on the Integrations page, beside the ones every channel has
+ * (`language`, `events`).
+ */
+interface NotifyChannel {
+    readonly integration: IntegrationConfig;
+    /** Formats a notice for this channel; `link` is the admin page, when `serverURL` is set. */
+    readonly format: (notice: Notice, link: string | undefined) => string;
+    /** Sends a formatted message; throws with the provider's reason. */
+    readonly send: (values: Readonly<Record<string, string>>, text: string) => Promise<void>;
+}
+/** A provider's answer that wasn't OK, for the error a connection shows. */
+declare class ChannelError extends Error {
+    /** Retrying won't help, e.g. a revoked token. */
+    readonly permanent: boolean;
+    constructor(message: string, permanent?: boolean);
+}
+
+interface NotifyPluginOptions {
+    /** Where notifications go. Default: Telegram. */
+    readonly channels?: readonly NotifyChannel[];
+    /**
+     * Notifications a connection sends an hour, at most; the ones over it are counted and told
+     * in one message once the hour allows. Default 60.
+     */
+    readonly limit?: number;
+    /** Slug of the collection that queues notifications. Default `notify-messages`. */
+    readonly slug?: string;
+}
+/**
+ * Tells admins about events in a chat: new orders, form answers, and failures (scheduled
+ * publishing, webhooks and email, backups, integrations). Each channel (Telegram) is an
+ * integration admins connect on the Integrations page.
+ */
+declare function notifyPlugin(options?: NotifyPluginOptions): _easy_cms_core.TypedPlugin<Record<never, never>>;
+
+declare const telegram: NotifyChannel;
+
+export { ChannelError, EVENT_LABELS, NOTIFY_EVENTS, notifyPlugin, telegram };
+export type { Language, Notice, NotifyChannel, NotifyEvent, NotifyPluginOptions };

package/dist/index.js

@@ -0,0 +1,508 @@
+// src/channel.ts
+var ChannelError = class extends Error {
+  /** Retrying won't help, e.g. a revoked token. */
+  permanent;
+  constructor(message, permanent = false) {
+    super(message);
+    this.name = "ChannelError";
+    this.permanent = permanent;
+  }
+};
+
+// src/messages.ts
+var NOTIFY_EVENTS = [
+  "form.submitted",
+  "order.created",
+  "scheduled.failed",
+  "delivery.failed",
+  "backup.failed",
+  "integration.failed"
+];
+var EVENT_LABELS = {
+  "form.submitted": { en: "A form was sent", th: "\u0E21\u0E35\u0E04\u0E19\u0E2A\u0E48\u0E07\u0E1F\u0E2D\u0E23\u0E4C\u0E21" },
+  "order.created": { en: "A new order", th: "\u0E04\u0E33\u0E2A\u0E31\u0E48\u0E07\u0E0B\u0E37\u0E49\u0E2D\u0E43\u0E2B\u0E21\u0E48" },
+  "scheduled.failed": { en: "Scheduled publishing failed", th: "\u0E01\u0E32\u0E23\u0E40\u0E1C\u0E22\u0E41\u0E1E\u0E23\u0E48\u0E15\u0E32\u0E21\u0E40\u0E27\u0E25\u0E32\u0E25\u0E49\u0E21\u0E40\u0E2B\u0E25\u0E27" },
+  "delivery.failed": { en: "A webhook or email gave up", th: "Webhook \u0E2B\u0E23\u0E37\u0E2D\u0E2D\u0E35\u0E40\u0E21\u0E25\u0E2A\u0E48\u0E07\u0E44\u0E21\u0E48\u0E2A\u0E33\u0E40\u0E23\u0E47\u0E08" },
+  "backup.failed": { en: "A backup failed", th: "\u0E01\u0E32\u0E23\u0E2A\u0E33\u0E23\u0E2D\u0E07\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E25\u0E49\u0E21\u0E40\u0E2B\u0E25\u0E27" },
+  "integration.failed": { en: "An integration failed", th: "\u0E01\u0E32\u0E23\u0E40\u0E0A\u0E37\u0E48\u0E2D\u0E21\u0E15\u0E48\u0E2D\u0E25\u0E49\u0E21\u0E40\u0E2B\u0E25\u0E27" }
+};
+var str = (v) => typeof v === "string" || typeof v === "number" ? String(v) : "";
+function money(amount, currency, language) {
+  if (typeof amount !== "number" || typeof currency !== "string") return "";
+  try {
+    const format = new Intl.NumberFormat(language, { style: "currency", currency });
+    const digits = format.resolvedOptions().maximumFractionDigits ?? 2;
+    return format.format(amount / 10 ** digits);
+  } catch {
+    return `${amount} ${currency}`;
+  }
+}
+var T = {
+  en: {
+    form: "Form",
+    from: "From",
+    order: "Order",
+    total: "Total",
+    email: "Email",
+    document: "Document",
+    error: "Error",
+    to: "To",
+    attempts: "Attempts",
+    connection: "Connection",
+    publish: "publish",
+    unpublish: "unpublish",
+    open: "Open in the admin",
+    dropped: (n, limit) => `${n} more notifications were not sent: at most ${limit} an hour.`,
+    test: "Easy CMS: test message. Notifications will arrive in this chat."
+  },
+  th: {
+    form: "\u0E1F\u0E2D\u0E23\u0E4C\u0E21",
+    from: "\u0E08\u0E32\u0E01",
+    order: "\u0E04\u0E33\u0E2A\u0E31\u0E48\u0E07\u0E0B\u0E37\u0E49\u0E2D",
+    total: "\u0E22\u0E2D\u0E14\u0E23\u0E27\u0E21",
+    email: "\u0E2D\u0E35\u0E40\u0E21\u0E25",
+    document: "\u0E40\u0E2D\u0E01\u0E2A\u0E32\u0E23",
+    error: "\u0E02\u0E49\u0E2D\u0E1C\u0E34\u0E14\u0E1E\u0E25\u0E32\u0E14",
+    to: "\u0E16\u0E36\u0E07",
+    attempts: "\u0E08\u0E33\u0E19\u0E27\u0E19\u0E04\u0E23\u0E31\u0E49\u0E07",
+    connection: "\u0E01\u0E32\u0E23\u0E40\u0E0A\u0E37\u0E48\u0E2D\u0E21\u0E15\u0E48\u0E2D",
+    publish: "\u0E40\u0E1C\u0E22\u0E41\u0E1E\u0E23\u0E48",
+    unpublish: "\u0E40\u0E25\u0E34\u0E01\u0E40\u0E1C\u0E22\u0E41\u0E1E\u0E23\u0E48",
+    open: "\u0E40\u0E1B\u0E34\u0E14\u0E43\u0E19\u0E2B\u0E19\u0E49\u0E32 admin",
+    dropped: (n, limit) => `\u0E21\u0E35\u0E01\u0E32\u0E23\u0E41\u0E08\u0E49\u0E07\u0E40\u0E15\u0E37\u0E2D\u0E19\u0E2D\u0E35\u0E01 ${n} \u0E23\u0E32\u0E22\u0E01\u0E32\u0E23\u0E17\u0E35\u0E48\u0E44\u0E21\u0E48\u0E44\u0E14\u0E49\u0E2A\u0E48\u0E07: \u0E2A\u0E48\u0E07\u0E44\u0E14\u0E49\u0E44\u0E21\u0E48\u0E40\u0E01\u0E34\u0E19 ${limit} \u0E23\u0E32\u0E22\u0E01\u0E32\u0E23\u0E15\u0E48\u0E2D\u0E0A\u0E31\u0E48\u0E27\u0E42\u0E21\u0E07`,
+    test: "Easy CMS: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E17\u0E14\u0E2A\u0E2D\u0E1A \u0E01\u0E32\u0E23\u0E41\u0E08\u0E49\u0E07\u0E40\u0E15\u0E37\u0E2D\u0E19\u0E08\u0E30\u0E2A\u0E48\u0E07\u0E21\u0E32\u0E17\u0E35\u0E48\u0E41\u0E0A\u0E15\u0E19\u0E35\u0E49"
+  }
+};
+var texts = (language) => T[language];
+function noticeOf(message, language) {
+  const notice = describe(message, language);
+  return notice && { ...notice, open: T[language].open };
+}
+function describe(message, language) {
+  const t = T[language];
+  const d = message.data;
+  const event = message.event;
+  if (!NOTIFY_EVENTS.includes(event)) return null;
+  const title = EVENT_LABELS[event][language];
+  const line = (label, value) => str(value) ? [`${label}: ${str(value)}`] : [];
+  const about = message.about;
+  const docPath = about?.collection && about.id !== void 0 ? `/collections/${about.collection}/${about.id}` : void 0;
+  switch (event) {
+    case "form.submitted": {
+      const form = d.form ?? {};
+      return {
+        title,
+        lines: [...line(t.form, form.title ?? form.id), ...line(t.from, d.email)],
+        path: docPath
+      };
+    }
+    case "order.created":
+      return {
+        title,
+        lines: [
+          ...line(t.order, d.orderNumber ? `#${str(d.orderNumber)}` : d.id),
+          ...line(t.total, money(d.total, d.currency, language)),
+          ...line(t.email, d.email)
+        ],
+        path: docPath
+      };
+    case "scheduled.failed": {
+      const action = d.action === "unpublish" ? t.unpublish : d.action ? t.publish : "";
+      const target = d.global ?? (d.collection ? `${str(d.collection)} ${str(d.doc)}` : "");
+      return {
+        title,
+        lines: [
+          ...line(t.document, `${str(target)}${action ? ` (${action})` : ""}`.trim()),
+          ...line(t.error, d.error)
+        ],
+        path: "/jobs?tab=scheduled"
+      };
+    }
+    case "delivery.failed":
+      return {
+        title,
+        lines: [
+          ...line(t.to, d.url ?? d.to),
+          ...line(t.attempts, d.attempts),
+          ...line(t.error, d.error)
+        ],
+        path: "/deliveries"
+      };
+    case "backup.failed":
+      return { title, lines: line(t.error, d.error), path: "/backups" };
+    case "integration.failed":
+      return {
+        title,
+        lines: [
+          ...line(t.connection, d.name ? `${str(d.integration)} \xB7 ${str(d.name)}` : d.integration),
+          ...line(t.error, d.error)
+        ],
+        path: "/integrations"
+      };
+  }
+}
+
+// src/plugin.ts
+import {
+  definePlugin
+} from "@easy-cms/core";
+
+// src/info.ts
+var INFO = {
+  name: "@easy-cms/plugin-notify",
+  // The plugin API it is written for (`PLUGIN_API_VERSION` of @easy-cms/core).
+  apiVersion: 1,
+  ...true ? { version: "1.32.0" } : {}
+};
+
+// src/telegram.ts
+var api = () => (process.env.TELEGRAM_API_URL ?? "https://api.telegram.org").replace(/\/$/, "");
+var html = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+async function call(token, method, body) {
+  if (!token) throw new ChannelError("No bot token", true);
+  let response;
+  try {
+    response = await fetch(`${api()}/bot${token}/${method}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body ?? {}),
+      signal: AbortSignal.timeout(1e4)
+    });
+  } catch (error) {
+    throw new ChannelError(`Telegram could not be reached: ${error.message}`);
+  }
+  const answer = await response.json().catch(() => ({ ok: false }));
+  if (!answer.ok) {
+    const code = answer.error_code ?? response.status;
+    throw new ChannelError(
+      `Telegram: ${answer.description ?? `HTTP ${response.status}`}`,
+      code === 400 || code === 401 || code === 403 || code === 404
+    );
+  }
+  return answer.result;
+}
+var chatLabel = (chat) => {
+  const name = chat.title ?? ([chat.first_name, chat.last_name].filter(Boolean).join(" ") || chat.username);
+  return `${String(name ?? chat.id)} (${String(chat.type)})`;
+};
+async function chats(token) {
+  const updates = await call(token, "getUpdates", { limit: 100 }) ?? [];
+  const found = /* @__PURE__ */ new Map();
+  for (const update of updates.reverse()) {
+    const holder = update.message ?? update.channel_post ?? update.my_chat_member ?? update.edited_message;
+    const chat = holder?.chat;
+    if (chat?.id !== void 0 && !found.has(String(chat.id)))
+      found.set(String(chat.id), chatLabel(chat));
+  }
+  return [...found].map(([value, label]) => ({ value, label }));
+}
+var fields = [
+  {
+    name: "token",
+    label: { en: "Bot token", th: "Bot token" },
+    description: {
+      en: "From @BotFather: /newbot, then copy the token.",
+      th: "\u0E08\u0E32\u0E01 @BotFather: /newbot \u0E41\u0E25\u0E49\u0E27\u0E04\u0E31\u0E14\u0E25\u0E2D\u0E01 token"
+    },
+    secret: true,
+    required: true
+  },
+  {
+    name: "chatId",
+    label: { en: "Chat ID", th: "Chat ID" },
+    description: {
+      en: "Write to the bot (or add it to a group), then press Find.",
+      th: "\u0E2A\u0E48\u0E07\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E2B\u0E32\u0E1A\u0E2D\u0E17 (\u0E2B\u0E23\u0E37\u0E2D\u0E40\u0E1E\u0E34\u0E48\u0E21\u0E1A\u0E2D\u0E17\u0E40\u0E02\u0E49\u0E32\u0E01\u0E25\u0E38\u0E48\u0E21) \u0E41\u0E25\u0E49\u0E27\u0E01\u0E14 \u0E04\u0E49\u0E19\u0E2B\u0E32"
+    },
+    required: true,
+    lookup: (values) => chats(values.token ?? "")
+  }
+];
+var telegram = {
+  integration: {
+    id: "telegram",
+    label: "Telegram",
+    category: "notifications",
+    description: {
+      en: "Tell admins about new orders, form answers and failures in a Telegram chat.",
+      th: "\u0E41\u0E08\u0E49\u0E07\u0E1C\u0E39\u0E49\u0E14\u0E39\u0E41\u0E25\u0E40\u0E23\u0E37\u0E48\u0E2D\u0E07\u0E04\u0E33\u0E2A\u0E31\u0E48\u0E07\u0E0B\u0E37\u0E49\u0E2D\u0E43\u0E2B\u0E21\u0E48 \u0E1F\u0E2D\u0E23\u0E4C\u0E21 \u0E41\u0E25\u0E30\u0E02\u0E49\u0E2D\u0E1C\u0E34\u0E14\u0E1E\u0E25\u0E32\u0E14\u0E43\u0E19\u0E41\u0E0A\u0E15 Telegram"
+    },
+    icon: "send",
+    docs: "https://easycms.dev/docs/notifications",
+    plugin: "@easy-cms/plugin-notify",
+    kind: "fields",
+    fields,
+    env: { token: "TELEGRAM_BOT_TOKEN" },
+    // The bot's name; the plugin then sends a test message.
+    async test(values) {
+      const me = await call(values.token ?? "", "getMe");
+      return { ok: true, account: me.username ? `@${me.username}` : me.first_name ?? "bot" };
+    }
+  },
+  format(notice, link) {
+    return [
+      `<b>${html(notice.title)}</b>`,
+      ...notice.lines.map(html),
+      ...link ? [`<a href="${html(link)}">${html(notice.open)}</a>`] : []
+    ].join("\n");
+  },
+  async send(values, text) {
+    await call(values.token ?? "", "sendMessage", {
+      chat_id: values.chatId,
+      text,
+      parse_mode: "HTML",
+      link_preview_options: { is_disabled: true }
+    });
+  }
+};
+
+// src/plugin.ts
+var RETRIES = [6e4, 5 * 6e4, 30 * 6e4];
+var CLAIM = 2 * 6e4;
+var HOUR = 60 * 6e4;
+var KEEP = 7 * 24 * HOUR;
+var nobody = () => false;
+var later = (now, ms) => new Date(now.getTime() + ms).toISOString();
+function notifyPlugin(options = {}) {
+  const channels = options.channels ?? [telegram];
+  const limit = options.limit ?? 60;
+  const slug = options.slug ?? "notify-messages";
+  const channelIds = new Set(channels.map((c) => c.integration.id));
+  if (!Number.isInteger(limit) || limit < 1)
+    throw new Error("notifyPlugin: `limit` must be a whole number above 0");
+  return definePlugin((config) => {
+    if (config.collections?.some((c) => c.slug === slug))
+      throw new Error(`notifyPlugin: there is already a collection "${slug}"; set \`slug\``);
+    const adminLanguage = config.admin?.locale === "th" ? "th" : "en";
+    const messages = {
+      slug,
+      labels: { singular: "Notification", plural: "Notifications" },
+      access: { read: nobody, create: nobody, update: nobody, delete: nobody },
+      fields: [
+        { name: "channel", type: "text", required: true, index: true },
+        { name: "connection", type: "text", required: true },
+        { name: "event", type: "text", required: true },
+        { name: "text", type: "textarea", required: true },
+        // pending | sent | failed | dropped (over the limit) | counted (told in a summary)
+        { name: "state", type: "text", required: true, index: true },
+        { name: "attempts", type: "number" },
+        { name: "nextAttemptAt", type: "text", index: true },
+        { name: "error", type: "text" }
+      ]
+    };
+    const channelOf = (id) => channels.find((c) => c.integration.id === id);
+    const languageOf = (conn) => conn.values.language === "th" || conn.values.language === "en" ? conn.values.language : adminLanguage;
+    const linkOf = (cms, path) => {
+      const server = cms.config.serverURL?.replace(/\/+$/, "");
+      if (!server || !path) return void 0;
+      return `${server}${cms.config.admin.path.replace(/\/+$/, "")}${path}`;
+    };
+    const recent = (cms, row, now) => cms.db.count({
+      collection: slug,
+      where: {
+        and: [
+          { channel: { equals: row.channel } },
+          { connection: { equals: row.connection } },
+          { state: { in: ["pending", "sent", "failed"] } },
+          { createdAt: { gt: new Date(now.getTime() - HOUR).toISOString() } }
+        ]
+      },
+      max: limit
+    });
+    async function deliver(cms, row, now = /* @__PURE__ */ new Date()) {
+      const channel = channelOf(row.channel);
+      const conn = channel ? await cms.integrations.get(channel.integration.id, { name: String(row.connection) }) : null;
+      const attempts = Number(row.attempts ?? 0) + 1;
+      const { id, ...data } = row;
+      try {
+        if (!channel || !conn) throw new ChannelError("The connection is gone", true);
+        await channel.send(conn.values, String(row.text));
+        await cms.db.update({
+          collection: slug,
+          id,
+          data: { ...data, state: "sent", attempts, error: null, updatedAt: now.toISOString() }
+        });
+        await cms.integrations.markUsed(channel.integration.id, conn.name);
+      } catch (error) {
+        const message = error.message;
+        const wait = error instanceof ChannelError && error.permanent ? void 0 : RETRIES[attempts - 1];
+        await cms.db.update({
+          collection: slug,
+          id,
+          data: {
+            ...data,
+            attempts,
+            state: wait === void 0 ? "failed" : "pending",
+            nextAttemptAt: later(now, wait ?? 0),
+            error: message.slice(0, 500),
+            updatedAt: now.toISOString()
+          }
+        });
+        if (wait === void 0 && channel && conn)
+          await cms.integrations.markError(channel.integration.id, message, conn.name);
+      }
+    }
+    async function enqueue(cms, channel, conn, event, text, now = /* @__PURE__ */ new Date()) {
+      const key = { channel: channel.integration.id, connection: conn.name };
+      const over = await recent(cms, key, now) >= limit;
+      const row = await cms.db.create({
+        collection: slug,
+        data: {
+          ...key,
+          event,
+          text,
+          state: over ? "dropped" : "pending",
+          attempts: 0,
+          nextAttemptAt: later(now, CLAIM),
+          error: null,
+          createdAt: now.toISOString(),
+          updatedAt: now.toISOString()
+        }
+      });
+      if (!over) await deliver(cms, row, now);
+    }
+    async function listen(message, { cms }) {
+      const data = message.data;
+      if (message.event === "integration.failed" && channelIds.has(String(data.integration))) return;
+      for (const channel of channels) {
+        for (const conn of await cms.integrations.all(channel.integration.id)) {
+          const wanted = (conn.values.events ?? "").split(",").filter(Boolean);
+          if (wanted.length > 0 && !wanted.includes(message.event)) continue;
+          const notice = noticeOf(message, languageOf(conn));
+          if (!notice) continue;
+          await enqueue(
+            cms,
+            channel,
+            conn,
+            message.event,
+            channel.format(notice, linkOf(cms, notice.path))
+          );
+        }
+      }
+    }
+    async function summarize(cms, now) {
+      const dropped = await cms.db.find({
+        collection: slug,
+        where: { state: { equals: "dropped" } },
+        sort: ["id"],
+        limit: 0,
+        page: 1
+      });
+      const groups = /* @__PURE__ */ new Map();
+      for (const row of dropped.docs) {
+        const key = `${String(row.channel)}
+${String(row.connection)}`;
+        groups.set(key, [...groups.get(key) ?? [], row]);
+      }
+      for (const [key, rows] of groups) {
+        const [channelId = "", connection = ""] = key.split("\n");
+        if (await recent(cms, { channel: channelId, connection }, now) >= limit) continue;
+        for (const { id, ...data } of rows)
+          await cms.db.update({ collection: slug, id, data: { ...data, state: "counted" } });
+        const channel = channelOf(channelId);
+        const conn = channel && await cms.integrations.get(channelId, { name: connection });
+        if (!channel || !conn) continue;
+        const t = texts(languageOf(conn));
+        const notice = {
+          title: "Easy CMS",
+          lines: [t.dropped(rows.length, limit)],
+          open: t.open
+        };
+        await enqueue(cms, channel, conn, "notify.dropped", channel.format(notice, void 0), now);
+      }
+    }
+    async function run({ cms, now }) {
+      const due = await cms.db.find({
+        collection: slug,
+        where: {
+          and: [{ state: { equals: "pending" } }, { nextAttemptAt: { lte: now.toISOString() } }]
+        },
+        sort: ["nextAttemptAt"],
+        limit: 50,
+        page: 1
+      });
+      for (const found of due.docs) {
+        const { id, ...data } = found;
+        const claimed = await cms.db.update({
+          collection: slug,
+          id,
+          data: { ...data, nextAttemptAt: later(now, CLAIM) },
+          where: {
+            and: [
+              { state: { equals: "pending" } },
+              { nextAttemptAt: { equals: found.nextAttemptAt } }
+            ]
+          }
+        });
+        if (claimed) await deliver(cms, { ...found, ...claimed, id }, now);
+      }
+      await summarize(cms, now);
+      const old = await cms.db.find({
+        collection: slug,
+        where: {
+          and: [
+            { state: { not_equals: "pending" } },
+            { updatedAt: { lt: new Date(now.getTime() - KEEP).toISOString() } }
+          ]
+        },
+        sort: ["id"],
+        limit: 500,
+        page: 1
+      });
+      for (const row of old.docs) await cms.db.delete({ collection: slug, id: row.id });
+    }
+    const integrations = channels.map(({ integration }) => ({
+      ...integration,
+      fields: [
+        ...integration.fields ?? [],
+        {
+          name: "language",
+          label: { en: "Language", th: "\u0E20\u0E32\u0E29\u0E32" },
+          type: "select",
+          options: [
+            { value: "en", label: "English" },
+            { value: "th", label: "\u0E20\u0E32\u0E29\u0E32\u0E44\u0E17\u0E22" }
+          ],
+          description: {
+            en: "Of the notifications. Empty: the admin's language.",
+            th: "\u0E02\u0E2D\u0E07\u0E01\u0E32\u0E23\u0E41\u0E08\u0E49\u0E07\u0E40\u0E15\u0E37\u0E2D\u0E19 \u0E16\u0E49\u0E32\u0E27\u0E48\u0E32\u0E07: \u0E20\u0E32\u0E29\u0E32\u0E02\u0E2D\u0E07\u0E2B\u0E19\u0E49\u0E32 admin"
+          }
+        },
+        {
+          name: "events",
+          label: { en: "Events", th: "\u0E40\u0E2B\u0E15\u0E38\u0E01\u0E32\u0E23\u0E13\u0E4C" },
+          type: "multiselect",
+          options: NOTIFY_EVENTS.map((value) => ({ value, label: EVENT_LABELS[value] })),
+          description: { en: "None ticked: all of them.", th: "\u0E16\u0E49\u0E32\u0E44\u0E21\u0E48\u0E40\u0E25\u0E37\u0E2D\u0E01: \u0E17\u0E31\u0E49\u0E07\u0E2B\u0E21\u0E14" }
+        }
+      ],
+      async test(values, args) {
+        const channel = channelOf(integration.id);
+        try {
+          const own = await integration.test?.(values, args);
+          if (own && !own.ok) return own;
+          const account = own?.account;
+          const language = values.language === "th" || values.language === "en" ? values.language : adminLanguage;
+          await channel.send(values, texts(language).test);
+          return { ok: true, ...account ? { account } : {} };
+        } catch (error) {
+          return { ok: false, message: error.message };
+        }
+      }
+    }));
+    return {
+      ...config,
+      collections: [...config.collections ?? [], messages],
+      integrations: [...config.integrations ?? [], ...integrations],
+      jobs: [...config.jobs ?? [], { name: "notify:send", run }],
+      listeners: [...config.listeners ?? [], { events: [...NOTIFY_EVENTS], handler: listen }]
+    };
+  }, INFO);
+}
+export {
+  ChannelError,
+  EVENT_LABELS,
+  NOTIFY_EVENTS,
+  notifyPlugin,
+  telegram
+};

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@easy-cms/plugin-notify",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.32.0",
+  "description": "Notifications for Easy CMS admins: Telegram messages when a form is submitted, an order comes in or something fails",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@easy-cms/core": "^1.32.0"
+  },
+  "devDependencies": {
+    "@easy-cms/core": "^1.32.0",
+    "@easy-cms/db-sqlite": "^1.32.0"
+  },
+  "engines": {
+    "node": ">=22.12"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/maritonx/easy-cms.git",
+    "directory": "packages/plugin-notify"
+  },
+  "keywords": [
+    "easy-cms",
+    "easy-cms-plugin",
+    "notifications",
+    "telegram"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
 }