@voltro/plugin-notifications 0.84.0 → 0.86.0

package/dist/rpc.d.ts

@@ -5,10 +5,10 @@ import { ReactivityChannel } from '@voltro/protocol';
 import { Schema } from 'effect';
 
 export declare const archiveDescriptor: MutationProcedureDescriptor<"notifications.archive", Schema.Struct<{
-    id: typeof Schema.String;
+    readonly id: Schema.String;
 }>, Schema.Struct<{
-    ok: typeof Schema.Boolean;
-}>, typeof Schema.Never>;
+    readonly ok: Schema.Boolean;
+}>, Schema.Never>;
 
 /**
  * The plugin's canonical package name — the key an app's `alias` is recorded
@@ -23,104 +23,104 @@ export declare const archiveDescriptor: MutationProcedureDescriptor<"notificatio
 export declare const BASE_NAME = "@voltro/plugin-notifications";
 
 export declare const clearQuietHoursDescriptor: MutationProcedureDescriptor<"notifications.clearQuietHours", Schema.Struct<{}>, Schema.Struct<{
-    ok: typeof Schema.Boolean;
-}>, typeof Schema.Never>;
+    readonly ok: Schema.Boolean;
+}>, Schema.Never>;
 
 export declare const inboxDescriptor: QueryProcedureDescriptor<"notifications.inbox", Schema.Struct<{
-    unreadOnly: Schema.optional<typeof Schema.Boolean>;
-    limit: Schema.optional<typeof Schema.Number>;
-}>, Schema.Array$<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, typeof Schema.Never>;
+    readonly unreadOnly: Schema.optional<Schema.Boolean>;
+    readonly limit: Schema.optional<Schema.Number>;
+}>, Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>, Schema.Never>;
 
 /** One push channel for the inbox: every in-app delivery and read-state
  *  change publishes, and `inbox` / `unreadCount` re-run for subscribers. */
 export declare const inboxFeed: ReactivityChannel;
 
 export declare const markAllReadDescriptor: MutationProcedureDescriptor<"notifications.markAllRead", Schema.Struct<{}>, Schema.Struct<{
-    count: typeof Schema.Number;
-}>, typeof Schema.Never>;
+    readonly count: Schema.Number;
+}>, Schema.Never>;
 
 export declare const markReadDescriptor: MutationProcedureDescriptor<"notifications.markRead", Schema.Struct<{
-    id: typeof Schema.String;
+    readonly id: Schema.String;
 }>, Schema.Struct<{
-    ok: typeof Schema.Boolean;
-}>, typeof Schema.Never>;
+    readonly ok: Schema.Boolean;
+}>, Schema.Never>;
 
 export declare const markUnreadDescriptor: MutationProcedureDescriptor<"notifications.markUnread", Schema.Struct<{
-    id: typeof Schema.String;
+    readonly id: Schema.String;
 }>, Schema.Struct<{
-    ok: typeof Schema.Boolean;
-}>, typeof Schema.Never>;
+    readonly ok: Schema.Boolean;
+}>, Schema.Never>;
 
 /** Declared for the codegen (`VoltroPlugin.rpcClientDescriptors`) so each tag is
  *  emitted into the generated client group. Kept in lockstep with the exports. */
 export declare const notificationsRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
 
