@12-apps/notifications 4.11.0 → 4.13.0

package/dist/{chunk-2TJ4D2KE.js → chunk-4DTUD74E.js}

@@ -306,7 +306,7 @@ import { Suspense as Suspense2, lazy as lazy2 } from "react";
 import { jsx as jsx3 } from "react/jsx-runtime";
 function lazyPreferencesPage(parts) {
   const Bound = lazy2(async () => {
-    const { PreferencesScreen } = await import("./preferences-screen-SXUIGECY.js");
+    const { PreferencesScreen } = await import("./preferences-screen-YRPNUZS5.js");
     return {
       default: /* @__PURE__ */ __name((props) => /* @__PURE__ */ jsx3(PreferencesScreen, { ...props, ...parts }), "default")
     };
@@ -395,4 +395,4 @@ export {
   httpNotificationsTransport,
   createWebNotifications
 };
-//# sourceMappingURL=chunk-2TJ4D2KE.js.map
+//# sourceMappingURL=chunk-4DTUD74E.js.map

package/dist/{chunk-WVRODNXQ.js → chunk-53SH5ABN.js}

@@ -1,13 +1,15 @@
 import {
   DEFAULT_CHANNEL_ROW,
   UnknownNotificationRecipientError,
+  capToAvailable,
   createGeneratorRegistry,
   enabledChannelsOf,
+  explicitChoicesOf,
   inboxWire,
-  mergeChoices,
   mergeStoredRow,
-  normalizePhoneE164
-} from "./chunk-SWOWHIFE.js";
+  normalizePhoneE164,
+  resolveTypeChannels
+} from "./chunk-XFODKRRB.js";
 import {
   messagesOf
 } from "./chunk-M2TVBVH2.js";
@@ -17,7 +19,7 @@ import {
 import {
   NOTIFICATION_CHANNELS,
   taxonomyOf
-} from "./chunk-6W7INOYQ.js";
+} from "./chunk-CSMFJJXY.js";
 import {
   renderEmail
 } from "./chunk-EKUSNUBT.js";
@@ -437,7 +439,7 @@ function webPushTransport(declaration, subscriptions, extraDrivers = {}) {
     supports: /* @__PURE__ */ __name((recipient) => recipient.pushSubscriptionCount > 0, "supports"),
     format: formatWebPush,
     async send(message, recipient) {
-      const rows = await subscriptions.list(recipient.userId);
+      const rows = await subscriptions.list(recipient.userId, recipient.clientId);
       if (rows.length === 0) throw new Error("Recipient no longer has push subscriptions.");
       const payload = JSON.stringify(message);
       let delivered = 0;
@@ -680,7 +682,7 @@ var DEFAULT_MAX_DELIVERY_ATTEMPTS = 5;
 var DEFAULT_SWEEP_TAKE = 200;
 var DEFAULT_SWEEP_CUTOFF_MS = 5 * 6e4;
 var RETRYABLE = ["FAILED", "QUEUED", "SENDING"];
-async function loadRecipient(deps, userId) {
+async function loadRecipient(deps, userId, clientId) {
   const contact = await deps.contacts.getContact(userId);
   if (!contact) return null;
   return {
@@ -691,7 +693,11 @@ async function loadRecipient(deps, userId) {
     // absent case has to stay distinguishable from a stated language, because
     // that is what lets a generator apply its own default in one place.
     ...contact.locale === void 0 ? {} : { locale: contact.locale },
-    pushSubscriptionCount: await deps.pushSubscriptions.count(userId)
+    clientId,
+    // SCOPED, and this is what keeps `supports()` honest: it gates on this
+    // number, so an unscoped count would enqueue a WEB_PUSH delivery for a
+    // notification no reachable subscription exists for.
+    pushSubscriptionCount: await deps.pushSubscriptions.count(userId, clientId)
   };
 }
 __name(loadRecipient, "loadRecipient");
@@ -757,7 +763,7 @@ async function dispatchOne(deps, notificationId) {
     where: { notificationId, status: "QUEUED" }
   });
   if (queued.length === 0) return 0;
-  const recipient = await loadRecipient(deps, notification.userId);
+  const recipient = await loadRecipient(deps, notification.userId, notification.clientId);
   if (!recipient) {
     await abandonUnreachable(deps, client, queued, notification.userId);
     return 0;
@@ -803,6 +809,10 @@ async function drainPending(deps, olderThanMs, take) {
 __name(drainPending, "drainPending");
 
 // src/server/inbox.ts
+function scopeBranch(scope) {
+  return scope === void 0 ? [] : [{ OR: [{ clientId: scope }, { clientId: null }] }];
+}
+__name(scopeBranch, "scopeBranch");
 var DEFAULT_PAGE = 20;
 var MAX_PAGE = 100;
 async function resolveAnchor(notifications, userId, cursor) {
@@ -811,31 +821,47 @@ async function resolveAnchor(notifications, userId, cursor) {
   return { createdAt: anchor.createdAt, id: anchor.id };
 }
 __name(resolveAnchor, "resolveAnchor");
-function pageWhere(userId, filter, anchor) {
+function pageWhere(userId, filter, anchor, scope) {
+  const clauses = [
+    // `(createdAt, id) < (anchor.createdAt, anchor.id)`, as a portable `where`.
+    ...anchor ? [
+      {
+        OR: [
+          { createdAt: { lt: anchor.createdAt } },
+          { createdAt: anchor.createdAt, id: { lt: anchor.id } }
+        ]
+      }
+    ] : [],
+    ...scopeBranch(scope)
+  ];
   return {
     userId,
     deletedAt: null,
     ...filter === "unread" ? { readAt: null } : {},
-    // `(createdAt, id) < (anchor.createdAt, anchor.id)`, as a portable `where`.
-    ...anchor ? {
-      OR: [
-        { createdAt: { lt: anchor.createdAt } },
-        { createdAt: anchor.createdAt, id: { lt: anchor.id } }
-      ]
-    } : {}
+    ...clauses.length > 0 ? { AND: clauses } : {}
   };
 }
 __name(pageWhere, "pageWhere");
+function unreadWhere(userId, scope) {
+  const scoped = scopeBranch(scope);
+  return {
+    userId,
+    deletedAt: null,
+    readAt: null,
+    ...scoped.length > 0 ? { AND: scoped } : {}
+  };
+}
+__name(unreadWhere, "unreadWhere");
 function createInboxStore(db) {
   return {
     /** The owner's inbox, newest first, keyset-paginated, deleted excluded. */
-    async list(userId, input = {}) {
+    async list(userId, input = {}, scope) {
       const client = await db();
       const limit = Math.min(Math.max(input.limit ?? DEFAULT_PAGE, 1), MAX_PAGE);
       const anchor = input.cursor ? await resolveAnchor(client.notification, userId, input.cursor) : void 0;
       if (input.cursor && !anchor) return { items: [], nextCursor: null };
       const rows = await client.notification.findMany({
-        where: pageWhere(userId, input.filter, anchor),
+        where: pageWhere(userId, input.filter, anchor, scope),
         // `id` tie-breaks equal timestamps so pages never skip/repeat.
         orderBy: [{ createdAt: "desc" }, { id: "desc" }],
         take: limit + 1
@@ -847,9 +873,9 @@ function createInboxStore(db) {
       };
     },
     /** Unread badge count (non-deleted, unread). */
-    async unreadCount(userId) {
+    async unreadCount(userId, scope) {
       const client = await db();
-      return client.notification.count({ where: { userId, deletedAt: null, readAt: null } });
+      return client.notification.count({ where: unreadWhere(userId, scope) });
     },
     /**
      * Mark specific notifications read. Only the owner's own, still-unread,
@@ -866,10 +892,10 @@ function createInboxStore(db) {
       return result.count;
     },
     /** Mark every unread notification of the owner read ("mark all"). */
-    async markAllRead(userId) {
+    async markAllRead(userId, scope) {
       const client = await db();
       const result = await client.notification.updateMany({
-        where: { userId, deletedAt: null, readAt: null },
+        where: unreadWhere(userId, scope),
         data: { readAt: /* @__PURE__ */ new Date() }
       });
       return result.count;
@@ -920,6 +946,14 @@ function createPreferenceStore(db, taxonomy, channelDefaults = {}) {
      * A category outside the taxonomy is IGNORED rather than stored: the DB
      * CHECK would reject it anyway, and a 500 from a stale client's extra key
      * would fail the whole save including the toggle the user did flip.
+     *
+     * What is written is the user's EXPLICIT choices only, never their
+     * effective row. Merging onto the effective row wrote a boolean for all
+     * four channels the moment anyone touched any switch, so the row could
+     * never again say "no opinion" about a channel — which silently disabled
+     * every per-type and per-host default for that user, and defeated the
+     * missing-key fallback that lets a new channel ship without a data
+     * migration.
      */
     async save(userId, input) {
       const client = await db();
@@ -928,8 +962,7 @@ function createPreferenceStore(db, taxonomy, channelDefaults = {}) {
         const existing = await client.notificationPreference.findUnique({
           where: { userId_category: { userId, category } }
         });
-        const current = existing ? mergeStoredRow(existing.channels, defaultRow) : defaultRow;
-        const channels = mergeChoices(current, choices);
+        const channels = { ...explicitChoicesOf(existing?.channels), ...choices };
         await client.notificationPreference.upsert({
           where: { userId_category: { userId, category } },
           create: { userId, category, channels },
@@ -937,20 +970,27 @@ function createPreferenceStore(db, taxonomy, channelDefaults = {}) {
         });
       }
     },
-    async enabledChannels(userId, category) {
+    async enabledChannels(userId, category, rules) {
       const client = await db();
       const row = await client.notificationPreference.findUnique({
         where: { userId_category: { userId, category } }
       });
-      return enabledChannelsOf(
-        row ? mergeStoredRow(row.channels, defaultRow) : defaultRow
-      );
+      return resolveTypeChannels({
+        stored: row?.channels,
+        categoryDefaults: defaultRow,
+        rules
+      });
     }
   };
 }
 __name(createPreferenceStore, "createPreferenceStore");
 
 // src/server/push-subscriptions.ts
+function reachableBy(userId, notificationClientId) {
+  if (notificationClientId === void 0 || notificationClientId === null) return { userId };
+  return { userId, OR: [{ clientId: null }, { clientId: notificationClientId }] };
+}
+__name(reachableBy, "reachableBy");
 function createPushSubscriptionStore(db, logger) {
   return {
     async save(userId, input) {
@@ -970,12 +1010,18 @@ function createPushSubscriptionStore(db, logger) {
           endpoint: input.endpoint,
           p256dh: input.keys.p256dh,
           auth: input.keys.auth,
+          clientId: input.clientId ?? null,
           userAgent: input.userAgent ?? null
         },
+        // Re-stamped on every save, so the same browser moving between a store's
+        // app and the platform corrects its own scope rather than keeping the
+        // first origin it ever subscribed from. A scope change on the SAME user
+        // is not a re-own and must not log one.
         update: {
           userId,
           p256dh: input.keys.p256dh,
           auth: input.keys.auth,
+          clientId: input.clientId ?? null,
           userAgent: input.userAgent ?? null
         }
       });
@@ -984,18 +1030,20 @@ function createPushSubscriptionStore(db, logger) {
       const client = await db();
       await client.pushSubscription.deleteMany({ where: { userId, endpoint } });
     },
-    async count(userId) {
+    async count(userId, notificationClientId) {
       const client = await db();
-      return client.pushSubscription.count({ where: { userId } });
+      return client.pushSubscription.count({ where: reachableBy(userId, notificationClientId) });
     },
     async isRegisteredTo(userId, endpoint) {
       const client = await db();
       const row = await client.pushSubscription.findUnique({ where: { endpoint } });
       return row?.userId === userId;
     },
-    async list(userId) {
+    async list(userId, notificationClientId) {
       const client = await db();
-      const rows = await client.pushSubscription.findMany({ where: { userId } });
+      const rows = await client.pushSubscription.findMany({
+        where: reachableBy(userId, notificationClientId)
+      });
       return rows.map((row) => ({
         id: row.id,
         endpoint: row.endpoint,
@@ -1012,12 +1060,13 @@ function createPushSubscriptionStore(db, logger) {
 __name(createPushSubscriptionStore, "createPushSubscriptionStore");
 
 // src/server/routes.ts
-async function channelAvailability(deps, userId) {
+async function channelAvailability(deps, userId, scopeClientId) {
   const contact = await deps.contacts.getContact(userId);
   const recipient = {
     userId,
     email: contact?.email ?? null,
     phone: contact?.phone ?? null,
+    clientId: scopeClientId,
     pushSubscriptionCount: 1
   };
   return Object.fromEntries(
@@ -1028,10 +1077,10 @@ async function channelAvailability(deps, userId) {
   );
 }
 __name(channelAvailability, "channelAvailability");
-async function preferencesPayload(deps, userId) {
+async function preferencesPayload(deps, userId, scopeClientId) {
   const [preferences, availability] = await Promise.all([
     deps.preferences.get(userId),
-    channelAvailability(deps, userId)
+    channelAvailability(deps, userId, scopeClientId)
   ]);
   return { preferences, availability, categories: [...deps.categories] };
 }
@@ -1045,7 +1094,8 @@ function inboxRoutes(deps) {
         async ({ actor, query, locale }) => ok(
           await deps.inbox.list(
             actor.userId,
-            parseListQuery(query, messagesOf(deps, locale))
+            parseListQuery(query, messagesOf(deps, locale)),
+            actor.scopeClientId
           )
         )
       )
@@ -1056,7 +1106,7 @@ function inboxRoutes(deps) {
       handle: guarded(
         async ({ actor }) => (
           // Polled by the SPAs, so it stays a single indexed COUNT.
-          ok({ count: await deps.inbox.unreadCount(actor.userId) })
+          ok({ count: await deps.inbox.unreadCount(actor.userId, actor.scopeClientId) })
         )
       )
     },
@@ -1065,7 +1115,7 @@ function inboxRoutes(deps) {
       path: "/notifications/mark-read",
       handle: guarded(async ({ actor, body, locale }) => {
         const target = parseMarkReadBody(body, messagesOf(deps, locale));
-        const updated = "all" in target ? await deps.inbox.markAllRead(actor.userId) : await deps.inbox.markRead(actor.userId, target.ids);
+        const updated = "all" in target ? await deps.inbox.markAllRead(actor.userId, actor.scopeClientId) : await deps.inbox.markRead(actor.userId, target.ids);
         if (updated > 0) deps.onInboxChanged?.(actor.userId);
         return ok({ updated });
       })
@@ -1091,7 +1141,9 @@ function preferenceRoutes(deps) {
     {
       method: "GET",
       path: "/notification-preferences",
-      handle: guarded(async ({ actor }) => ok(await preferencesPayload(deps, actor.userId)))
+      handle: guarded(
+        async ({ actor }) => ok(await preferencesPayload(deps, actor.userId, actor.scopeClientId ?? null))
+      )
     },
     {
       method: "PUT",
@@ -1101,7 +1153,7 @@ function preferenceRoutes(deps) {
           actor.userId,
           parsePreferencesBody(body, messagesOf(deps, locale))
         );
-        return ok(await preferencesPayload(deps, actor.userId));
+        return ok(await preferencesPayload(deps, actor.userId, actor.scopeClientId ?? null));
       })
     }
   ];
@@ -1132,6 +1184,9 @@ function pushRoutes(deps) {
         const input = parsePushSubscriptionBody(body, messagesOf(deps, locale));
         const userAgent = headers?.["user-agent"];
         await deps.pushSubscriptions.save(actor.userId, {
+          // The HOST's resolved origin, never the body's — a caller cannot
+          // choose which store's app their browser counts as.
+          clientId: actor.scopeClientId ?? null,
           ...input,
           ...userAgent ? { userAgent } : {}
         });
@@ -1189,13 +1244,19 @@ function announce(deps, notification) {
   }
 }
 __name(announce, "announce");
-async function resolveChannels(deps, event, category, recipient) {
-  const enabled = await deps.preferences.enabledChannels(event.recipient.userId, category);
+async function resolveChannels(deps, event, generator, recipient) {
+  const rules = { channels: generator.channels, channelDefaults: generator.channelDefaults };
+  const enabled = await deps.preferences.enabledChannels(
+    event.recipient.userId,
+    generator.category,
+    rules
+  );
   const supported = enabled.filter((channel) => {
     const transport = deps.transports.get(channel);
     return transport !== null && transport.supports(recipient);
   });
-  return applyPolicy(deps, event.recipient.clientId, supported);
+  const permitted = await applyPolicy(deps, event.recipient.clientId, supported);
+  return capToAvailable(permitted, generator.channels);
 }
 __name(resolveChannels, "resolveChannels");
 async function commit(deps, event, category, content, channels) {
@@ -1232,10 +1293,14 @@ function createNotificationRouter(deps) {
     drainPending: /* @__PURE__ */ __name((olderThanMs = DEFAULT_SWEEP_CUTOFF_MS, take = DEFAULT_SWEEP_TAKE) => drainPending(deps, olderThanMs, take), "drainPending"),
     async notify(event, options = {}) {
       const generator = deps.generators.resolve(event.type);
-      const recipient = await loadRecipient(deps, event.recipient.userId);
+      const recipient = await loadRecipient(
+        deps,
+        event.recipient.userId,
+        event.recipient.clientId ?? null
+      );
       if (!recipient) throw new UnknownNotificationRecipientError(event.recipient.userId);
       const content = generator.generate(event.payload, { locale: recipient.locale });
-      const channels = await resolveChannels(deps, event, generator.category, recipient);
+      const channels = await resolveChannels(deps, event, generator, recipient);
       const notification = await commit(deps, event, generator.category, content, channels);
       announce(deps, {
         notificationId: notification.id,
@@ -1353,4 +1418,4 @@ export {
   createTransportRegistry,
   createApiNotifications
 };
-//# sourceMappingURL=chunk-WVRODNXQ.js.map
+//# sourceMappingURL=chunk-53SH5ABN.js.map