@allbluecn/web-app 0.4.17 → 0.4.19

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

@@ -0,0 +1,281 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+vi.mock('@tanstack/react-start', () => ({
+  createServerFn: (config: any) => {
+    const api: any = {
+      _validator: undefined,
+      validator(schema: any) {
+        this._validator = schema
+        return this
+      },
+      handler(fn: Function) {
+        const wrapped = async (args: any) => {
+          let data = args?.data
+          if (this._validator && data !== undefined) {
+            data = this._validator.parse ? this._validator.parse(data) : data
+          }
+          return fn({ data })
+        }
+        return wrapped
+      },
+    }
+    return api
+  },
+}))
+
+vi.mock('@tanstack/react-start/server', () => ({
+  getRequest: vi.fn(),
+}))
+
+vi.mock('@allbluecn/database', () => ({
+  prisma: {
+    user: { findUnique: vi.fn() },
+    teamInvitation: { findUnique: vi.fn(), update: vi.fn(), updateMany: vi.fn(), deleteMany: vi.fn(), create: vi.fn(), findMany: vi.fn() },
+    teamMembership: { findUnique: vi.fn(), create: vi.fn() },
+    teamJoinRequest: { findUnique: vi.fn(), upsert: vi.fn(), update: vi.fn(), updateMany: vi.fn(), findMany: vi.fn() },
+    $transaction: vi.fn(),
+  },
+}))
+
+vi.mock('@/server/auth-helpers', () => ({
+  requireAuth: vi.fn().mockResolvedValue({ user: { id: 'u2', email: 'b@x.com' } }),
+}))
+
+vi.mock('@/server/audit', () => ({
+  auditLog: vi.fn(),
+}))
+
+vi.mock('@/server/resources', () => ({
+  requireTeamSeats: vi.fn().mockResolvedValue(undefined),
+}))
+
+import { prisma } from '@allbluecn/database'
+import { applyTeamInvitationFn, approveTeamJoinRequestFn, rejectTeamJoinRequestFn, getTeamInvitationByTokenFn, refreshTeamInvitationLinkFn, listTeamInvitationsFn } from '../team'
+
+vi.mocked(prisma.$transaction).mockImplementation(async (fn: any) => fn(prisma))
+
+const LINK_INV = {
+  id: 'inv1', token: 't1', status: 'pending', seatType: 'member', channel: 'link',
+  email: null, expiresAt: new Date(Date.now() + 60000), ownerId: 'owner1',
+  owner: { id: 'owner1', username: 'ow', email: 'owner@x.com' },
+}
+
+describe('applyTeamInvitationFn（link 渠道）', () => {
+  beforeEach(() => vi.clearAllMocks())
+
+  it('链接不存在 → 拒绝', async () => {
+    vi.mocked(prisma.teamInvitation.findUnique).mockResolvedValue(null as never)
+    await expect(applyTeamInvitationFn({ data: { token: 'tX', email: 'a@x.com' } }))
+      .rejects.toMatchObject({ message: expect.stringContaining('不存在') })
+  })
+
+  it('链接过期 → 拒绝', async () => {
+    vi.mocked(prisma.teamInvitation.findUnique).mockResolvedValue({ ...LINK_INV, expiresAt: new Date(Date.now() - 1000) } as never)
+    await expect(applyTeamInvitationFn({ data: { token: 't1', email: 'a@x.com' } }))
+      .rejects.toMatchObject({ message: expect.stringContaining('过期') })
+  })
+
+  it('邮箱是 owner 自己 → 拒绝（不能加入自己的团队）', async () => {
+    vi.mocked(prisma.teamInvitation.findUnique).mockResolvedValue(LINK_INV as never)
+    await expect(applyTeamInvitationFn({ data: { token: 't1', email: 'owner@x.com' } }))
+      .rejects.toMatchObject({ message: expect.stringContaining('自己的团队') })
+  })
+
+  it('邮箱已注册且该账号已加入团队 → 拒绝', async () => {
+    vi.mocked(prisma.teamInvitation.findUnique).mockResolvedValue(LINK_INV as never)
+    vi.mocked(prisma.user.findUnique).mockResolvedValue({ id: 'u9' } as never)
+    vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue({ id: 'm1' } as never)
+    await expect(applyTeamInvitationFn({ data: { token: 't1', email: 'taken@x.com' } }))
+      .rejects.toMatchObject({ message: expect.stringContaining('已加入团队') })
+  })
+
+  it('新邮箱 → 创建 TeamJoinRequest，且不改 TeamInvitation 状态', async () => {
+    vi.mocked(prisma.teamInvitation.findUnique).mockResolvedValue(LINK_INV as never)
+    vi.mocked(prisma.user.findUnique).mockResolvedValue(null as never)
+    vi.mocked(prisma.teamJoinRequest.findUnique).mockResolvedValue(null as never)
+    vi.mocked(prisma.teamJoinRequest.upsert).mockResolvedValue({ id: 'jr1' } as never)
+
+    const res = await applyTeamInvitationFn({ data: { token: 't1', email: 'new@x.com' } })
+
+    expect(res).toMatchObject({ success: true, requiresApproval: true })
+    expect(prisma.teamJoinRequest.upsert).toHaveBeenCalledWith(expect.objectContaining({
+      where: { invitationId_email: { invitationId: 'inv1', email: 'new@x.com' } },
+    }))
+    expect(prisma.teamInvitation.update).not.toHaveBeenCalled()
+  })
+
+  it('同链接同邮箱已有 pending 申请 → 幂等返回，不重复创建', async () => {
+    vi.mocked(prisma.teamInvitation.findUnique).mockResolvedValue(LINK_INV as never)
+    vi.mocked(prisma.user.findUnique).mockResolvedValue(null as never)
+    vi.mocked(prisma.teamJoinRequest.findUnique).mockResolvedValue({ id: 'jr1', status: 'pending' } as never)
+
+    const res = await applyTeamInvitationFn({ data: { token: 't1', email: 'dup@x.com' } })
+
+    expect(res).toMatchObject({ success: true, duplicate: true })
+    expect(prisma.teamJoinRequest.upsert).not.toHaveBeenCalled()
+  })
+})
+
+const PENDING_REQ = {
+  id: 'jr1', invitationId: 'inv1', ownerId: 'u2', userId: 'u9',
+  email: 'new@x.com', status: 'pending', seatType: 'member',
+  invitation: { id: 'inv1', token: 't1', status: 'pending', channel: 'link', expiresAt: new Date(Date.now() + 60000) },
+}
+
+describe('approveTeamJoinRequestFn', () => {
+  beforeEach(() => vi.clearAllMocks())
+
+  it('申请不存在或非本人 → 拒绝', async () => {
+    vi.mocked(prisma.teamJoinRequest.findUnique).mockResolvedValue(null as never)
+    await expect(approveTeamJoinRequestFn({ data: { requestId: 'jrX', seatType: 'member' } }))
+      .rejects.toMatchObject({ message: expect.stringContaining('申请不存在') })
+  })
+
+  it('申请人已加入其他团队 → 友好拒绝', async () => {
+    vi.mocked(prisma.teamJoinRequest.findUnique).mockResolvedValue(PENDING_REQ as never)
+    vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue({ id: 'mX' } as never)
+    await expect(approveTeamJoinRequestFn({ data: { requestId: 'jr1', seatType: 'member' } }))
+      .rejects.toMatchObject({ message: expect.stringContaining('已加入团队') })
+  })
+
+  it('链接已过期 → 拒绝并同步失效申请', async () => {
+    vi.mocked(prisma.teamJoinRequest.findUnique).mockResolvedValue({
+      ...PENDING_REQ, invitation: { ...PENDING_REQ.invitation, expiresAt: new Date(Date.now() - 1000) },
+    } as never)
+    vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue(null as never)
+    await expect(approveTeamJoinRequestFn({ data: { requestId: 'jr1', seatType: 'member' } }))
+      .rejects.toMatchObject({ message: expect.stringContaining('过期') })
+    expect(prisma.teamJoinRequest.update).toHaveBeenCalledWith(expect.objectContaining({
+      data: expect.objectContaining({ status: 'invalidated' }),
+    }))
+  })
+
+  it('批准 → 事务创建 membership 并置 approved', async () => {
+    vi.mocked(prisma.teamJoinRequest.findUnique).mockResolvedValue(PENDING_REQ as never)
+    vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue(null as never)
+    vi.mocked(prisma.teamMembership.create).mockResolvedValue({ id: 'm1' } as never)
+    vi.mocked(prisma.teamJoinRequest.update).mockResolvedValue({ id: 'jr1' } as never)
+
+    const res = await approveTeamJoinRequestFn({ data: { requestId: 'jr1', seatType: 'guest' } })
+
+    expect(res).toEqual({ success: true })
+    expect(prisma.teamMembership.create).toHaveBeenCalledWith(expect.objectContaining({
+      data: { ownerId: 'u2', memberId: 'u9', seatType: 'guest' },
+    }))
+    expect(prisma.teamJoinRequest.update).toHaveBeenCalledWith(expect.objectContaining({
+      where: { id: 'jr1' },
+      data: expect.objectContaining({ status: 'approved', seatType: 'guest' }),
+    }))
+  })
+
+  it('userId 为空时按 email 回查申请人', async () => {
+    vi.mocked(prisma.teamJoinRequest.findUnique).mockResolvedValue({ ...PENDING_REQ, userId: null } as never)
+    vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue(null as never)
+    vi.mocked(prisma.user.findUnique).mockResolvedValue({ id: 'u9' } as never)
+    vi.mocked(prisma.teamMembership.create).mockResolvedValue({ id: 'm1' } as never)
+    vi.mocked(prisma.teamJoinRequest.update).mockResolvedValue({ id: 'jr1' } as never)
+
+    await approveTeamJoinRequestFn({ data: { requestId: 'jr1', seatType: 'member' } })
+
+    expect(prisma.user.findUnique).toHaveBeenCalledWith(expect.objectContaining({ where: { email: 'new@x.com' } }))
+    expect(prisma.teamMembership.create).toHaveBeenCalledWith(expect.objectContaining({
+      data: expect.objectContaining({ memberId: 'u9' }),
+    }))
+  })
+})
+
+describe('rejectTeamJoinRequestFn', () => {
+  beforeEach(() => vi.clearAllMocks())
+
+  it('拒绝 → 置 rejected 并记录 processedAt', async () => {
+    vi.mocked(prisma.teamJoinRequest.findUnique).mockResolvedValue(PENDING_REQ as never)
+    vi.mocked(prisma.teamJoinRequest.update).mockResolvedValue({ id: 'jr1' } as never)
+
+    await rejectTeamJoinRequestFn({ data: { requestId: 'jr1' } })
+
+    expect(prisma.teamJoinRequest.update).toHaveBeenCalledWith(expect.objectContaining({
+      where: { id: 'jr1' },
+      data: expect.objectContaining({ status: 'rejected' }),
+    }))
+  })
+
+  it('非 pending 状态 → 拒绝操作', async () => {
+    vi.mocked(prisma.teamJoinRequest.findUnique).mockResolvedValue({ ...PENDING_REQ, status: 'approved' } as never)
+    await expect(rejectTeamJoinRequestFn({ data: { requestId: 'jr1' } }))
+      .rejects.toMatchObject({ message: expect.stringContaining('待审批') })
+  })
+})
+
+describe('getTeamInvitationByTokenFn（link 渠道）', () => {
+  beforeEach(() => vi.clearAllMocks())
+
+  it('登录用户有 pending 申请 → 返回 myRequestStatus=pending', async () => {
+    vi.mocked(prisma.teamInvitation.findUnique).mockResolvedValue(LINK_INV as never)
+    vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue(null as never)
+    vi.mocked(prisma.user.findUnique).mockResolvedValue({ email: 'new@x.com' } as never)
+    vi.mocked(prisma.teamJoinRequest.findUnique).mockResolvedValue({ status: 'pending' } as never)
+
+    const res = await getTeamInvitationByTokenFn({ data: { token: 't1', userId: 'u9' } })
+
+    expect(res).toMatchObject({ effectiveStatus: 'pending', myRequestStatus: 'pending', alreadyJoined: false })
+  })
+
+  it('链接过期 → 置 expired 并 invalid 关联 pending 申请', async () => {
+    vi.mocked(prisma.teamInvitation.findUnique).mockResolvedValue({ ...LINK_INV, expiresAt: new Date(Date.now() - 1000) } as never)
+    vi.mocked(prisma.teamInvitation.update).mockResolvedValue({} as never)
+    vi.mocked(prisma.teamJoinRequest.updateMany).mockResolvedValue({ count: 2 } as never)
+
+    const res = await getTeamInvitationByTokenFn({ data: { token: 't1', userId: null } })
+
+    expect(res).toMatchObject({ effectiveStatus: 'expired' })
+    expect(prisma.teamJoinRequest.updateMany).toHaveBeenCalledWith(expect.objectContaining({
+      where: { invitationId: 'inv1', status: 'pending' },
+    }))
+  })
+
+  it('登录用户已加入团队 → alreadyJoined=true', async () => {
+    vi.mocked(prisma.teamInvitation.findUnique).mockResolvedValue(LINK_INV as never)
+    vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue({ ownerId: 'other' } as never)
+
+    const res = await getTeamInvitationByTokenFn({ data: { token: 't1', userId: 'u9' } })
+
+    expect(res).toMatchObject({ alreadyJoined: true, joinedOwnerId: 'other', myRequestStatus: null })
+  })
+})
+
+describe('refreshTeamInvitationLinkFn', () => {
+  beforeEach(() => vi.clearAllMocks())
+
+  it('刷新 → 旧链接 pending 申请全部 invalidated，旧链接删除，新链接创建', 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.create).mockResolvedValue({ id: 'inv2', token: 'NEW' } as never)
+
+    const res = await refreshTeamInvitationLinkFn({ data: { expiresInDays: 7 } })
+
+    expect(res).toMatchObject({ success: true })
+    expect(prisma.teamJoinRequest.updateMany).toHaveBeenCalledWith(expect.objectContaining({
+      where: expect.objectContaining({ ownerId: 'u2', status: 'pending' }),
+      data: expect.objectContaining({ status: 'invalidated' }),
+    }))
+    expect(prisma.teamInvitation.deleteMany).toHaveBeenCalledWith(expect.objectContaining({
+      where: { ownerId: 'u2', channel: 'link', status: { in: ['pending', 'pending_approval'] } },
+    }))
+    expect(prisma.teamInvitation.create).toHaveBeenCalled()
+  })
+})
+
+describe('listTeamInvitationsFn', () => {
+  beforeEach(() => vi.clearAllMocks())
+
+  it('返回 { invitations, joinRequests } 结构', async () => {
+    vi.mocked(prisma.teamInvitation.updateMany).mockResolvedValue({ count: 0 } as never)
+    vi.mocked(prisma.teamJoinRequest.updateMany).mockResolvedValue({ count: 0 } as never)
+    vi.mocked(prisma.teamInvitation.findMany).mockResolvedValue([{ id: 'inv1' }] as never)
+    vi.mocked(prisma.teamJoinRequest.findMany).mockResolvedValue([{ id: 'jr1' }] as never)
+
+    const res = await listTeamInvitationsFn()
+
+    expect(res).toEqual({ invitations: [{ id: 'inv1' }], joinRequests: [{ id: 'jr1' }] })
+  })
+})

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