-export declare const preferencesDescriptor: QueryProcedureDescriptor<"notifications.preferences", Schema.Struct<{}>, Schema.Array$<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>, typeof Schema.Never>;
+export declare const preferencesDescriptor: QueryProcedureDescriptor<"notifications.preferences", Schema.Struct<{}>, Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>, Schema.Never>;
 
 export declare const setPreferenceDescriptor: MutationProcedureDescriptor<"notifications.setPreference", Schema.Struct<{
-    category: typeof Schema.String;
-    channel: typeof Schema.String;
-    enabled: typeof Schema.Boolean;
+    readonly category: Schema.String;
+    readonly channel: Schema.String;
+    readonly enabled: Schema.Boolean;
 }>, Schema.Struct<{
-    ok: typeof Schema.Boolean;
-}>, typeof Schema.Never>;
+    readonly ok: Schema.Boolean;
+}>, Schema.Never>;
 
 export declare const setQuietHoursDescriptor: MutationProcedureDescriptor<"notifications.setQuietHours", Schema.Struct<{
-    startMinute: typeof Schema.Number;
-    endMinute: typeof Schema.Number;
-    tz: Schema.optional<typeof Schema.String>;
-    policy: Schema.optional<Schema.Literal<["hold", "drop"]>>;
+    readonly startMinute: Schema.Number;
+    readonly endMinute: Schema.Number;
+    readonly tz: Schema.optional<Schema.String>;
+    readonly policy: Schema.optional<Schema.Literals<readonly ["hold", "drop"]>>;
 }>, Schema.Struct<{
-    ok: typeof Schema.Boolean;
-}>, typeof Schema.Never>;
+    readonly ok: Schema.Boolean;
+}>, Schema.Never>;
 
 export declare const subscribeDescriptor: MutationProcedureDescriptor<"notifications.subscribe", Schema.Struct<{
-    topic: typeof Schema.String;
+    readonly topic: Schema.String;
 }>, Schema.Struct<{
-    ok: typeof Schema.Boolean;
-}>, typeof Schema.Never>;
+    readonly ok: Schema.Boolean;
+}>, Schema.Never>;
 
 export declare const unarchiveDescriptor: MutationProcedureDescriptor<"notifications.unarchive", Schema.Struct<{
-    id: typeof Schema.String;
+    readonly id: Schema.String;
 }>, Schema.Struct<{
-    ok: typeof Schema.Boolean;
-}>, typeof Schema.Never>;
+    readonly ok: Schema.Boolean;
+}>, Schema.Never>;
 
 export declare const unreadCountDescriptor: QueryProcedureDescriptor<"notifications.unreadCount", Schema.Struct<{}>, Schema.Struct<{
-    count: typeof Schema.Number;
-}>, typeof Schema.Never>;
+    readonly count: Schema.Number;
+}>, Schema.Never>;
 
 export declare const unsubscribeDescriptor: MutationProcedureDescriptor<"notifications.unsubscribe", Schema.Struct<{
-    topic: typeof Schema.String;
+    readonly topic: Schema.String;
 }>, Schema.Struct<{
-    ok: typeof Schema.Boolean;
-}>, typeof Schema.Never>;
+    readonly ok: Schema.Boolean;
+}>, Schema.Never>;
 
 export declare const webPushPublicKeyDescriptor: QueryProcedureDescriptor<"notifications.webPushPublicKey", Schema.Struct<{}>, Schema.Struct<{
-    key: typeof Schema.String;
-}>, typeof Schema.Never>;
+    readonly key: Schema.String;
+}>, Schema.Never>;
 
 /** Registered only when the app configures a web-push channel — see
  *  `notificationsPlugin`. */
 export declare const webPushRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
 
 export declare const webPushStatusDescriptor: QueryProcedureDescriptor<"notifications.webPushStatus", Schema.Struct<{}>, Schema.Struct<{
-    endpoints: typeof Schema.Number;
-}>, typeof Schema.Never>;
+    readonly endpoints: Schema.Number;
+}>, Schema.Never>;
 
 export declare const webPushSubscribeDescriptor: MutationProcedureDescriptor<"notifications.webPushSubscribe", Schema.Struct<{
-    endpoint: typeof Schema.String;
-    p256dh: typeof Schema.String;
-    auth: typeof Schema.String;
-    ua: Schema.optional<typeof Schema.String>;
+    readonly endpoint: Schema.String;
+    readonly p256dh: Schema.String;
+    readonly auth: Schema.String;
+    readonly ua: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
-    ok: typeof Schema.Boolean;
-}>, typeof Schema.Never>;
+    readonly ok: Schema.Boolean;
+}>, Schema.Never>;
 
 export declare const webPushUnsubscribeDescriptor: MutationProcedureDescriptor<"notifications.webPushUnsubscribe", Schema.Struct<{
-    endpoint: typeof Schema.String;
+    readonly endpoint: Schema.String;
 }>, Schema.Struct<{
-    ok: typeof Schema.Boolean;
-}>, typeof Schema.Never>;
+    readonly ok: Schema.Boolean;
+}>, Schema.Never>;
 
 export { }

