@12-apps/notifications 4.1.0 → 4.2.0

package/dist/chunk-4PSUZ7X5.js

@@ -0,0 +1,1320 @@
+import {
+  DEFAULT_CHANNEL_ROW,
+  UnknownNotificationRecipientError,
+  createGeneratorRegistry,
+  enabledChannelsOf,
+  inboxWire,
+  mergeChoices,
+  mergeStoredRow,
+  normalizePhoneE164
+} from "./chunk-AHNRSA6U.js";
+import {
+  NOTIFICATION_CHANNELS,
+  messagesOf,
+  taxonomyOf
+} from "./chunk-4TTYQVPK.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/server/context.ts
+var NotificationsApiError = class _NotificationsApiError extends Error {
+  static {
+    __name(this, "NotificationsApiError");
+  }
+  status;
+  constructor(status, message) {
+    super(message);
+    this.name = "NotificationsApiError";
+    this.status = status;
+    Object.setPrototypeOf(this, _NotificationsApiError.prototype);
+  }
+};
+var ok = /* @__PURE__ */ __name((data, status = 200) => ({
+  status,
+  body: { data }
+}), "ok");
+var fail = /* @__PURE__ */ __name((status, error) => ({
+  status,
+  body: { error }
+}), "fail");
+function foldApiError(error) {
+  if (error instanceof NotificationsApiError) return fail(error.status, error.message);
+  throw error;
+}
+__name(foldApiError, "foldApiError");
+function guarded(handle) {
+  return async (request) => {
+    try {
+      return await handle(request);
+    } catch (error) {
+      return foldApiError(error);
+    }
+  };
+}
+__name(guarded, "guarded");
+function asRecord(body, messages) {
+  if (typeof body !== "object" || body === null || Array.isArray(body)) {
+    throw new NotificationsApiError(400, messages.invalidBody);
+  }
+  return body;
+}
+__name(asRecord, "asRecord");
+function parseIds(value, messages) {
+  if (!Array.isArray(value) || value.length === 0 || value.length > 100) {
+    throw new NotificationsApiError(400, messages.invalidBody);
+  }
+  return value.map((id) => {
+    if (typeof id !== "string" || id.length === 0) {
+      throw new NotificationsApiError(400, messages.invalidBody);
+    }
+    return id;
+  });
+}
+__name(parseIds, "parseIds");
+function parseLimit(raw, messages) {
+  if (raw === void 0 || raw === "") return void 0;
+  const limit = Number(raw);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+    throw new NotificationsApiError(400, messages.invalidBody);
+  }
+  return limit;
+}
+__name(parseLimit, "parseLimit");
+function parseFilter(raw, messages) {
+  if (raw === void 0) return void 0;
+  if (raw !== "all" && raw !== "unread") {
+    throw new NotificationsApiError(400, messages.invalidBody);
+  }
+  return raw;
+}
+__name(parseFilter, "parseFilter");
+function parseListQuery(query, messages) {
+  const filter = parseFilter(query.filter, messages);
+  const limit = parseLimit(query.limit, messages);
+  return {
+    ...filter !== void 0 ? { filter } : {},
+    ...query.cursor ? { cursor: query.cursor } : {},
+    ...limit !== void 0 ? { limit } : {}
+  };
+}
+__name(parseListQuery, "parseListQuery");
+function parseMarkReadBody(body, messages) {
+  const record = asRecord(body, messages);
+  const wantsAll = record.all === true;
+  const hasIds = record.ids !== void 0;
+  if (wantsAll === hasIds) {
+    throw new NotificationsApiError(400, messages.markReadTargetRequired);
+  }
+  return wantsAll ? { all: true } : { ids: parseIds(record.ids, messages) };
+}
+__name(parseMarkReadBody, "parseMarkReadBody");
+function parseDeleteBody(body, messages) {
+  return parseIds(asRecord(body, messages).ids, messages);
+}
+__name(parseDeleteBody, "parseDeleteBody");
+function parsePreferencesBody(body, messages) {
+  const record = asRecord(body, messages);
+  const parsed = {};
+  for (const [category, value] of Object.entries(record)) {
+    parsed[category] = parseToggles(value, messages);
+  }
+  return parsed;
+}
+__name(parsePreferencesBody, "parsePreferencesBody");
+function parseToggles(value, messages) {
+  const toggles = asRecord(value, messages);
+  const row = {};
+  for (const channel of NOTIFICATION_CHANNELS) {
+    const flag = toggles[channel];
+    if (flag === void 0) continue;
+    if (typeof flag !== "boolean") throw new NotificationsApiError(400, messages.invalidBody);
+    row[channel] = flag;
+  }
+  return row;
+}
+__name(parseToggles, "parseToggles");
+var MAX_ENDPOINT_CHARS = 2e3;
+var MAX_KEY_CHARS = 500;
+function parseEndpoint(value, messages) {
+  if (typeof value !== "string" || value.length === 0 || value.length > MAX_ENDPOINT_CHARS) {
+    throw new NotificationsApiError(400, messages.invalidBody);
+  }
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new NotificationsApiError(400, messages.invalidBody);
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new NotificationsApiError(400, messages.invalidBody);
+  }
+  return value;
+}
+__name(parseEndpoint, "parseEndpoint");
+function parsePushSubscriptionBody(body, messages) {
+  const record = asRecord(body, messages);
+  const keys = asRecord(record.keys, messages);
+  const key = /* @__PURE__ */ __name((value) => {
+    if (typeof value !== "string" || value.length === 0 || value.length > MAX_KEY_CHARS) {
+      throw new NotificationsApiError(400, messages.invalidBody);
+    }
+    return value;
+  }, "key");
+  return {
+    endpoint: parseEndpoint(record.endpoint, messages),
+    keys: { p256dh: key(keys.p256dh), auth: key(keys.auth) }
+  };
+}
+__name(parsePushSubscriptionBody, "parsePushSubscriptionBody");
+function parsePushEndpointBody(body, messages) {
+  return parseEndpoint(asRecord(body, messages).endpoint, messages);
+}
+__name(parsePushEndpointBody, "parsePushEndpointBody");
+function parsePushEndpointQuery(query, messages) {
+  if (query.endpoint === void 0 || query.endpoint === "") return void 0;
+  return parseEndpoint(query.endpoint, messages);
+}
+__name(parsePushEndpointQuery, "parsePushEndpointQuery");
+
+// src/server/transports/drivers.ts
+var NotificationProviderError = class _NotificationProviderError extends Error {
+  static {
+    __name(this, "NotificationProviderError");
+  }
+  status;
+  constructor(vendor, status, detail) {
+    super(`${vendor} rejected the message (${status} ${detail}).`);
+    this.name = "NotificationProviderError";
+    this.status = status;
+    Object.setPrototypeOf(this, _NotificationProviderError.prototype);
+  }
+};
+async function postOrThrow(vendor, fetchImpl, url, init) {
+  const call = fetchImpl ?? globalThis.fetch;
+  const response = await call(url, { method: "POST", ...init });
+  if (!response.ok) {
+    throw new NotificationProviderError(vendor, response.status, await response.text());
+  }
+}
+__name(postOrThrow, "postOrThrow");
+function resolveDriver(channel, declaration, table) {
+  const factory = table[declaration.driver];
+  if (!factory) {
+    throw new Error(
+      `@12-apps/notifications: unknown ${channel} driver "${declaration.driver}". Known drivers: ${Object.keys(table).sort().join(", ")}.`
+    );
+  }
+  return factory(declaration);
+}
+__name(resolveDriver, "resolveDriver");
+function absoluteLink(link, appUrl) {
+  if (!link || !appUrl) return null;
+  try {
+    return new URL(link, appUrl).toString();
+  } catch {
+    return null;
+  }
+}
+__name(absoluteLink, "absoluteLink");
+function phoneChannel(channel, options) {
+  const toE164 = /* @__PURE__ */ __name((recipient) => normalizePhoneE164(recipient.phone, {
+    defaultCountryCode: options.defaultCountryCode
+  }), "toE164");
+  return {
+    channel,
+    supports: /* @__PURE__ */ __name((recipient) => toE164(recipient) !== null, "supports"),
+    format: options.format,
+    async send(message, recipient) {
+      const to = toE164(recipient);
+      if (!to) throw new Error("Recipient has no usable phone number.");
+      await options.send(to, message);
+    }
+  };
+}
+__name(phoneChannel, "phoneChannel");
+
+// src/server/transports/email.ts
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+__name(escapeHtml, "escapeHtml");
+var resendDriver = /* @__PURE__ */ __name((declaration) => ({
+  async send(to, message) {
+    if (!declaration.apiKey || !declaration.from) {
+      throw new Error("The resend email driver needs both `apiKey` and `from`.");
+    }
+    await postOrThrow("Resend", declaration.fetchImpl, "https://api.resend.com/emails", {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${declaration.apiKey}`
+      },
+      body: JSON.stringify({
+        from: declaration.from,
+        to: [to],
+        subject: message.subject,
+        text: message.text,
+        html: message.html
+      })
+    });
+  }
+}), "resendDriver");
+var logEmailDriver = /* @__PURE__ */ __name((declaration) => ({
+  // Deliberately logs NO destination address — a recipient e-mail is PII and
+  // must never reach logs; the subject alone is enough for local debugging.
+  send(_to, message) {
+    declaration.logger?.info(
+      `[notifications:email] log driver suppressed a real send (subject="${message.subject}")`
+    );
+    return Promise.resolve();
+  }
+}), "logEmailDriver");
+var EMAIL_DRIVERS = {
+  resend: resendDriver,
+  log: logEmailDriver
+};
+function formatEmail(content, declaration) {
+  const href = absoluteLink(content.link, declaration.appUrl);
+  const label = declaration.linkLabel ?? "Ver detalhes";
+  return {
+    subject: content.title,
+    text: href ? `${content.body}
+
+${href}` : content.body,
+    html: [
+      `<p><strong>${escapeHtml(content.title)}</strong></p>`,
+      `<p>${escapeHtml(content.body)}</p>`,
+      ...href ? [`<p><a href="${escapeHtml(href)}">${escapeHtml(label)}</a></p>`] : []
+    ].join("\n")
+  };
+}
+__name(formatEmail, "formatEmail");
+function emailTransport(declaration, extraDrivers = {}) {
+  const driver = resolveDriver("EMAIL", declaration, { ...EMAIL_DRIVERS, ...extraDrivers });
+  return {
+    channel: "EMAIL",
+    // Truthiness, not `!== null`: an EMPTY STRING is a very ordinary DB value
+    // for a nullable column, and it used to pass this gate, earn a delivery row
+    // and then fail forever against `send`'s own `!recipient.email` check.
+    supports: /* @__PURE__ */ __name((recipient) => Boolean(recipient.email), "supports"),
+    format: /* @__PURE__ */ __name((content) => formatEmail(content, declaration), "format"),
+    async send(message, recipient) {
+      if (!recipient.email) throw new Error("Recipient has no email address.");
+      await driver.send(recipient.email, message);
+    }
+  };
+}
+__name(emailTransport, "emailTransport");
+
+// src/server/transports/sms.ts
+var MAX_SMS_CHARS = 480;
+var twilioDriver = /* @__PURE__ */ __name((declaration) => ({
+  async send(toE164, message) {
+    const sid = declaration.accountSid;
+    if (!sid || !declaration.authToken || !declaration.from) {
+      throw new Error("The twilio sms driver needs `accountSid`, `authToken` and `from`.");
+    }
+    const auth = Buffer.from(`${sid}:${declaration.authToken}`).toString("base64");
+    await postOrThrow(
+      "Twilio",
+      declaration.fetchImpl,
+      `https://api.twilio.com/2010-04-01/Accounts/${encodeURIComponent(sid)}/Messages.json`,
+      {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          Authorization: `Basic ${auth}`
+        },
+        body: new URLSearchParams({
+          To: toE164,
+          From: declaration.from,
+          Body: message.body
+        }).toString()
+      }
+    );
+  }
+}), "twilioDriver");
+var logSmsDriver = /* @__PURE__ */ __name((declaration) => ({
+  // Deliberately logs NO destination — a phone number is PII and must never
+  // reach logs; the message body alone is enough for local debugging.
+  send(_toE164, message) {
+    declaration.logger?.info(
+      `[notifications:sms] log driver suppressed a real send (body="${message.body}")`
+    );
+    return Promise.resolve();
+  }
+}), "logSmsDriver");
+var SMS_DRIVERS = {
+  twilio: twilioDriver,
+  log: logSmsDriver
+};
+function formatSms(content, declaration) {
+  const parts = [`${content.title}: ${content.body}`];
+  const href = absoluteLink(content.link, declaration.appUrl);
+  if (href) parts.push(href);
+  const body = parts.join(" ");
+  return { body: body.length > MAX_SMS_CHARS ? `${body.slice(0, MAX_SMS_CHARS - 1)}\u2026` : body };
+}
+__name(formatSms, "formatSms");
+function smsTransport(declaration, extraDrivers = {}) {
+  const driver = resolveDriver("SMS", declaration, { ...SMS_DRIVERS, ...extraDrivers });
+  return phoneChannel("SMS", {
+    defaultCountryCode: declaration.defaultCountryCode,
+    format: /* @__PURE__ */ __name((content) => formatSms(content, declaration), "format"),
+    send: /* @__PURE__ */ __name((toE164, message) => driver.send(toE164, message), "send")
+  });
+}
+__name(smsTransport, "smsTransport");
+
+// src/server/transports/web-push.ts
+var vapidDriver = /* @__PURE__ */ __name((declaration) => {
+  const sender = declaration.sender;
+  if (!sender) {
+    throw new Error(
+      "The vapid web-push driver needs a `sender` \u2014 import `vapidPushSender` from @12-apps/notifications/web-push."
+    );
+  }
+  return sender;
+}, "vapidDriver");
+var logWebPushDriver = /* @__PURE__ */ __name((declaration) => (_subscription, payload) => {
+  declaration.logger?.info(
+    `[notifications:web-push] log driver suppressed a real send (${payload.length} bytes)`
+  );
+  return Promise.resolve();
+}, "logWebPushDriver");
+var WEB_PUSH_DRIVERS = {
+  vapid: vapidDriver,
+  log: logWebPushDriver
+};
+var GONE_STATUSES = /* @__PURE__ */ new Set([404, 410]);
+function statusCodeOf(error) {
+  if (error && typeof error === "object" && "statusCode" in error) {
+    const code = error.statusCode;
+    return typeof code === "number" ? code : null;
+  }
+  return null;
+}
+__name(statusCodeOf, "statusCodeOf");
+function formatWebPush(content) {
+  return {
+    title: content.title,
+    body: content.body,
+    link: content.link ?? null,
+    data: content.data ?? {}
+  };
+}
+__name(formatWebPush, "formatWebPush");
+function webPushTransport(declaration, subscriptions, extraDrivers = {}) {
+  const send = resolveDriver("WEB_PUSH", declaration, {
+    ...WEB_PUSH_DRIVERS,
+    ...extraDrivers
+  });
+  return {
+    channel: "WEB_PUSH",
+    supports: /* @__PURE__ */ __name((recipient) => recipient.pushSubscriptionCount > 0, "supports"),
+    format: formatWebPush,
+    async send(message, recipient) {
+      const rows = await subscriptions.list(recipient.userId);
+      if (rows.length === 0) throw new Error("Recipient no longer has push subscriptions.");
+      const payload = JSON.stringify(message);
+      let delivered = 0;
+      let lastError = null;
+      for (const row of rows) {
+        try {
+          await send({ endpoint: row.endpoint, keys: { p256dh: row.p256dh, auth: row.auth } }, payload);
+          delivered += 1;
+        } catch (error) {
+          const status = statusCodeOf(error);
+          if (status !== null && GONE_STATUSES.has(status)) {
+            await subscriptions.prune(row.id).catch(() => {
+            });
+          } else {
+            lastError = error;
+          }
+        }
+      }
+      if (delivered === 0) {
+        throw lastError instanceof Error ? lastError : new Error("No push subscription accepted the payload.");
+      }
+    }
+  };
+}
+__name(webPushTransport, "webPushTransport");
+
+// src/server/transports/whatsapp.ts
+var DEFAULT_GRAPH_API_BASE = "https://graph.facebook.com/v20.0";
+function templatePayload(toDigits, message, declaration) {
+  return {
+    messaging_product: "whatsapp",
+    to: toDigits,
+    type: "template",
+    template: {
+      name: declaration.templateName,
+      language: { code: declaration.templateLanguage },
+      components: [
+        {
+          type: "body",
+          parameters: message.templateParameters.map((text) => ({ type: "text", text }))
+        }
+      ]
+    }
+  };
+}
+__name(templatePayload, "templatePayload");
+function textPayload(toDigits, message) {
+  return {
+    messaging_product: "whatsapp",
+    to: toDigits,
+    type: "text",
+    text: { body: message.text }
+  };
+}
+__name(textPayload, "textPayload");
+var metaDriver = /* @__PURE__ */ __name((declaration) => ({
+  async send(toE164, message) {
+    if (!declaration.accessToken || !declaration.phoneNumberId) {
+      throw new Error("The meta whatsapp driver needs `accessToken` and `phoneNumberId`.");
+    }
+    const toDigits = toE164.replace("+", "");
+    const payload = declaration.templateName ? templatePayload(toDigits, message, declaration) : textPayload(toDigits, message);
+    const base = declaration.graphApiBase ?? DEFAULT_GRAPH_API_BASE;
+    await postOrThrow(
+      "WhatsApp Cloud API",
+      declaration.fetchImpl,
+      `${base}/${encodeURIComponent(declaration.phoneNumberId)}/messages`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${declaration.accessToken}`
+        },
+        body: JSON.stringify(payload)
+      }
+    );
+  }
+}), "metaDriver");
+var logWhatsAppDriver = /* @__PURE__ */ __name((declaration) => ({
+  // Deliberately logs NO destination — a phone number is PII and must never
+  // reach logs; the message text alone is enough for local debugging.
+  send(_toE164, message) {
+    declaration.logger?.info(
+      `[notifications:whatsapp] log driver suppressed a real send (text="${message.text}")`
+    );
+    return Promise.resolve();
+  }
+}), "logWhatsAppDriver");
+var WHATSAPP_DRIVERS = {
+  meta: metaDriver,
+  log: logWhatsAppDriver
+};
+function formatWhatsApp(content, declaration) {
+  const lines = [`*${content.title}*`, "", content.body];
+  const href = absoluteLink(content.link, declaration.appUrl);
+  if (href) lines.push("", href);
+  return { text: lines.join("\n"), templateParameters: [content.title, content.body] };
+}
+__name(formatWhatsApp, "formatWhatsApp");
+function whatsAppTransport(declaration, extraDrivers = {}, logger) {
+  const driver = resolveDriver("WHATSAPP", declaration, {
+    ...WHATSAPP_DRIVERS,
+    ...extraDrivers
+  });
+  if (!declaration.templateName) {
+    logger?.error(
+      "[notifications] WHATSAPP is declared with no `templateName`: only free-form replies inside the 24h customer-service window will be accepted, and every business-initiated send will be rejected by the Graph API."
+    );
+  }
+  return phoneChannel("WHATSAPP", {
+    defaultCountryCode: declaration.defaultCountryCode,
+    format: /* @__PURE__ */ __name((content) => formatWhatsApp(content, declaration), "format"),
+    send: /* @__PURE__ */ __name((toE164, message) => driver.send(toE164, message), "send")
+  });
+}
+__name(whatsAppTransport, "whatsAppTransport");
+
+// src/server/transports/registry.ts
+function build(declaration, subscriptions, extra, logger) {
+  switch (declaration.channel) {
+    case "EMAIL":
+      return emailTransport(declaration, extra.email ?? {});
+    case "SMS":
+      return smsTransport(declaration, extra.sms ?? {});
+    case "WHATSAPP":
+      return whatsAppTransport(
+        declaration,
+        extra.whatsapp ?? {},
+        logger
+      );
+    case "WEB_PUSH":
+      return webPushTransport(
+        declaration,
+        subscriptions,
+        extra.webPush ?? {}
+      );
+  }
+}
+__name(build, "build");
+function createTransportRegistry(declarations, subscriptions, extra = {}, logger) {
+  const transports = /* @__PURE__ */ new Map();
+  let publicKey = null;
+  for (const declaration of declarations) {
+    if (transports.has(declaration.channel)) {
+      throw new Error(
+        `@12-apps/notifications: the ${declaration.channel} channel is declared twice.`
+      );
+    }
+    if (declaration.channel === "WEB_PUSH") publicKey = declaration.publicKey ?? null;
+    transports.set(declaration.channel, build(declaration, subscriptions, extra, logger));
+  }
+  return {
+    get: /* @__PURE__ */ __name((channel) => transports.get(channel) ?? null, "get"),
+    list: /* @__PURE__ */ __name(() => [...transports.values()], "list"),
+    register(transport) {
+      transports.set(transport.channel, transport);
+    },
+    webPushPublicKey: /* @__PURE__ */ __name(() => publicKey, "webPushPublicKey")
+  };
+}
+__name(createTransportRegistry, "createTransportRegistry");
+
+// src/server/by-permission.ts
+function reportOutcome(logger, report) {
+  const { type, clientId, permissions, candidateCount, result } = report;
+  const failed = result.skipped.filter((skip) => skip.reason !== "missing-permission").length;
+  if (failed > 0) {
+    logger.error(
+      `[notifications] ${type}: ${failed} of ${failed + result.notified.length} matching recipient(s) at client ${clientId} could not be reached; ${result.notified.length} delivered`
+    );
+    return;
+  }
+  if (result.notified.length > 0) return;
+  logger.info(
+    `[notifications] ${type}: no recipient at client ${clientId} holds [${permissions.join(", ")}] (${candidateCount} candidate(s) evaluated)`
+  );
+}
+__name(reportOutcome, "reportOutcome");
+async function dispatchTo(deps, clientId, userId, event) {
+  try {
+    await deps.router.notify({ ...event, recipient: { userId, clientId } });
+    return true;
+  } catch (error) {
+    deps.logger.error(
+      `[notifications] ${event.type} dispatch failed for user ${userId} at client ${clientId}:`,
+      error
+    );
+    return false;
+  }
+}
+__name(dispatchTo, "dispatchTo");
+async function heldBy(deps, clientId, userId) {
+  try {
+    const granted = await deps.directory.getPermissions(userId, clientId);
+    return granted instanceof Set ? granted : new Set(granted);
+  } catch (error) {
+    deps.logger.error(
+      `[notifications] audience lookup failed for user ${userId} at client ${clientId}:`,
+      error
+    );
+    return null;
+  }
+}
+__name(heldBy, "heldBy");
+function createNotifyByPermission(deps) {
+  return /* @__PURE__ */ __name(async function notifyByPermission(clientId, permissions, event) {
+    if (permissions.length === 0) {
+      throw new Error(
+        "notifyByPermission(): `permissions` must be non-empty \u2014 an empty list matches every user of the tenant."
+      );
+    }
+    const candidates = [...new Set(await deps.directory.listCandidates(clientId))];
+    const result = { notified: [], skipped: [] };
+    for (const userId of candidates) {
+      const held = await heldBy(deps, clientId, userId);
+      if (!held) {
+        result.skipped.push({ userId, reason: "audience-error" });
+        continue;
+      }
+      if (!permissions.every((permission) => held.has(permission))) {
+        result.skipped.push({ userId, reason: "missing-permission" });
+        continue;
+      }
+      if (await dispatchTo(deps, clientId, userId, event)) result.notified.push(userId);
+      else result.skipped.push({ userId, reason: "dispatch-failed" });
+    }
+    reportOutcome(deps.logger, {
+      type: event.type,
+      clientId,
+      permissions,
+      candidateCount: candidates.length,
+      result
+    });
+    return result;
+  }, "notifyByPermission");
+}
+__name(createNotifyByPermission, "createNotifyByPermission");
+
+// src/server/dispatch.ts
+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) {
+  const contact = await deps.contacts.getContact(userId);
+  if (!contact) return null;
+  return {
+    userId,
+    email: contact.email,
+    phone: contact.phone,
+    pushSubscriptionCount: await deps.pushSubscriptions.count(userId)
+  };
+}
+__name(loadRecipient, "loadRecipient");
+function contentOf(notification) {
+  return {
+    title: notification.title,
+    body: notification.body,
+    ...notification.link !== null ? { link: notification.link } : {},
+    data: notification.data ?? {}
+  };
+}
+__name(contentOf, "contentOf");
+var messageOf = /* @__PURE__ */ __name((error) => error instanceof Error ? error.message : String(error), "messageOf");
+async function settle(deps, client, delivery, error) {
+  const spent = delivery.attempts + 1;
+  const terminal = spent >= deps.maxAttempts;
+  await client.notificationDelivery.update({
+    where: { id: delivery.id },
+    data: {
+      status: terminal ? "DEAD" : "FAILED",
+      error: terminal ? `${messageOf(error)} (gave up after ${spent} attempts)` : messageOf(error)
+    }
+  });
+}
+__name(settle, "settle");
+async function sendClaimed(deps, client, delivery, content, recipient) {
+  const claimed = await client.notificationDelivery.updateMany({
+    where: { id: delivery.id, status: "QUEUED" },
+    data: { status: "SENDING", attempts: { increment: 1 } }
+  });
+  if (claimed.count !== 1) return false;
+  const transport = deps.transports.get(delivery.channel);
+  try {
+    if (!transport) throw new Error(`No transport declared for ${delivery.channel}.`);
+    await transport.send(transport.format(content), recipient);
+    await client.notificationDelivery.update({
+      where: { id: delivery.id },
+      data: { status: "SENT", sentAt: /* @__PURE__ */ new Date(), error: null }
+    });
+  } catch (error) {
+    await settle(deps, client, delivery, error);
+  }
+  return true;
+}
+__name(sendClaimed, "sendClaimed");
+async function abandonUnreachable(deps, client, queued, userId) {
+  deps.logger.error(
+    `[notifications] no contact for user ${userId}: ${queued.length} delivery row(s) marked DEAD`
+  );
+  for (const delivery of queued) {
+    await client.notificationDelivery.update({
+      where: { id: delivery.id },
+      data: { status: "DEAD", error: "The contact directory no longer knows this recipient." }
+    });
+  }
+}
+__name(abandonUnreachable, "abandonUnreachable");
+async function dispatchOne(deps, notificationId) {
+  const client = await deps.db();
+  const notification = await client.notification.findUnique({ where: { id: notificationId } });
+  if (!notification) return 0;
+  const queued = await client.notificationDelivery.findMany({
+    where: { notificationId, status: "QUEUED" }
+  });
+  if (queued.length === 0) return 0;
+  const recipient = await loadRecipient(deps, notification.userId);
+  if (!recipient) {
+    await abandonUnreachable(deps, client, queued, notification.userId);
+    return 0;
+  }
+  const content = contentOf(notification);
+  let sent = 0;
+  for (const delivery of queued) {
+    if (await sendClaimed(deps, client, delivery, content, recipient)) sent += 1;
+  }
+  return sent;
+}
+__name(dispatchOne, "dispatchOne");
+async function requeue(client, row, cutoff) {
+  const moved = await client.notificationDelivery.updateMany({
+    where: { id: row.id, status: row.status, updatedAt: { lt: cutoff } },
+    data: { status: "QUEUED" }
+  });
+  return moved.count === 1;
+}
+__name(requeue, "requeue");
+async function drainPending(deps, olderThanMs, take) {
+  const client = await deps.db();
+  const cutoff = new Date(Date.now() - olderThanMs);
+  const stale = await client.notificationDelivery.findMany({
+    where: { status: { in: RETRYABLE }, updatedAt: { lt: cutoff } },
+    orderBy: { updatedAt: "asc" },
+    take
+  });
+  const notificationIds = /* @__PURE__ */ new Set();
+  for (const row of stale) {
+    if (await requeue(client, row, cutoff)) notificationIds.add(row.notificationId);
+  }
+  let dispatched = 0;
+  for (const id of notificationIds) {
+    try {
+      dispatched += await dispatchOne(deps, id);
+    } catch (error) {
+      deps.logger.error(`[notifications] sweep failed to dispatch ${id}:`, error);
+    }
+  }
+  return { dispatched };
+}
+__name(drainPending, "drainPending");
+
+// src/server/inbox.ts
+var DEFAULT_PAGE = 20;
+var MAX_PAGE = 100;
+async function resolveAnchor(notifications, userId, cursor) {
+  const anchor = await notifications.findUnique({ where: { id: cursor } });
+  if (!anchor || anchor.userId !== userId) return void 0;
+  return { createdAt: anchor.createdAt, id: anchor.id };
+}
+__name(resolveAnchor, "resolveAnchor");
+function pageWhere(userId, filter, anchor) {
+  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 } }
+      ]
+    } : {}
+  };
+}
+__name(pageWhere, "pageWhere");
+function createInboxStore(db) {
+  return {
+    /** The owner's inbox, newest first, keyset-paginated, deleted excluded. */
+    async list(userId, input = {}) {
+      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),
+        // `id` tie-breaks equal timestamps so pages never skip/repeat.
+        orderBy: [{ createdAt: "desc" }, { id: "desc" }],
+        take: limit + 1
+      });
+      const page = rows.slice(0, limit);
+      return {
+        items: page.map(inboxWire),
+        nextCursor: rows.length > limit ? page[page.length - 1]?.id ?? null : null
+      };
+    },
+    /** Unread badge count (non-deleted, unread). */
+    async unreadCount(userId) {
+      const client = await db();
+      return client.notification.count({ where: { userId, deletedAt: null, readAt: null } });
+    },
+    /**
+     * Mark specific notifications read. Only the owner's own, still-unread,
+     * non-deleted rows are touched — foreign or already-read ids are silently
+     * ignored (idempotent). Returns how many rows flipped.
+     */
+    async markRead(userId, ids) {
+      if (ids.length === 0) return 0;
+      const client = await db();
+      const result = await client.notification.updateMany({
+        where: { id: { in: [...ids] }, userId, deletedAt: null, readAt: null },
+        data: { readAt: /* @__PURE__ */ new Date() }
+      });
+      return result.count;
+    },
+    /** Mark every unread notification of the owner read ("mark all"). */
+    async markAllRead(userId) {
+      const client = await db();
+      const result = await client.notification.updateMany({
+        where: { userId, deletedAt: null, readAt: null },
+        data: { readAt: /* @__PURE__ */ new Date() }
+      });
+      return result.count;
+    },
+    /**
+     * Soft-delete notifications (single or bulk): stamps `deletedAt` so the
+     * rows drop out of every list/count forever, while the delivery audit
+     * trail under them survives. Owner-scoped and idempotent like mark-read.
+     */
+    async softDelete(userId, ids) {
+      if (ids.length === 0) return 0;
+      const client = await db();
+      const result = await client.notification.updateMany({
+        where: { id: { in: [...ids] }, userId, deletedAt: null },
+        data: { deletedAt: /* @__PURE__ */ new Date() }
+      });
+      return result.count;
+    }
+  };
+}
+__name(createInboxStore, "createInboxStore");
+
+// src/server/preferences.ts
+function createPreferenceStore(db, taxonomy, channelDefaults = {}) {
+  const defaultRow = { ...DEFAULT_CHANNEL_ROW, ...channelDefaults };
+  const known = new Set(taxonomy.categories);
+  return {
+    async get(userId) {
+      const client = await db();
+      const rows = await client.notificationPreference.findMany({ where: { userId } });
+      const stored = new Map(rows.map((row) => [row.category, row.channels]));
+      return Object.fromEntries(
+        taxonomy.categories.map((category) => [
+          category,
+          // A category with no row, or a row missing a channel key, falls back
+          // to the defaults — so a NEW channel ships without a data migration.
+          mergeStoredRow(stored.get(category), defaultRow)
+        ])
+      );
+    },
+    /**
+     * Only the categories present on `input` are written; within a category,
+     * the toggles are merged over the user's CURRENT effective row (their
+     * stored choices, or the defaults when none) — so a single-toggle save
+     * (how the settings UI writes) never resets the category's other channels
+     * back to their defaults.
+     *
+     * 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.
+     */
+    async save(userId, input) {
+      const client = await db();
+      for (const [category, choices] of Object.entries(input)) {
+        if (!choices || !known.has(category)) continue;
+        const existing = await client.notificationPreference.findUnique({
+          where: { userId_category: { userId, category } }
+        });
+        const current = existing ? mergeStoredRow(existing.channels, defaultRow) : defaultRow;
+        const channels = mergeChoices(current, choices);
+        await client.notificationPreference.upsert({
+          where: { userId_category: { userId, category } },
+          create: { userId, category, channels },
+          update: { channels }
+        });
+      }
+    },
+    async enabledChannels(userId, category) {
+      const client = await db();
+      const row = await client.notificationPreference.findUnique({
+        where: { userId_category: { userId, category } }
+      });
+      return enabledChannelsOf(
+        row ? mergeStoredRow(row.channels, defaultRow) : defaultRow
+      );
+    }
+  };
+}
+__name(createPreferenceStore, "createPreferenceStore");
+
+// src/server/push-subscriptions.ts
+function createPushSubscriptionStore(db, logger) {
+  return {
+    async save(userId, input) {
+      const client = await db();
+      const existing = await client.pushSubscription.findUnique({
+        where: { endpoint: input.endpoint }
+      });
+      if (existing && existing.userId !== userId) {
+        logger?.error(
+          `[notifications] push endpoint re-owned: user ${existing.userId} lost this browser's subscription to user ${userId}`
+        );
+      }
+      await client.pushSubscription.upsert({
+        where: { endpoint: input.endpoint },
+        create: {
+          userId,
+          endpoint: input.endpoint,
+          p256dh: input.keys.p256dh,
+          auth: input.keys.auth,
+          userAgent: input.userAgent ?? null
+        },
+        update: {
+          userId,
+          p256dh: input.keys.p256dh,
+          auth: input.keys.auth,
+          userAgent: input.userAgent ?? null
+        }
+      });
+    },
+    async remove(userId, endpoint) {
+      const client = await db();
+      await client.pushSubscription.deleteMany({ where: { userId, endpoint } });
+    },
+    async count(userId) {
+      const client = await db();
+      return client.pushSubscription.count({ where: { userId } });
+    },
+    async isRegisteredTo(userId, endpoint) {
+      const client = await db();
+      const row = await client.pushSubscription.findUnique({ where: { endpoint } });
+      return row?.userId === userId;
+    },
+    async list(userId) {
+      const client = await db();
+      const rows = await client.pushSubscription.findMany({ where: { userId } });
+      return rows.map((row) => ({
+        id: row.id,
+        endpoint: row.endpoint,
+        p256dh: row.p256dh,
+        auth: row.auth
+      }));
+    },
+    async prune(id) {
+      const client = await db();
+      await client.pushSubscription.delete({ where: { id } });
+    }
+  };
+}
+__name(createPushSubscriptionStore, "createPushSubscriptionStore");
+
+// src/server/routes.ts
+async function channelAvailability(deps, userId) {
+  const contact = await deps.contacts.getContact(userId);
+  const recipient = {
+    userId,
+    email: contact?.email ?? null,
+    phone: contact?.phone ?? null,
+    pushSubscriptionCount: 1
+  };
+  return Object.fromEntries(
+    NOTIFICATION_CHANNELS.map((channel) => [
+      channel,
+      deps.transports.get(channel)?.supports(recipient) ?? false
+    ])
+  );
+}
+__name(channelAvailability, "channelAvailability");
+async function preferencesPayload(deps, userId) {
+  const [preferences, availability] = await Promise.all([
+    deps.preferences.get(userId),
+    channelAvailability(deps, userId)
+  ]);
+  return { preferences, availability, categories: [...deps.categories] };
+}
+__name(preferencesPayload, "preferencesPayload");
+function inboxRoutes(deps) {
+  return [
+    {
+      method: "GET",
+      path: "/notifications",
+      handle: guarded(
+        async ({ actor, query }) => ok(await deps.inbox.list(actor.userId, parseListQuery(query, deps.messages)))
+      )
+    },
+    {
+      method: "GET",
+      path: "/notifications/unread-count",
+      handle: guarded(
+        async ({ actor }) => (
+          // Polled by the SPAs, so it stays a single indexed COUNT.
+          ok({ count: await deps.inbox.unreadCount(actor.userId) })
+        )
+      )
+    },
+    {
+      method: "POST",
+      path: "/notifications/mark-read",
+      handle: guarded(async ({ actor, body }) => {
+        const target = parseMarkReadBody(body, deps.messages);
+        const updated = "all" in target ? await deps.inbox.markAllRead(actor.userId) : await deps.inbox.markRead(actor.userId, target.ids);
+        if (updated > 0) deps.onInboxChanged?.(actor.userId);
+        return ok({ updated });
+      })
+    },
+    {
+      method: "POST",
+      // POST, not DELETE, because the ids travel in a JSON body.
+      path: "/notifications/delete",
+      handle: guarded(async ({ actor, body }) => {
+        const deleted = await deps.inbox.softDelete(
+          actor.userId,
+          parseDeleteBody(body, deps.messages)
+        );
+        if (deleted > 0) deps.onInboxChanged?.(actor.userId);
+        return ok({ deleted });
+      })
+    }
+  ];
+}
+__name(inboxRoutes, "inboxRoutes");
+function preferenceRoutes(deps) {
+  return [
+    {
+      method: "GET",
+      path: "/notification-preferences",
+      handle: guarded(async ({ actor }) => ok(await preferencesPayload(deps, actor.userId)))
+    },
+    {
+      method: "PUT",
+      path: "/notification-preferences",
+      handle: guarded(async ({ actor, body }) => {
+        await deps.preferences.save(actor.userId, parsePreferencesBody(body, deps.messages));
+        return ok(await preferencesPayload(deps, actor.userId));
+      })
+    }
+  ];
+}
+__name(preferenceRoutes, "preferenceRoutes");
+function pushRoutes(deps) {
+  return [
+    {
+      method: "GET",
+      path: "/push-subscriptions",
+      handle: guarded(async ({ actor, query }) => {
+        const endpoint = parsePushEndpointQuery(query, deps.messages);
+        return ok({
+          // null = web push is not configured on this deployment.
+          vapidPublicKey: deps.transports.webPushPublicKey(),
+          count: await deps.pushSubscriptions.count(actor.userId),
+          // Only when asked. `registered` is what lets the settings screen stop
+          // trusting the browser alone: a re-owned or pruned row answers false,
+          // so the screen offers *Ativar* again instead of claiming all is well.
+          ...endpoint !== void 0 ? { registered: await deps.pushSubscriptions.isRegisteredTo(actor.userId, endpoint) } : {}
+        });
+      })
+    },
+    {
+      method: "POST",
+      path: "/push-subscriptions",
+      handle: guarded(async ({ actor, body, headers }) => {
+        const input = parsePushSubscriptionBody(body, deps.messages);
+        const userAgent = headers?.["user-agent"];
+        await deps.pushSubscriptions.save(actor.userId, {
+          ...input,
+          ...userAgent ? { userAgent } : {}
+        });
+        return ok({ count: await deps.pushSubscriptions.count(actor.userId) });
+      })
+    },
+    {
+      method: "DELETE",
+      // The endpoint is a long opaque URL, unusable as a path param.
+      path: "/push-subscriptions",
+      handle: guarded(async ({ actor, body }) => {
+        await deps.pushSubscriptions.remove(
+          actor.userId,
+          parsePushEndpointBody(body, deps.messages)
+        );
+        return ok({ count: await deps.pushSubscriptions.count(actor.userId) });
+      })
+    }
+  ];
+}
+__name(pushRoutes, "pushRoutes");
+function notificationRoutes(deps) {
+  return [...inboxRoutes(deps), ...preferenceRoutes(deps), ...pushRoutes(deps)];
+}
+__name(notificationRoutes, "notificationRoutes");
+
+// src/server/router.ts
+function policyFallback(channels) {
+  const free = new Set(enabledChannelsOf(DEFAULT_CHANNEL_ROW));
+  return channels.filter((channel) => free.has(channel));
+}
+__name(policyFallback, "policyFallback");
+async function applyPolicy(deps, clientId, channels) {
+  if (!deps.channelPolicy || clientId === null || clientId === void 0) return channels;
+  try {
+    return await deps.channelPolicy(clientId, channels);
+  } catch (error) {
+    deps.logger.error(
+      `[notifications] channelPolicy failed for client ${clientId}; degrading to the free channels:`,
+      error
+    );
+    return policyFallback(channels);
+  }
+}
+__name(applyPolicy, "applyPolicy");
+function announce(deps, notification) {
+  if (!deps.onCommitted) return;
+  try {
+    deps.onCommitted(notification);
+  } catch (error) {
+    deps.logger.error(
+      `[notifications] commit listener failed for ${notification.notificationId}:`,
+      error
+    );
+  }
+}
+__name(announce, "announce");
+async function resolveChannels(deps, event, category, recipient) {
+  const enabled = await deps.preferences.enabledChannels(event.recipient.userId, category);
+  const supported = enabled.filter((channel) => {
+    const transport = deps.transports.get(channel);
+    return transport !== null && transport.supports(recipient);
+  });
+  return applyPolicy(deps, event.recipient.clientId, supported);
+}
+__name(resolveChannels, "resolveChannels");
+async function commit(deps, event, category, content, channels) {
+  const client = await deps.db();
+  return client.$transaction(async (tx) => {
+    const created = await tx.notification.create({
+      data: {
+        userId: event.recipient.userId,
+        clientId: event.recipient.clientId ?? null,
+        type: event.type,
+        category,
+        title: content.title,
+        body: content.body,
+        link: content.link ?? null,
+        data: content.data ?? {}
+      }
+    });
+    if (channels.length > 0) {
+      await tx.notificationDelivery.createMany({
+        data: channels.map((channel) => ({ notificationId: created.id, channel })),
+        // Idempotence backstop: the unique (notification, channel) key.
+        skipDuplicates: true
+      });
+    }
+    return created;
+  });
+}
+__name(commit, "commit");
+function createNotificationRouter(deps) {
+  return {
+    dispatchDeliveries: /* @__PURE__ */ __name(async (notificationId) => {
+      await dispatchOne(deps, notificationId);
+    }, "dispatchDeliveries"),
+    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 content = generator.generate(event.payload);
+      const recipient = await loadRecipient(deps, event.recipient.userId);
+      if (!recipient) throw new UnknownNotificationRecipientError(event.recipient.userId);
+      const channels = await resolveChannels(deps, event, generator.category, recipient);
+      const notification = await commit(deps, event, generator.category, content, channels);
+      announce(deps, {
+        notificationId: notification.id,
+        userId: notification.userId,
+        clientId: notification.clientId
+      });
+      if (options.sync) {
+        await dispatchOne(deps, notification.id);
+        return { notificationId: notification.id, channels };
+      }
+      void (deps.scheduleDispatch ? deps.scheduleDispatch(notification.id) : dispatchOne(deps, notification.id)).catch((error) => {
+        deps.logger.error(`[notifications] dispatch failed for ${notification.id}:`, error);
+      });
+      return { notificationId: notification.id, channels };
+    }
+  };
+}
+__name(createNotificationRouter, "createNotificationRouter");
+
+// src/server/create-api-notifications.ts
+function present(entries) {
+  return Object.fromEntries(
+    Object.entries(entries).filter(([, value]) => value !== void 0)
+  );
+}
+__name(present, "present");
+var consoleLogger = {
+  info: /* @__PURE__ */ __name((message, ...meta) => console.info(message, ...meta), "info"),
+  error: /* @__PURE__ */ __name((message, ...meta) => console.error(message, ...meta), "error")
+};
+function createApiNotifications(config) {
+  const messages = messagesOf(config);
+  const taxonomy = taxonomyOf(config);
+  const logger = config.logger ?? consoleLogger;
+  const generators = createGeneratorRegistry(config.generators ?? []);
+  const inbox = createInboxStore(config.db);
+  const preferences = createPreferenceStore(
+    config.db,
+    taxonomy,
+    config.channelDefaults ?? {}
+  );
+  const pushSubscriptions = createPushSubscriptionStore(config.db, logger);
+  const transports = createTransportRegistry(
+    config.transports ?? [],
+    pushSubscriptions,
+    config.drivers ?? {},
+    logger
+  );
+  const router = createNotificationRouter({
+    db: config.db,
+    generators,
+    transports,
+    preferences,
+    pushSubscriptions,
+    contacts: config.contacts,
+    logger,
+    maxAttempts: config.maxDeliveryAttempts ?? DEFAULT_MAX_DELIVERY_ATTEMPTS,
+    // `exactOptionalPropertyTypes` is on, so an absent host seam must be an
+    // ABSENT key rather than an explicit `undefined`.
+    ...present({
+      channelPolicy: config.channelPolicy,
+      scheduleDispatch: config.scheduleDispatch,
+      onCommitted: config.onCommitted
+    })
+  });
+  const audience = config.audience;
+  const notifyByPermission = audience ? createNotifyByPermission({ router, directory: audience, logger }) : () => Promise.reject(
+    new Error(
+      "notifyByPermission() needs an `audience` directory \u2014 pass the host authorization engine to createApiNotifications({ audience })."
+    )
+  );
+  return {
+    routes: notificationRoutes({
+      inbox,
+      preferences,
+      pushSubscriptions,
+      transports,
+      contacts: config.contacts,
+      categories: taxonomy.categories,
+      messages,
+      ...present({ onInboxChanged: config.onInboxChanged })
+    }),
+    notify: router.notify,
+    dispatchDeliveries: router.dispatchDeliveries,
+    drainPending: router.drainPending,
+    notifyByPermission,
+    inbox,
+    preferences,
+    pushSubscriptions,
+    registerGenerator: generators.register,
+    transports,
+    messages
+  };
+}
+__name(createApiNotifications, "createApiNotifications");
+
+export {
+  NotificationsApiError,
+  ok,
+  foldApiError,
+  NotificationProviderError,
+  absoluteLink,
+  EMAIL_DRIVERS,
+  formatEmail,
+  emailTransport,
+  SMS_DRIVERS,
+  formatSms,
+  smsTransport,
+  WEB_PUSH_DRIVERS,
+  formatWebPush,
+  webPushTransport,
+  WHATSAPP_DRIVERS,
+  formatWhatsApp,
+  whatsAppTransport,
+  createTransportRegistry,
+  createApiNotifications
+};
+//# sourceMappingURL=chunk-4PSUZ7X5.js.map