@@ -33,10 +33,21 @@ vi.mock('@allbluecn/database', () => ({
     teamMembership: {
       findUnique: vi.fn(),
       findMany: vi.fn(),
+      findFirst: vi.fn(),
       delete: vi.fn(),
+      create: vi.fn(),
       count: vi.fn(),
     },
-    teamInvitation: { count: vi.fn() },
+    teamInvitation: {
+      create: vi.fn(),
+      findFirst: vi.fn(),
+      findUnique: vi.fn(),
+      updateMany: vi.fn(),
+      findMany: vi.fn(),
+      update: vi.fn(),
+      count: vi.fn(),
+      deleteMany: vi.fn(),
+    },
     projectMember: { deleteMany: vi.fn() },
     $transaction: vi.fn(),
   },
@@ -55,17 +66,13 @@ vi.mock('@/server/audit', () => ({
 }))
 
 import { prisma } from '@allbluecn/database'
-import {
-  listTeamMembersFn,
-  removeTeamMemberFn,
-  leaveTeamFn,
-  listTeamUsersFn,
-} from '../team'
+import { listTeamMembersFn } from '../team'
 
 describe('listTeamMembersFn', () => {
   beforeEach(() => vi.clearAllMocks())
 
-  it('owner 列出成员', async () => {
+  it('已有 membership → 正常列出成员', async () => {
+    vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue({ id: "m1", ownerId: "owner1" } as never)
     vi.mocked(prisma.teamMembership.findMany).mockResolvedValue([
       {
         id: 'm1',
@@ -78,124 +85,38 @@ describe('listTeamMembersFn', () => {
     ] as never)
     const result = await listTeamMembersFn()
     expect(result).toHaveLength(1)
-    expect(result[0].seatType).toBe('member')
+    expect((result as any)[0].seatType).toBe('member')
+    expect((result as any)[0].memberId).toBe('u2')
   })
-})
-
-describe('removeTeamMemberFn', () => {
-  beforeEach(() => vi.clearAllMocks())
-
-  it('owner 移除成员 → 事务删 membership + 级联删 ProjectMember', async () => {
-    vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue({
-      id: 'm1',
-      ownerId: 'owner1',
-      memberId: 'u2',
-      seatType: 'member',
-    } as never)
-    let capturedTx: any
-    vi.mocked(prisma.$transaction).mockImplementation(async (fn: any) => {
-      capturedTx = {
-        teamMembership: { delete: vi.fn().mockResolvedValue({}) },
-        projectMember: { deleteMany: vi.fn().mockResolvedValue({ count: 3 }) },
-      }
-      return fn(capturedTx)
-    })
-    const result = await removeTeamMemberFn({ data: { membershipId: 'm1' } })
-    expect(result.success).toBe(true)
-    expect(capturedTx.projectMember.deleteMany).toHaveBeenCalledWith(
-      expect.objectContaining({ where: { userId: 'u2' } }),
-    )
-  })
-
-  it('非 owner 移除 → 拒绝', async () => {
-    vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue({
-      id: 'm1',
-      ownerId: 'other',
-      memberId: 'u2',
-    } as never)
-    await expect(removeTeamMemberFn({ data: { membershipId: 'm1' } }))
-      .rejects.toMatchObject({ message: expect.stringContaining('权限') })
-  })
-
-  it('成员不存在 → 拒绝', async () => {
-    vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue(null)
-    await expect(removeTeamMemberFn({ data: { membershipId: 'm999' } }))
-      .rejects.toMatchObject({ message: expect.stringContaining('不存在') })
-  })
-})
-
-describe('leaveTeamFn', () => {
-  beforeEach(() => vi.clearAllMocks())
 
-  it('未加入团队 → 拒绝', async () => {
+  it('无 membership → 自动创建 owner 记录', async () => {
     vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue(null)
-    await expect(leaveTeamFn()).rejects.toMatchObject({ message: expect.stringContaining('未加入') })
-  })
-
-  it('已加入团队 → 退出并级联删 ProjectMember', async () => {
-    vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue({
-      id: 'm1',
+    vi.mocked(prisma.teamMembership.create).mockResolvedValue({
+      id: 'm-new',
       ownerId: 'owner1',
       memberId: 'owner1',
+      seatType: 'owner',
+      joinedAt: new Date(),
+      member: { id: 'owner1', username: 'A', email: 'a@x.com', avatarConfig: null, bgShape: null, bgColor: null },
     } as never)
-    let capturedTx: any
-    vi.mocked(prisma.$transaction).mockImplementation(async (fn: any) => {
-      capturedTx = {
-        teamMembership: { delete: vi.fn().mockResolvedValue({}) },
-        projectMember: { deleteMany: vi.fn().mockResolvedValue({ count: 2 }) },
-      }
-      return fn(capturedTx)
-    })
-    const result = await leaveTeamFn()
-    expect(result.success).toBe(true)
-    expect(capturedTx.projectMember.deleteMany).toHaveBeenCalledWith(
-      expect.objectContaining({ where: { userId: 'owner1' } }),
+    const result = await listTeamMembersFn()
+    expect(prisma.teamMembership.create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ ownerId: 'owner1', memberId: 'owner1', seatType: 'owner' }),
+      }),
     )
-  })
-})
-
-describe('listTeamUsersFn', () => {
-  beforeEach(() => vi.clearAllMocks())
-
-  it('返回 owner + active 成员（含 seatType）', async () => {
-    vi.mocked(prisma.user.findUnique).mockResolvedValue({
-      id: 'owner1',
-      username: 'A',
-      email: 'a@x.com',
-      avatarConfig: null,
-      bgShape: null,
-      bgColor: null,
-    } as never)
-    vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue({
-      ownerId: 'owner1',
-      memberId: 'owner1',
-    } as never)
-    vi.mocked(prisma.teamMembership.findMany).mockResolvedValue([
-      { seatType: 'member', member: { id: 'u2', username: 'B', email: 'b@x.com', avatarConfig: null, bgShape: null, bgColor: null } },
-      { seatType: 'guest', member: { id: 'u3', username: 'C', email: 'c@x.com', avatarConfig: null, bgShape: null, bgColor: null } },
-    ] as never)
-    const result = await listTeamUsersFn()
-    expect(result).toHaveLength(3)
+    expect(result).toHaveLength(1)
     expect(result[0].seatType).toBe('owner')
-    expect(result[0].username).toBe('A')
-    expect(result[1].seatType).toBe('member')
-    expect(result[2].seatType).toBe('guest')
+    expect(result[0].memberId).toBe('owner1')
   })
 
-  it('未加入团队的用户 → 返回自身作为 owner', async () => {
-    vi.mocked(prisma.user.findUnique).mockResolvedValue({
-      id: 'owner1',
-      username: 'Solo',
-      email: 'solo@x.com',
-      avatarConfig: null,
-      bgShape: null,
-      bgColor: null,
-    } as never)
-    vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue(null)
-    vi.mocked(prisma.teamMembership.findMany).mockResolvedValue([] as never)
-    const result = await listTeamUsersFn()
-    expect(result).toHaveLength(1)
-    expect(result[0].seatType).toBe('owner')
-    expect(result[0].username).toBe('Solo')
+  it('已有 membership → 不创建，直接查询', async () => {
+    vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue({ id: "m1", ownerId: "owner1" } as never)
+    vi.mocked(prisma.teamMembership.findMany).mockResolvedValue([])
+    await listTeamMembersFn()
+    expect(prisma.teamMembership.create).not.toHaveBeenCalled()
+    expect(prisma.teamMembership.findMany).toHaveBeenCalledWith(
+      expect.objectContaining({ where: { ownerId: 'owner1' } }),
+    )
   })
-})
+})

package/src/{lib/collections/ai/ai-providers-collection.ts → server/serverFns/auth/setup.ts}

@@ -15,17 +15,12 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-import { createCollection } from '@tanstack/db'
-import { queryCollectionOptions } from '@tanstack/query-db-collection'
-import { listAiProvidersFn } from '@/server/serverFns/ai/providers'
-import { getQueryClient } from '@allbluecn/shared/lib/query-client-seam'
+import { createServerFn } from '@tanstack/react-start'
+import { prisma } from '@allbluecn/database'
 
-export const aiProvidersCollection = createCollection(
-  queryCollectionOptions({
-    id: 'ai-providers',
-    queryKey: ['ai-providers'],
-    queryFn: () => listAiProvidersFn(),
-    getKey: (item) => item.meta.providerId,
-    queryClient: getQueryClient(),
+export const checkAdminExistsFn = createServerFn({ method: 'GET' }).handler(async () => {
+  const count = await prisma.user.count({
+    where: { role: 'SUPER_ADMIN' },
   })
-)
+  return { hasAdmin: count > 0 }
+})

package/src/server/serverFns/notifications.ts

@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+import { createServerFn } from '@tanstack/react-start'
+import { getRequest } from '@tanstack/react-start/server'
+import { z } from 'zod'
+import { prisma } from '@allbluecn/database'
+import { requireAuth } from '@/server/auth-helpers'
+import {
+  NOTIFICATION_CATEGORIES,
+  type NotificationCategory,
+  type CategoryPreferences,
+  type NotificationItem,
+  type NotificationListResult,
+} from '@allbluecn/shared'
+import {
+  getOrCreatePreferences,
+  DEFAULT_CATEGORIES,
+} from '@/server/notifications/notification-service'
+
+const PAGE_SIZE = 20
+
+const listSchema = z.object({
+  category: z.enum(NOTIFICATION_CATEGORIES).optional(),
+  cursor: z.string().optional(),
+})
+
+export const listNotificationsFn = createServerFn({ method: 'GET' })
+  .validator(listSchema)
+  .handler(async ({ data }): Promise<NotificationListResult> => {
+    const request = getRequest()
+    const session = await requireAuth(request)
+    const userId = session.user!.id!
+
+    const items = await prisma.notification.findMany({
+      where: {
+        userId,
+        ...(data.category ? { category: data.category } : {}),
+      },
+      orderBy: { createdAt: 'desc' },
+      take: PAGE_SIZE + 1,
+      ...(data.cursor ? { cursor: { id: data.cursor }, skip: 1 } : {}),
+    })
+
+    const hasMore = items.length > PAGE_SIZE
+    const page = (hasMore ? items.slice(0, PAGE_SIZE) : items).map(
+      (n): NotificationItem => ({
+        id: n.id,
+        category: n.category as NotificationCategory,
+        type: n.type,
+        title: n.title,
+        body: n.body,
+        link: n.link,
+        readAt: n.readAt ? n.readAt.toISOString() : null,
+        createdAt: n.createdAt.toISOString(),
+      }),
+    )
+    return { items: page, total: page.length, hasMore }
+  })
+
+const markReadSchema = z.object({ id: z.string().min(1) })
+
+export const markNotificationReadFn = createServerFn({ method: 'POST' })
+  .validator(markReadSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest()
+    const session = await requireAuth(request)
+    const userId = session.user!.id!
+    await prisma.notification.updateMany({
+      where: { id: data.id, userId, readAt: null },
+      data: { readAt: new Date() },
+    })
+    return { success: true }
+  })
+
+export const markAllNotificationsReadFn = 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.updateMany({
+      where: { userId, readAt: null },
+      data: { readAt: new Date() },
+    })
+    return { success: true, count: result.count }
+  })
+
+const deleteSchema = z.object({ id: z.string().min(1) })
+
+export const deleteNotificationFn = createServerFn({ method: 'POST' })
+  .validator(deleteSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest()
+    const session = await requireAuth(request)
+    const userId = session.user!.id!
+    await prisma.notification.deleteMany({ where: { id: data.id, userId } })
+    return { success: true }
+  })
+
+export const getUnreadCountFn = createServerFn({ method: 'GET' })
+  .validator(z.object({}).optional())
+  .handler(async () => {
+    const request = getRequest()
+    const session = await requireAuth(request)
+    const userId = session.user!.id!
+    const count = await prisma.notification.count({
+      where: { userId, readAt: null },
+    })
+    return { count }
+  })
+
+export const getNotificationPreferencesFn = createServerFn({ method: 'GET' })
+  .validator(z.object({}).optional())
+  .handler(async () => {
+    const request = getRequest()
+    const session = await requireAuth(request)
+    return getOrCreatePreferences(session.user!.id!)
+  })
+
+const preferencesSchema = z.object({
+  categories: z.record(z.string(), z.boolean()),
+  dndEnabled: z.boolean(),
+  dndStart: z.string().regex(/^\d{2}:\d{2}$/),
+  dndEnd: z.string().regex(/^\d{2}:\d{2}$/),
+})
+
+export const updateNotificationPreferencesFn = createServerFn({
+  method: 'POST',
+})
+  .validator(preferencesSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest()
+    const session = await requireAuth(request)
+    const userId = session.user!.id!
+    const categories = { ...DEFAULT_CATEGORIES } as CategoryPreferences
+    for (const c of NOTIFICATION_CATEGORIES) {
+      if (typeof data.categories[c] === 'boolean') categories[c] = data.categories[c]
+    }
+    await prisma.notificationPreference.upsert({
+      where: { userId },
+      create: {
+        userId,
+        categories,
+        dndEnabled: data.dndEnabled,
+        dndStart: data.dndStart,
+        dndEnd: data.dndEnd,
+      },
+      update: {
+        categories,
+        dndEnabled: data.dndEnabled,
+        dndStart: data.dndStart,
+        dndEnd: data.dndEnd,
+      },
+    })
+    return { success: true }
+  })