package/dist/rpc.js

@@ -8,10 +8,7 @@ var i = "@voltro/plugin-notifications", a = r("notifications-inbox"), o = n({
 		unreadOnly: e.optional(e.Boolean),
 		limit: e.optional(e.Number)
 	}),
-	output: e.Array(e.Record({
-		key: e.String,
-		value: e.Unknown
-	})),
+	output: e.Array(e.Record(e.String, e.Unknown)),
 	openAccess: "self-scoped read: returns only the calling subject's own inbox items"
 }), s = n({
 	name: "notifications.unreadCount",
@@ -47,10 +44,7 @@ var i = "@voltro/plugin-notifications", a = r("notifications-inbox"), o = n({
 }), p = n({
 	name: "notifications.preferences",
 	input: e.Struct({}),
-	output: e.Array(e.Record({
-		key: e.String,
-		value: e.Unknown
-	})),
+	output: e.Array(e.Record(e.String, e.Unknown)),
 	openAccess: "self-scoped read: returns only the calling subject's own channel preferences"
 }), m = t({
 	name: "notifications.setPreference",
@@ -77,7 +71,7 @@ var i = "@voltro/plugin-notifications", a = r("notifications-inbox"), o = n({
 		startMinute: e.Number,
 		endMinute: e.Number,
 		tz: e.optional(e.String),
-		policy: e.optional(e.Literal("hold", "drop"))
+		policy: e.optional(e.Literals(["hold", "drop"]))
 	}),
 	output: e.Struct({ ok: e.Boolean }),
 	openAccess: "self-scoped write: sets only the calling subject's own quiet-hours window"

package/dist/sendNotification.js

@@ -0,0 +1,42 @@
+import { Schema as e } from "effect";
+//#region src/sendNotification.ts
+var t = (e) => {
+	if (typeof e == "object" && e) {
+		let t = e;
+		if (typeof t.userId == "string") return [t.userId];
+		if (Array.isArray(t.userIds)) return t.userIds.filter((e) => typeof e == "string");
+	}
+	throw Error("sendNotification: pass `recipients` — the audience has neither `userId` nor `userIds`");
+}, n = async (n, i, a) => {
+	let o = e.decodeUnknownSync(i.audience)(a.audience), s = e.decodeUnknownSync(i.payload)(a.payload), c = a.recipients ? await a.recipients(o) : t(o), l = [];
+	for (let e of c) {
+		let t = (a.localeFor ? await a.localeFor(e) : null) ?? a.defaultLocale ?? "en", o = await n.send(r(i, s, e, t, a.tenantId));
+		l.push({
+			recipientId: e,
+			locale: t,
+			result: o
+		});
+	}
+	return l;
+}, r = (e, t, n, r, i) => {
+	let a = e.render(t, {
+		locale: r,
+		recipientId: n
+	});
+	return {
+		to: n,
+		category: e.category,
+		title: a.title,
+		body: a.body,
+		data: {
+			...a.data,
+			notification: e.name,
+			...a.image === void 0 ? {} : { image: a.image },
+			...a.actions === void 0 ? {} : { actions: a.actions }
+		},
+		...e.channels === void 0 ? {} : { channels: e.channels },
+		...i === void 0 ? {} : { tenantId: i }
+	};
+};
+//#endregion
+export { t as defaultRecipients, r as sendInputFor, n as sendNotification };

package/dist/service.js

@@ -0,0 +1,212 @@
+import { resolveChannels as e } from "./channels.js";
+import { randomUUID as t } from "node:crypto";
+//#region src/service.ts
+var n = (e) => ({
+	id: "inApp",
+	deliver: async (n) => {
+		await e.addInbox({
+			id: t(),
+			subjectId: n.to,
+			category: n.category,
+			title: n.title,
+			body: n.body,
+			data: n.data ?? {},
+			tenantId: n.tenantId ?? null,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	}
+}), r = (e, t) => {
+	try {
+		let n = new Intl.DateTimeFormat("en-US", {
+			timeZone: t,
+			hour: "2-digit",
+			minute: "2-digit",
+			hour12: !1
+		}).formatToParts(e), r = Number(n.find((e) => e.type === "hour")?.value ?? "0") % 24, i = Number(n.find((e) => e.type === "minute")?.value ?? "0");
+		return r * 60 + i;
+	} catch {
+		return e.getUTCHours() * 60 + e.getUTCMinutes();
+	}
+}, i = (e, t) => {
+	if (e.startMinute === e.endMinute) return !1;
+	let n = r(t, e.tz ?? "UTC");
+	return e.startMinute < e.endMinute ? n >= e.startMinute && n < e.endMinute : n >= e.startMinute || n < e.endMinute;
+}, a = (e, t) => {
+	let n = r(t, e.tz ?? "UTC"), i = e.endMinute - n;
+	return i <= 0 && (i += 1440), new Date(t.getTime() + i * 6e4);
+}, o = (n) => {
+	let r = new Map(n.channels.map((e) => [e.id, e])), o = n.channels.map((e) => e.id), c = n.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()), l = n.digestWindowMs ?? 0, u = async (i) => {
+		let a = await n.store.getPreferences(i.to), s = e(o, i.category, i.channels, a, i.to), l = o.filter((e) => !s.includes(e)), u = [], d = [], f = {
+			to: i.to,
+			category: i.category,
+			title: i.title,
+			body: i.body,
+			...i.data ? { data: i.data } : {},
+			tenantId: i.tenantId ?? null
+		};
+		for (let e of s) {
+			let a = r.get(e);
+			if (!a) continue;
+			if (a.deliverDetailed !== void 0) {
+				try {
+					let r = await a.deliverDetailed(f);
+					for (let a of r) await n.store.recordDelivery({
+						id: t(),
+						to: i.to,
+						category: i.category,
+						channel: e,
+						at: c(),
+						status: a.status,
+						endpoint: a.endpoint,
+						...a.error === void 0 ? {} : { error: a.error },
+						...a.clickToken === void 0 ? {} : { clickToken: a.clickToken }
+					});
+					let o = r.filter((e) => e.status === "failed");
+					r.length === 0 || o.length < r.length ? u.push(e) : d.push({
+						channel: e,
+						error: o[0]?.error ?? "all endpoints failed"
+					});
+				} catch (r) {
+					let a = r instanceof Error ? r.message : String(r);
+					d.push({
+						channel: e,
+						error: a
+					}), await n.store.recordDelivery({
+						id: t(),
+						to: i.to,
+						category: i.category,
+						channel: e,
+						at: c(),
+						status: "failed",
+						error: a
+					});
+				}
+				continue;
+			}
+			let o = {
+				id: t(),
+				to: i.to,
+				category: i.category,
+				channel: e,
+				at: c()
+			};
+			try {
+				await a.deliver(f), u.push(e), await n.store.recordDelivery({
+					...o,
+					status: "sent"
+				});
+			} catch (t) {
+				let r = t instanceof Error ? t.message : String(t);
+				d.push({
+					channel: e,
+					error: r
+				}), await n.store.recordDelivery({
+					...o,
+					status: "failed",
+					error: r
+				});
+			}
+		}
+		return {
+			delivered: u,
+			failed: d,
+			skipped: l
+		};
+	}, d = async (e) => {
+		let r = await n.store.getQuietHours(e.to), o = new Date(c());
+		if (r && i(r, o)) return (r.policy ?? "hold") === "drop" ? {
+			delivered: [],
+			failed: [],
+			skipped: [],
+			held: "quiet-drop"
+		} : (await n.store.enqueueHeld({
+			id: t(),
+			kind: "quiet",
+			subjectId: e.to,
+			send: e,
+			flushAt: a(r, o).toISOString()
+		}), {
+			delivered: [],
+			failed: [],
+			skipped: [],
+			held: "quiet-held"
+		});
+		if (l > 0 && !e.channels) {
+			let r = (await n.store.pendingDigest(e.to))[0]?.flushAt ?? new Date(o.getTime() + l).toISOString();
+			return await n.store.enqueueHeld({
+				id: t(),
+				kind: "digest",
+				subjectId: e.to,
+				send: e,
+				flushAt: r
+			}), {
+				delivered: [],
+				failed: [],
+				skipped: [],
+				held: "digest"
+			};
+		}
+		return u(e);
+	};
+	return {
+		send: d,
+		inbox: (e, t) => n.store.listInbox(e, t),
+		unreadCount: (e) => n.store.unreadCount(e),
+		markRead: (e, t) => n.store.markRead(e, t),
+		markUnread: (e, t) => n.store.markUnread(e, t),
+		markAllRead: (e) => n.store.markAllRead(e),
+		setArchived: (e, t, r) => n.store.setArchived(e, t, r),
+		getPreferences: (e) => n.store.getPreferences(e),
+		setPreference: (e) => n.store.setPreference(e),
+		subscribe: (e, t, r) => n.store.subscribeTopic({
+			topic: e,
+			subjectId: t,
+			tenantId: r ?? null
+		}),
+		unsubscribe: (e, t) => n.store.unsubscribeTopic(e, t),
+		broadcast: async (e, t) => {
+			let r = await n.store.listTopicSubscribers(e), i = [];
+			for (let e of r) i.push(await d({
+				...t,
+				to: e.subjectId,
+				tenantId: t.tenantId ?? e.tenantId ?? null
+			}));
+			return {
+				recipients: r.length,
+				results: i
+			};
+		},
+		setQuietHours: (e) => n.store.setQuietHours(e),
+		clearQuietHours: (e) => n.store.clearQuietHours(e),
+		getQuietHours: (e) => n.store.getQuietHours(e),
+		flushDue: async (e = new Date(c())) => {
+			let t = await n.store.dueHeld(e.toISOString());
+			if (t.length === 0) return 0;
+			for (let e of t.filter((e) => e.kind === "quiet")) await u(e.send);
+			let r = /* @__PURE__ */ new Map();
+			for (let e of t.filter((e) => e.kind === "digest")) {
+				let t = r.get(e.subjectId) ?? [];
+				t.push(e), r.set(e.subjectId, t);
+			}
+			for (let [e, t] of r) await u(s(e, t));
+			return await n.store.clearHeld(t.map((e) => e.id)), t.length;
+		}
+	};
+}, s = (e, t) => {
+	if (t.length === 1) return t[0].send;
+	let n = t.map((e) => ({
+		category: e.send.category,
+		title: e.send.title,
+		body: e.send.body
+	}));
+	return {
+		to: e,
+		category: "digest",
+		title: `${t.length} new notifications`,
+		body: n.map((e) => `• ${e.title}`).join("\n"),
+		data: { items: n },
+		tenantId: t[0].send.tenantId ?? null
+	};
+};
+//#endregion
+export { o as buildNotificationService, n as inAppChannel, i as inQuietHours, r as minuteOfDayInZone, a as quietHoursEnd };