@allbluecn/web-app 0.4.22 → 0.5.0

package/src/server/notifications/__tests__/notification-service.test.ts

@@ -0,0 +1,189 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('@allbluecn/database', () => ({
+  prisma: {
+    notificationPreference: {
+      findUnique: vi.fn(),
+      create: vi.fn(),
+    },
+    notification: {
+      create: vi.fn(),
+      findFirst: vi.fn(),
+      findMany: vi.fn(),
+      count: vi.fn(),
+    },
+  },
+  Prisma: {},
+}))
+
+vi.mock('@/server/notifications/event-bus', () => ({
+  notificationBus: {
+    emit: vi.fn(),
+    subscribe: vi.fn(),
+  },
+}))
+
+import { prisma } from '@allbluecn/database'
+import { notificationBus } from '@/server/notifications/event-bus'
+import { createNotification, deliverDueDigests } from '../notification-service'
+
+const mockedFindUnique = prisma.notificationPreference.findUnique as ReturnType<typeof vi.fn>
+const mockedCreatePref = prisma.notificationPreference.create as ReturnType<typeof vi.fn>
+const mockedNotifCreate = prisma.notification.create as ReturnType<typeof vi.fn>
+const mockedNotifFindFirst = prisma.notification.findFirst as ReturnType<typeof vi.fn>
+const mockedNotifFindMany = prisma.notification.findMany as ReturnType<typeof vi.fn>
+const mockedNotifCount = prisma.notification.count as ReturnType<typeof vi.fn>
+const mockedEmit = notificationBus.emit as ReturnType<typeof vi.fn>
+
+const realtimePrefs = {
+  userId: 'u1',
+  categories: {
+    team: 'realtime',
+    collaboration: 'realtime',
+    system: 'realtime',
+    billing: 'realtime',
+    security: 'realtime',
+  },
+  dndEnabled: false,
+  dndStart: '22:00',
+  dndEnd: '08:00',
+}
+
+const createdNotification = {
+  id: 'n1',
+  category: 'team',
+  type: 'invite',
+  title: 't',
+  body: null,
+  link: null,
+  readAt: null,
+  createdAt: new Date('2026-08-29T10:00:00Z'),
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  mockedFindUnique.mockResolvedValue(realtimePrefs)
+  mockedCreatePref.mockResolvedValue(null)
+  mockedNotifCreate.mockResolvedValue(createdNotification)
+})
+
+describe('createNotification frequency 判定', () => {
+  it('off 类别完全不投递（不入库）', async () => {
+    mockedFindUnique.mockResolvedValue({
+      ...realtimePrefs,
+      categories: { ...realtimePrefs.categories, team: 'off' },
+    })
+    await createNotification({ userId: 'u1', category: 'team', type: 'invite', title: 't' })
+    expect(mockedNotifCreate).not.toHaveBeenCalled()
+    expect(mockedEmit).not.toHaveBeenCalled()
+  })
+
+  it('realtime 类别入库并实时推送', async () => {
+    await createNotification({ userId: 'u1', category: 'team', type: 'invite', title: 't' })
+    expect(mockedNotifCreate).toHaveBeenCalledTimes(1)
+    expect(mockedEmit).toHaveBeenCalledTimes(1)
+    expect(mockedEmit).toHaveBeenCalledWith('u1', {
+      kind: 'notification',
+      notification: expect.objectContaining({ id: 'n1' }),
+    })
+  })
+
+  it('digest-daily 类别仅入库不推送', async () => {
+    mockedFindUnique.mockResolvedValue({
+      ...realtimePrefs,
+      categories: { ...realtimePrefs.categories, team: 'digest-daily' },
+    })
+    await createNotification({ userId: 'u1', category: 'team', type: 'invite', title: 't' })
+    expect(mockedNotifCreate).toHaveBeenCalledTimes(1)
+    expect(mockedEmit).not.toHaveBeenCalled()
+  })
+
+  it('force 绕过 off 判定并强制推送', async () => {
+    mockedFindUnique.mockResolvedValue({
+      ...realtimePrefs,
+      categories: { ...realtimePrefs.categories, team: 'off' },
+    })
+    await createNotification({ userId: 'u1', category: 'team', type: 'digest.daily', title: 't', force: true })
+    expect(mockedNotifCreate).toHaveBeenCalledTimes(1)
+    expect(mockedEmit).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('deliverDueDigests', () => {
+  const digestPrefs = {
+    userId: 'u1',
+    categories: {
+      team: 'digest-daily',
+      collaboration: 'realtime',
+      system: 'off',
+      billing: 'digest-weekly',
+      security: 'realtime',
+    },
+    dndEnabled: false,
+    dndStart: '22:00',
+    dndEnd: '08:00',
+  }
+
+  it('到期且有积压时生成摘要并实时推送', async () => {
+    mockedFindUnique.mockResolvedValue(digestPrefs)
+    mockedNotifFindFirst.mockResolvedValue({
+      createdAt: new Date(Date.now() - 25 * 60 * 60 * 1000),
+    })
+    mockedNotifCount.mockResolvedValue(4)
+    mockedNotifFindMany.mockResolvedValue([{ title: 'a' }, { title: 'b' }, { title: 'c' }])
+    mockedNotifCreate.mockResolvedValue({ ...createdNotification, type: 'digest.daily' })
+
+    await deliverDueDigests('u1')
+
+    // team(daily) 到期生成摘要并推送；billing(weekly) 距水位线 25h < 7d 未到期
+    expect(mockedEmit).toHaveBeenCalledTimes(1)
+    const teamDigest = mockedNotifCreate.mock.calls.find(
+      (c) => c[0]?.data?.type === 'digest.daily'
+    )
+    expect(teamDigest).toBeDefined()
+    expect(teamDigest![0].data.title).toContain('今日团队协作有 4 条新通知')
+    expect(teamDigest![0].data.body).toContain('等 4 条通知')
+  })
+
+  it('未到期（24h 内已有摘要）跳过', async () => {
+    mockedFindUnique.mockResolvedValue(digestPrefs)
+    mockedNotifFindFirst.mockResolvedValue({ createdAt: new Date(Date.now() - 2 * 60 * 60 * 1000) })
+
+    await deliverDueDigests('u1')
+
+    expect(mockedNotifCount).not.toHaveBeenCalled()
+    expect(mockedNotifCreate).not.toHaveBeenCalled()
+  })
+
+  it('到期但无积压通知跳过', async () => {
+    mockedFindUnique.mockResolvedValue(digestPrefs)
+    mockedNotifFindFirst.mockResolvedValue({
+      createdAt: new Date(Date.now() - 25 * 60 * 60 * 1000),
+    })
+    mockedNotifCount.mockResolvedValue(0)
+
+    await deliverDueDigests('u1')
+
+    expect(mockedNotifCreate).not.toHaveBeenCalled()
+    expect(mockedEmit).not.toHaveBeenCalled()
+  })
+
+  it('weekly 频率 7 天内已有摘要跳过', async () => {
+    mockedFindUnique.mockResolvedValue({
+      ...digestPrefs,
+      categories: { ...digestPrefs.categories, billing: 'digest-weekly', team: 'realtime' },
+    })
+    mockedNotifFindFirst.mockResolvedValue({ createdAt: new Date(Date.now() - 6 * 24 * 60 * 60 * 1000) })
+
+    await deliverDueDigests('u1')
+
+    expect(mockedNotifCount).not.toHaveBeenCalled()
+    expect(mockedNotifCreate).not.toHaveBeenCalled()
+  })
+
+  it('无 digest 类别直接返回', async () => {
+    await deliverDueDigests('u1')
+    expect(mockedNotifFindFirst).not.toHaveBeenCalled()
+  })
+})

package/src/server/notifications/notification-service.ts

@@ -1,15 +1,19 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 import { prisma } from '@allbluecn/database'
 import type {
-  CategoryPreferences,
+  CategoryFrequencies,
   NotificationCategory,
   NotificationItem,
   NotificationPreferences,
 } from '@allbluecn/shared'
-import { isInDndWindow, DEFAULT_CATEGORIES } from '@allbluecn/shared'
+import {
+  isInDndWindow,
+  normalizeCategoryFrequencies,
+  DEFAULT_CATEGORIES,
+} from '@allbluecn/shared'
 import { notificationBus } from './event-bus'
 
-export { DEFAULT_CATEGORIES, isInDndWindow } from '@allbluecn/shared'
+export { DEFAULT_CATEGORIES, isInDndWindow, normalizeCategoryFrequencies } from '@allbluecn/shared'
 
 export interface CreateNotificationInput {
   userId: string
@@ -18,13 +22,36 @@ export interface CreateNotificationInput {
   title: string
   body?: string
   link?: string
+  /** 绕过 frequency 判定并强制实时推送（仅 digest 摘要生成使用） */
+  force?: boolean
+}
+
+/** 服务端直出的类别中文名（与 zh locale tabs 保持一致） */
+const CATEGORY_LABELS: Record<NotificationCategory, string> = {
+  team: '团队协作',
+  collaboration: '内容协作',
+  system: '系统公告',
+  billing: '账单订阅',
+  security: '安全告警',
+}
+
+const DIGEST_TYPE: Record<'digest-daily' | 'digest-weekly', string> = {
+  'digest-daily': 'digest.daily',
+  'digest-weekly': 'digest.weekly',
+}
+
+const DIGEST_MIN_INTERVAL_MS: Record<'digest-daily' | 'digest-weekly', number> = {
+  'digest-daily': 24 * 60 * 60 * 1000,
+  'digest-weekly': 7 * 24 * 60 * 60 * 1000,
 }
 
+const DIGEST_SUMMARY_ITEMS = 3
+
 export async function getOrCreatePreferences(userId: string): Promise<NotificationPreferences> {
   const existing = await prisma.notificationPreference.findUnique({ where: { userId } })
   if (existing) {
     return {
-      categories: { ...DEFAULT_CATEGORIES, ...(existing.categories as object) } as CategoryPreferences,
+      categories: normalizeCategoryFrequencies(existing.categories),
       dndEnabled: existing.dndEnabled,
       dndStart: existing.dndStart,
       dndEnd: existing.dndEnd,
@@ -52,35 +79,118 @@ export async function getOrCreatePreferences(userId: string): Promise<Notificati
   return defaults
 }
 
-/** fire-and-forget：任何失败只记日志不抛出，不阻断业务主流程 */
+async function insertNotification(
+  input: CreateNotificationInput
+): Promise<NotificationItem | null> {
+  const created = await prisma.notification.create({
+    data: {
+      userId: input.userId,
+      category: input.category,
+      type: input.type,
+      title: input.title,
+      body: input.body,
+      link: input.link,
+    },
+  })
+  return {
+    id: created.id,
+    category: created.category as NotificationCategory,
+    type: created.type,
+    title: created.title,
+    body: created.body,
+    link: created.link,
+    readAt: created.readAt ? created.readAt.toISOString() : null,
+    createdAt: created.createdAt.toISOString(),
+  }
+}
+
+/**
+ * fire-and-forget：任何失败只记日志不抛出，不阻断业务主流程。
+ * frequency 判定：off 不投递；realtime 入库 + 实时推送；digest-* 仅入库（由 deliverDueDigests 汇总推送）。
+ */
 export async function createNotification(input: CreateNotificationInput): Promise<void> {
   try {
     const prefs = await getOrCreatePreferences(input.userId)
-    if (!prefs.categories[input.category]) return
+    const frequency = prefs.categories[input.category]
+    if (!input.force && frequency === 'off') return
 
-    const created = await prisma.notification.create({
-      data: {
-        userId: input.userId,
-        category: input.category,
-        type: input.type,
-        title: input.title,
-        body: input.body,
-        link: input.link,
-      },
-    })
+    const item = await insertNotification(input)
+    if (!item) return
 
-    const item: NotificationItem = {
-      id: created.id,
-      category: created.category as NotificationCategory,
-      type: created.type,
-      title: created.title,
-      body: created.body,
-      link: created.link,
-      readAt: created.readAt ? created.readAt.toISOString() : null,
-      createdAt: created.createdAt.toISOString(),
+    if (input.force || frequency === 'realtime') {
+      notificationBus.emit(input.userId, { kind: 'notification', notification: item })
     }
-    notificationBus.emit(input.userId, { kind: 'notification', notification: item })
   } catch (e) {
     console.error('[notifications] create failed:', e instanceof Error ? e.message : 'unknown')
   }
-}
+}
+
+function formatDigestBody(titles: string[], total: number): string {
+  const lines = titles.slice(0, DIGEST_SUMMARY_ITEMS).map((t) => `· ${t}`)
+  if (total > DIGEST_SUMMARY_ITEMS) {
+    lines.push(`等 ${total} 条通知`)
+  }
+  return lines.join('\n')
+}
+
+/**
+ * 检查并投递到期的 digest（摘要）通知。在用户建立 SSE 连接时调用（fire-and-forget）：
+ * 以同类别最近一条同频率摘要的 createdAt 为水位线，积压通知数 > 0 且距上次摘要超过
+ * 频率周期时，按类别生成一条摘要通知并实时推送。
+ */
+export async function deliverDueDigests(userId: string): Promise<void> {
+  try {
+    const prefs = await getOrCreatePreferences(userId)
+    const digestCats = (Object.keys(prefs.categories) as NotificationCategory[]).filter(
+      (c) => prefs.categories[c] === 'digest-daily' || prefs.categories[c] === 'digest-weekly'
+    )
+    for (const category of digestCats) {
+      const frequency = prefs.categories[category] as 'digest-daily' | 'digest-weekly'
+      const type = DIGEST_TYPE[frequency]
+
+      const lastDigest = await prisma.notification.findFirst({
+        where: { userId, category, type },
+        orderBy: { createdAt: 'desc' },
+        select: { createdAt: true },
+      })
+      if (lastDigest && Date.now() - lastDigest.createdAt.getTime() < DIGEST_MIN_INTERVAL_MS[frequency]) {
+        continue
+      }
+
+      const since = lastDigest?.createdAt ?? new Date(0)
+      const pendingCount = await prisma.notification.count({
+        where: {
+          userId,
+          category,
+          type: { not: { startsWith: 'digest.' } },
+          createdAt: { gt: since },
+        },
+      })
+      if (pendingCount === 0) continue
+
+      const pending = await prisma.notification.findMany({
+        where: {
+          userId,
+          category,
+          type: { not: { startsWith: 'digest.' } },
+          createdAt: { gt: since },
+        },
+        orderBy: { createdAt: 'desc' },
+        select: { title: true },
+        take: DIGEST_SUMMARY_ITEMS,
+      })
+
+      const periodLabel = frequency === 'digest-daily' ? '今日' : '本周'
+      await createNotification({
+        userId,
+        category,
+        type,
+        title: `${periodLabel}${CATEGORY_LABELS[category]}有 ${pendingCount} 条新通知`,
+        body: formatDigestBody(pending.map((n) => n.title), pendingCount),
+        force: true,
+      })
+    }
+  } catch (e) {
+    console.error('[notifications] digest failed:', e instanceof Error ? e.message : 'unknown')
+  }
+}

package/src/server/serverFns/__tests__/team-invitation.test.ts

@@ -40,8 +40,9 @@ vi.mock('@allbluecn/database', () => ({
       update: vi.fn(),
       count: vi.fn(),
       deleteMany: vi.fn(),
+      delete: vi.fn(),
     },
-    teamJoinRequest: { updateMany: vi.fn(), findMany: vi.fn() },
+    teamJoinRequest: { updateMany: vi.fn(), findMany: vi.fn(), findUnique: vi.fn(), delete: vi.fn() },
     $transaction: vi.fn(),
   },
 }))
@@ -68,16 +69,18 @@ import {
   refreshTeamInvitationLinkFn,
   listTeamInvitationsFn,
   clearExpiredInvitationsFn,
+  deleteTeamInvitationFn,
+  deleteTeamJoinRequestFn,
 } from '../team'
 
 describe('refreshTeamInvitationLinkFn', () => {
   beforeEach(() => vi.clearAllMocks())
 
-  it('生成新链接，删除旧链接', async () => {
+  it('生成新链接，旧链接置 revoked 保留申请历史', async () => {
     vi.mocked(prisma.$transaction).mockImplementation(async (fn: any) => {
       const tx = {
         teamInvitation: {
-          deleteMany: vi.fn().mockResolvedValue({}),
+          updateMany: vi.fn().mockResolvedValue({}),
           create: vi.fn().mockResolvedValue({ id: 'inv-new', token: 'abc123' }),
         },
         teamJoinRequest: {
@@ -97,7 +100,7 @@ describe('refreshTeamInvitationLinkFn', () => {
     vi.mocked(prisma.$transaction).mockImplementation(async (fn: any) => {
       const tx = {
         teamInvitation: {
-          deleteMany: vi.fn().mockResolvedValue({}),
+          updateMany: vi.fn().mockResolvedValue({}),
           create: vi.fn().mockResolvedValue({ id: 'inv-new', token: 'xyz' }),
         },
         teamJoinRequest: {
@@ -114,7 +117,7 @@ describe('refreshTeamInvitationLinkFn', () => {
     vi.mocked(prisma.$transaction).mockImplementation(async (fn: any) => {
       const tx = {
         teamInvitation: {
-          deleteMany: vi.fn().mockResolvedValue({}),
+          updateMany: vi.fn().mockResolvedValue({}),
           create: vi.fn().mockResolvedValue({ id: 'inv-new', token: 'tok' }),
         },
         teamJoinRequest: {
@@ -199,15 +202,78 @@ describe('createTeamInvitationFn link 邀请', () => {
 describe('clearExpiredInvitationsFn', () => {
   beforeEach(() => vi.clearAllMocks())
 
-  it('清除所有过期邀请', async () => {
+  it('清除所有过期邮箱邀请（链接行保留以维持申请历史）', async () => {
     vi.mocked(prisma.teamInvitation.deleteMany).mockResolvedValue({ count: 2 } as never)
     const result = await clearExpiredInvitationsFn({ data: {} })
     expect(result.success).toBe(true)
     expect(result.count).toBe(2)
     expect(prisma.teamInvitation.deleteMany).toHaveBeenCalledWith(
       expect.objectContaining({
-        where: expect.objectContaining({ status: 'expired' }),
+        where: expect.objectContaining({ status: 'expired', channel: 'email' }),
       }),
     )
   })
 })
+
+describe('deleteTeamInvitationFn', () => {
+  beforeEach(() => vi.clearAllMocks())
+
+  it('删除自己的 email 邀请记录', async () => {
+    vi.mocked(prisma.teamInvitation.findUnique).mockResolvedValue({
+      id: 'inv1', ownerId: 'owner1', channel: 'email', email: 'x@y.com',
+    } as never)
+    vi.mocked(prisma.teamInvitation.delete).mockResolvedValue({} as never)
+
+    const result = await deleteTeamInvitationFn({ data: { invitationId: 'inv1' } })
+
+    expect(result.success).toBe(true)
+    expect(prisma.teamInvitation.delete).toHaveBeenCalledWith({ where: { id: 'inv1' } })
+  })
+
+  it('link 渠道邀请禁止删除（防级联删申请）', async () => {
+    vi.mocked(prisma.teamInvitation.findUnique).mockResolvedValue({
+      id: 'inv2', ownerId: 'owner1', channel: 'link',
+    } as never)
+
+    await expect(
+      deleteTeamInvitationFn({ data: { invitationId: 'inv2' } }),
+    ).rejects.toMatchObject({ message: expect.stringContaining('不可删除') })
+    expect(prisma.teamInvitation.delete).not.toHaveBeenCalled()
+  })
+
+  it('他人邀请不可删除', async () => {
+    vi.mocked(prisma.teamInvitation.findUnique).mockResolvedValue({
+      id: 'inv3', ownerId: 'someone-else', channel: 'email',
+    } as never)
+
+    await expect(
+      deleteTeamInvitationFn({ data: { invitationId: 'inv3' } }),
+    ).rejects.toMatchObject({ message: '邀请不存在' })
+    expect(prisma.teamInvitation.delete).not.toHaveBeenCalled()
+  })
+})
+
+describe('deleteTeamJoinRequestFn', () => {
+  beforeEach(() => vi.clearAllMocks())
+
+  it('删除自己的申请记录', async () => {
+    vi.mocked(prisma.teamJoinRequest.findUnique).mockResolvedValue({
+      id: 'jr1', ownerId: 'owner1', email: 'a@b.com', status: 'rejected',
+    } as never)
+    vi.mocked(prisma.teamJoinRequest.delete).mockResolvedValue({} as never)
+
+    const result = await deleteTeamJoinRequestFn({ data: { requestId: 'jr1' } })
+
+    expect(result.success).toBe(true)
+    expect(prisma.teamJoinRequest.delete).toHaveBeenCalledWith({ where: { id: 'jr1' } })
+  })
+
+  it('他人申请不可删除', async () => {
+    vi.mocked(prisma.teamJoinRequest.findUnique).mockResolvedValue(null as never)
+
+    await expect(
+      deleteTeamJoinRequestFn({ data: { requestId: 'jrX' } }),
+    ).rejects.toMatchObject({ message: '申请不存在' })
+    expect(prisma.teamJoinRequest.delete).not.toHaveBeenCalled()
+  })
+})

package/src/server/serverFns/__tests__/team-join-request.test.ts

@@ -246,9 +246,9 @@ describe('getTeamInvitationByTokenFn（link 渠道）', () => {
 describe('refreshTeamInvitationLinkFn', () => {
   beforeEach(() => vi.clearAllMocks())
 
-  it('刷新 → 旧链接 pending 申请全部 invalidated，旧链接删除，新链接创建', async () => {
+  it('刷新 → 旧链接 pending 申请全部 invalidated，旧链接置 revoked 保留历史，新链接创建', async () => {
     vi.mocked(prisma.teamJoinRequest.updateMany).mockResolvedValue({ count: 1 } as never)
-    vi.mocked(prisma.teamInvitation.deleteMany).mockResolvedValue({ count: 1 } as never)
+    vi.mocked(prisma.teamInvitation.updateMany).mockResolvedValue({ count: 1 } as never)
     vi.mocked(prisma.teamInvitation.create).mockResolvedValue({ id: 'inv2', token: 'NEW' } as never)
 
     const res = await refreshTeamInvitationLinkFn({ data: { expiresInDays: 7 } })
@@ -258,9 +258,11 @@ describe('refreshTeamInvitationLinkFn', () => {
       where: expect.objectContaining({ ownerId: 'u2', status: 'pending' }),
       data: expect.objectContaining({ status: 'invalidated' }),
     }))
-    expect(prisma.teamInvitation.deleteMany).toHaveBeenCalledWith(expect.objectContaining({
+    expect(prisma.teamInvitation.updateMany).toHaveBeenCalledWith(expect.objectContaining({
       where: { ownerId: 'u2', channel: 'link', status: { in: ['pending', 'pending_approval'] } },
+      data: { status: 'revoked' },
     }))
+    expect(prisma.teamInvitation.deleteMany).not.toHaveBeenCalled()
     expect(prisma.teamInvitation.create).toHaveBeenCalled()
   })
 })

package/src/server/serverFns/locale.ts

@@ -1,8 +1,20 @@
 import { createServerFn } from '@tanstack/react-start'
-import { getRequest } from '@tanstack/react-start/server'
+import { getRequest, setCookie } from '@tanstack/react-start/server'
 import { detectLocale } from '@/lib/i18n/detect'
 
+/**
+ * 检测用户语言并固化为 lng cookie：
+ * 首次访问（无 cookie）时，SSR 依据 querystring/accept-language 检测出的语言
+ * 写入 cookie，保证客户端 i18n（仅读 querystring/cookie）与服务端同源一致，
+ * 避免 hydration mismatch。
+ */
 export const getLocaleFn = createServerFn({ method: 'GET' }).handler(async () => {
   const request = getRequest()
-  return detectLocale(request, null)
-})
+  const locale = detectLocale(request, null)
+  setCookie('lng', locale, {
+    path: '/',
+    maxAge: 60 * 60 * 24 * 365,
+    sameSite: 'lax',
+  })
+  return locale
+})

package/src/server/serverFns/notifications.ts

@@ -6,10 +6,11 @@ import { prisma } from '@allbluecn/database'
 import { requireAuth } from '@/server/auth-helpers'
 import {
   NOTIFICATION_CATEGORIES,
+  NOTIFICATION_FREQUENCIES,
   type NotificationCategory,
-  type CategoryPreferences,
   type NotificationItem,
   type NotificationListResult,
+  type CategoryFrequencies,
 } from '@allbluecn/shared'
 import {
   getOrCreatePreferences,
@@ -96,6 +97,16 @@ export const deleteNotificationFn = createServerFn({ method: 'POST' })
     return { success: true }
   })
 
+export const clearNotificationsFn = createServerFn({ method: 'POST' })
+  .validator(z.object({}).optional())
+  .handler(async () => {
+    const request = getRequest()
+    const session = await requireAuth(request)
+    const userId = session.user!.id!
+    const result = await prisma.notification.deleteMany({ where: { userId } })
+    return { success: true, count: result.count }
+  })
+
 export const getUnreadCountFn = createServerFn({ method: 'GET' })
   .validator(z.object({}).optional())
   .handler(async () => {
@@ -117,7 +128,7 @@ export const getNotificationPreferencesFn = createServerFn({ method: 'GET' })
   })
 
 const preferencesSchema = z.object({
-  categories: z.record(z.string(), z.boolean()),
+  categories: z.record(z.string(), z.enum(NOTIFICATION_FREQUENCIES)),
   dndEnabled: z.boolean(),
   dndStart: z.string().regex(/^\d{2}:\d{2}$/),
   dndEnd: z.string().regex(/^\d{2}:\d{2}$/),
@@ -131,9 +142,12 @@ export const updateNotificationPreferencesFn = createServerFn({
     const request = getRequest()
     const session = await requireAuth(request)
     const userId = session.user!.id!
-    const categories = { ...DEFAULT_CATEGORIES } as CategoryPreferences
+    const categories = { ...DEFAULT_CATEGORIES } as CategoryFrequencies
     for (const c of NOTIFICATION_CATEGORIES) {
-      if (typeof data.categories[c] === 'boolean') categories[c] = data.categories[c]
+      const v = data.categories[c]
+      if ((NOTIFICATION_FREQUENCIES as readonly string[]).includes(v)) {
+        categories[c] = v as CategoryFrequencies[NotificationCategory]
+      }
     }
     await prisma.notificationPreference.upsert({
       where: { userId },