@voltro/plugin-notifications 0.83.1 → 0.85.0

package/THIRD-PARTY-NOTICES.md

@@ -5,66 +5,10 @@ property of its respective copyright holders and is used under the terms of
 its license. This file is provided for attribution; it grants no rights in
 @voltro/plugin-notifications itself, which is proprietary (see LICENSE).
 
-Generated from the resolved runtime dependency closure (13 packages).
+Generated from the resolved runtime dependency closure (11 packages).
 
 ---
 
-## @effect/experimental@0.61.1
-
-License: MIT
-
-```
-MIT License
-
-Copyright (c) 2023-present The Contributors
-
-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.
-```
-
-## @effect/sql@0.52.1
-
-License: MIT
-
-```
-MIT License
-
-Copyright (c) 2023-present The Contributors
-
-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.
-```
-
 ## @tanstack/devtools-event-client@0.4.4
 
 License: MIT

package/dist/define.d.ts

@@ -7,8 +7,8 @@ export declare interface DefineNotificationConfig<Audience, Payload> {
     readonly name: string;
     /** The notifications category preferences are keyed by. Default: `name`. */
     readonly category?: string;
-    readonly audience: Schema.Schema<Audience, any>;
-    readonly payload: Schema.Schema<Payload, any>;
+    readonly audience: Schema.Codec<Audience, any>;
+    readonly payload: Schema.Codec<Payload, any>;
     /** PURE: payload + locale → what the recipient sees. No IO. */
     readonly render: (payload: Payload, ctx: RenderContext) => RenderedNotification;
     /** Restrict to these channels (ids); default: every configured channel,
@@ -20,8 +20,8 @@ export declare interface NotificationDescriptor<Audience = unknown, Payload = un
     readonly _tag: 'VoltroNotification';
     readonly name: string;
     readonly category: string;
-    readonly audience: Schema.Schema<Audience, any>;
-    readonly payload: Schema.Schema<Payload, any>;
+    readonly audience: Schema.Codec<Audience, any>;
+    readonly payload: Schema.Codec<Payload, any>;
     readonly render: (payload: Payload, ctx: RenderContext) => RenderedNotification;
     readonly channels?: ReadonlyArray<string>;
 }

package/dist/index.d.ts

@@ -5,6 +5,7 @@ import { FieldDefinitions } from '@voltro/database';
 import { Schema } from 'effect';
 import { Table } from '@voltro/database';
 import { VoltroPlugin } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
 
 export declare const APNS_HOSTS: {
     readonly production: "https://api.push.apple.com";
@@ -135,8 +136,8 @@ export declare interface DefineNotificationConfig<Audience, Payload> {
     readonly name: string;
     /** The notifications category preferences are keyed by. Default: `name`. */
     readonly category?: string;
-    readonly audience: Schema.Schema<Audience, any>;
-    readonly payload: Schema.Schema<Payload, any>;
+    readonly audience: Schema.Codec<Audience, any>;
+    readonly payload: Schema.Codec<Payload, any>;
     /** PURE: payload + locale → what the recipient sees. No IO. */
     readonly render: (payload: Payload, ctx: RenderContext) => RenderedNotification;
     /** Restrict to these channels (ids); default: every configured channel,
@@ -413,8 +414,8 @@ export declare interface NotificationDescriptor<Audience = unknown, Payload = un
     readonly _tag: 'VoltroNotification';
     readonly name: string;
     readonly category: string;
-    readonly audience: Schema.Schema<Audience, any>;
-    readonly payload: Schema.Schema<Payload, any>;
+    readonly audience: Schema.Codec<Audience, any>;
+    readonly payload: Schema.Codec<Payload, any>;
     readonly render: (payload: Payload, ctx: RenderContext) => RenderedNotification;
     readonly channels?: ReadonlyArray<string>;
 }
@@ -442,7 +443,7 @@ export declare interface NotificationOutboxHandlerOptions {
 export declare class NotificationService extends NotificationService_base {
 }
 
-declare const NotificationService_base: Context.TagClass<NotificationService, "@voltro/plugin-notifications/NotificationService", NotificationServiceShape>;
+declare const NotificationService_base: Context.ServiceClass<NotificationService, "@voltro/plugin-notifications/NotificationService", NotificationServiceShape>;
 
 export declare interface NotificationServiceShape {
     readonly send: (input: SendInput) => Promise<SendResult>;
@@ -758,12 +759,10 @@ export declare interface PushSubscriptionStore {
 export declare class PushTokenRejected extends PushTokenRejected_base {
 }
 
-declare const PushTokenRejected_base: Schema.TaggedErrorClass<PushTokenRejected, "PushTokenRejected", {
-    readonly _tag: Schema.tag<"PushTokenRejected">;
-} & {
-    token: typeof Schema.String;
-    reason: typeof Schema.String;
-}>;
+declare const PushTokenRejected_base: Schema.Class<PushTokenRejected, Schema.TaggedStruct<"PushTokenRejected", {
+    readonly token: Schema.String;
+    readonly reason: Schema.String;
+}>, YieldableError>;
 
 /** A per-subject Do-Not-Disturb window, expressed in minutes-of-day in the
  *  subject's `tz` (an IANA zone). A window may WRAP midnight (`startMinute` >

package/dist/index.js

@@ -259,13 +259,26 @@ var I = class extends _.TaggedError()("PushTokenRejected", {
 		},
 		markRead: async (n, r) => (await t("_voltro_notification_inbox", v(b("id", n), b("subjectId", r)), [], 1))[0] ? (await e.update("_voltro_notification_inbox", n, { readAt: (/* @__PURE__ */ new Date()).toISOString() }), !0) : !1,
 		markUnread: async (n, r) => (await t("_voltro_notification_inbox", v(b("id", n), b("subjectId", r)), [], 1))[0] ? (await e.update("_voltro_notification_inbox", n, { readAt: null }), !0) : !1,
-		markAllRead: async (n) => {
-			let r = await t("_voltro_notification_inbox", v(b("subjectId", n), w("readAt")), [], void 0), i = (/* @__PURE__ */ new Date()).toISOString();
-			for (let t of r) await e.update("_voltro_notification_inbox", String(t.id), { readAt: i });
-			return r.length;
+		markAllRead: async (t) => {
+			let n = /* @__PURE__ */ new Date();
+			return e.updateMany("_voltro_notification_inbox", { readAt: n }, { where: v(b("subjectId", t), w("readAt")) });
 		},
 		setArchived: async (n, r, i) => (await t("_voltro_notification_inbox", v(b("id", n), b("subjectId", r)), [], 1))[0] ? (await e.update("_voltro_notification_inbox", n, { archivedAt: i ? (/* @__PURE__ */ new Date()).toISOString() : null }), !0) : !1,
-		unreadCount: async (e) => (await t("_voltro_notification_inbox", v(b("subjectId", e), w("readAt")), [], void 0)).length,
+		unreadCount: async (t) => {
+			let n = await e.query({
+				table: "_voltro_notification_inbox",
+				predicate: v(b("subjectId", t), w("readAt")),
+				order: [],
+				take: void 0,
+				skip: void 0,
+				projection: void 0,
+				aggregations: [{
+					op: "count",
+					alias: "count"
+				}]
+			});
+			return Number(n[0]?.count ?? 0);
+		},
 		getPreferences: async (e) => (await t("_voltro_notification_preferences", b("subjectId", e), [], void 0)).map(r),
 		setPreference: async (t) => {
 			let n = x({
@@ -1172,7 +1185,7 @@ var I = class extends _.TaggedError()("PushTokenRejected", {
 	subjectId: A(),
 	send: T(),
 	flushAt: j()
-}).renamedFrom("notification_held").index("byHeldFlushAt", ["flushAt"]).index("byHeldSubjectKind", ["subjectId", "kind"]), $ = class extends oe.Tag("@voltro/plugin-notifications/NotificationService")() {}, Nt = (e) => async (t) => {
+}).renamedFrom("notification_held").index("byHeldFlushAt", ["flushAt"]).index("byHeldSubjectKind", ["subjectId", "kind"]), $ = class extends oe.Service()("@voltro/plugin-notifications/NotificationService") {}, Nt = (e) => async (t) => {
 	if (e !== void 0) try {
 		let n = await e(t);
 		if (typeof n == "string" && n !== "") return n;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/plugin-notifications",
-  "version": "0.83.1",
+  "version": "0.85.0",
   "description": "One unified notification surface — email, Slack/webhook, SMS, push, in-app — with per-subject preference routing, an in-app inbox, and a delivery log. NotificationService + typed routes + useInbox/useUnreadCount hooks.",
   "keywords": [
     "voltro",
@@ -49,12 +49,12 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/client": "0.83.1",
-    "@voltro/database": "0.83.1",
-    "@voltro/protocol": "0.83.1"
+    "@voltro/client": "0.85.0",
+    "@voltro/database": "0.85.0",
+    "@voltro/protocol": "0.85.0"
   },
   "peerDependencies": {
-    "effect": "^3.22.2",
+    "effect": "4.0.1",
     "react": "^19.0.0"
   },
   "publishConfig": {