@allbluecn/web-app 0.4.17 → 0.4.18

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

@@ -39,7 +39,10 @@ vi.mock('@allbluecn/database', () => ({
       findMany: vi.fn(),
       update: vi.fn(),
       count: vi.fn(),
+      deleteMany: vi.fn(),
     },
+    teamJoinRequest: { updateMany: vi.fn(), findMany: vi.fn() },
+    $transaction: vi.fn(),
   },
 }))
 
@@ -60,84 +63,151 @@ vi.mock('@/server/email/sender', () => ({
 }))
 
 import { prisma } from '@allbluecn/database'
-import { createTeamInvitationFn } from '../team'
+import {
+  createTeamInvitationFn,
+  refreshTeamInvitationLinkFn,
+  listTeamInvitationsFn,
+  clearExpiredInvitationsFn,
+} from '../team'
 
-describe('createTeamInvitationFn 互斥校验', () => {
+describe('refreshTeamInvitationLinkFn', () => {
   beforeEach(() => vi.clearAllMocks())
 
-  it('邀请自己 → 拒绝', async () => {
-    ;(prisma.user.findUnique as any).mockImplementation(async (opts: any) => {
-      if (opts.where.id === 'owner1') return { id: 'owner1', email: 'a@x.com' }
-      return null
+  it('生成新链接，删除旧链接', async () => {
+    vi.mocked(prisma.$transaction).mockImplementation(async (fn: any) => {
+      const tx = {
+        teamInvitation: {
+          deleteMany: vi.fn().mockResolvedValue({}),
+          create: vi.fn().mockResolvedValue({ id: 'inv-new', token: 'abc123' }),
+        },
+        teamJoinRequest: {
+          updateMany: vi.fn().mockResolvedValue({}),
+        },
+      }
+      return fn(tx)
     })
-    await expect(
-      createTeamInvitationFn({ data: { email: 'a@x.com', seatType: 'member', channel: 'email' } }),
-    ).rejects.toMatchObject({ message: expect.stringContaining('自己') })
+    const result = await refreshTeamInvitationLinkFn({ data: {} })
+    expect(result.success).toBe(true)
+    expect(result.invitationId).toBe('inv-new')
+    expect(result.token).toBeTruthy()
+    expect(result.token.length).toBeGreaterThan(0)
   })
 
-  it('目标已在任何团队 → 拒绝', async () => {
-    ;(prisma.user.findUnique as any).mockImplementation(async (opts: any) => {
-      if (opts.where.id === 'owner1') return { id: 'owner1', email: 'a@x.com' }
-      if (opts.where.email === 'b@x.com') return { id: 'u2', email: 'b@x.com' }
-      return null
+  it('支持自定义有效期', async () => {
+    vi.mocked(prisma.$transaction).mockImplementation(async (fn: any) => {
+      const tx = {
+        teamInvitation: {
+          deleteMany: vi.fn().mockResolvedValue({}),
+          create: vi.fn().mockResolvedValue({ id: 'inv-new', token: 'xyz' }),
+        },
+        teamJoinRequest: {
+          updateMany: vi.fn().mockResolvedValue({}),
+        },
+      }
+      return fn(tx)
     })
-    vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue({
-      ownerId: 'other',
-    } as never)
-    await expect(
-      createTeamInvitationFn({ data: { email: 'b@x.com', seatType: 'member', channel: 'email' } }),
-    ).rejects.toMatchObject({ message: expect.stringContaining('已加入') })
+    const result = await refreshTeamInvitationLinkFn({ data: { expiresInDays: 14 } })
+    expect(result.success).toBe(true)
   })
 
-  it('邮箱已有 pending 邀请 → 拒绝', async () => {
-    ;(prisma.user.findUnique as any).mockImplementation(async (opts: any) => {
-      if (opts.where.id === 'owner1') return { id: 'owner1', email: 'a@x.com' }
-      if (opts.where.email === 'b@x.com') return { id: 'u2', email: 'b@x.com' }
-      return null
+  it('默认有效期 7 天', async () => {
+    vi.mocked(prisma.$transaction).mockImplementation(async (fn: any) => {
+      const tx = {
+        teamInvitation: {
+          deleteMany: vi.fn().mockResolvedValue({}),
+          create: vi.fn().mockResolvedValue({ id: 'inv-new', token: 'tok' }),
+        },
+        teamJoinRequest: {
+          updateMany: vi.fn().mockResolvedValue({}),
+        },
+      }
+      return fn(tx)
     })
-    vi.mocked(prisma.teamMembership.findUnique).mockResolvedValue(null)
-    vi.mocked(prisma.teamMembership.findFirst).mockResolvedValue(null)
-    vi.mocked(prisma.teamInvitation.findFirst).mockResolvedValue({ id: 'inv1' } as never)
-    await expect(
-      createTeamInvitationFn({ data: { email: 'b@x.com', seatType: 'member', channel: 'email' } }),
-    ).rejects.toMatchObject({ message: expect.stringContaining('待处理') })
+    await refreshTeamInvitationLinkFn({ data: {} })
+    const createCall = vi.mocked(prisma.$transaction).mock.calls[0][0]
+    expect(createCall).toBeDefined()
   })
+})
 
-  it('未注册邮箱 + 席位可用 → 创建邀请', async () => {
-    vi.mocked(prisma.user.findUnique).mockResolvedValue(null)
-    vi.mocked(prisma.teamMembership.findFirst).mockResolvedValue(null)
-    vi.mocked(prisma.teamInvitation.findFirst).mockResolvedValue(null)
-    vi.mocked(prisma.teamInvitation.create).mockResolvedValue(
-      { id: 'inv1', token: 't1' } as never,
-    )
-    const result = await createTeamInvitationFn({
-      data: { email: 'new@x.com', seatType: 'guest', channel: 'link' },
-    })
-    expect(prisma.teamInvitation.create).toHaveBeenCalledWith(
+describe('listTeamInvitationsFn', () => {
+  beforeEach(() => vi.clearAllMocks())
+
+  it('返回所有邀请（含已过期链接）', async () => {
+    vi.mocked(prisma.teamInvitation.updateMany).mockResolvedValue({ count: 0 } as never)
+    vi.mocked(prisma.teamInvitation.findMany).mockResolvedValue([
+      {
+        id: 'inv2',
+        ownerId: 'owner1',
+        channel: 'email',
+        status: 'pending',
+        token: 'tok2',
+        email: 'b@x.com',
+        expiresAt: new Date(Date.now() + 86400000),
+        createdAt: new Date(Date.now() + 1000),
+        owner: { id: 'owner1', username: 'A', email: 'a@x.com' },
+      },
+      {
+        id: 'inv1',
+        ownerId: 'owner1',
+        channel: 'link',
+        status: 'expired',
+        token: 'old',
+        expiresAt: new Date(Date.now() - 86400000),
+        createdAt: new Date(Date.now() - 86400000),
+        owner: { id: 'owner1', username: 'A', email: 'a@x.com' },
+      },
+    ] as never)
+    vi.mocked(prisma.teamJoinRequest.updateMany).mockResolvedValue({ count: 0 } as never)
+    vi.mocked(prisma.teamJoinRequest.findMany).mockResolvedValue([] as never)
+    const result = await listTeamInvitationsFn()
+    expect(result.invitations).toHaveLength(2)
+    expect(result.invitations[0].channel).toBe('email')
+    expect(result.invitations[1].channel).toBe('link')
+    expect(result.joinRequests).toEqual([])
+  })
+
+  it('过期 pending/pending_approval 邀请自动标记为 expired', async () => {
+    vi.mocked(prisma.teamInvitation.updateMany).mockResolvedValue({ count: 1 } as never)
+    vi.mocked(prisma.teamInvitation.findMany).mockResolvedValue([])
+    vi.mocked(prisma.teamJoinRequest.updateMany).mockResolvedValue({ count: 0 } as never)
+    vi.mocked(prisma.teamJoinRequest.findMany).mockResolvedValue([])
+    await listTeamInvitationsFn()
+    expect(prisma.teamInvitation.updateMany).toHaveBeenCalledWith(
       expect.objectContaining({
-        data: expect.objectContaining({
-          email: 'new@x.com',
-          seatType: 'guest',
-          token: expect.any(String),
-          expiresAt: expect.any(Date),
+        where: expect.objectContaining({
+          status: { in: ['pending', 'pending_approval'] },
         }),
       }),
     )
-    expect(result.success).toBe(true)
   })
+})
 
-  it('link 邀请：已有 pending 链接邀请 → 拒绝（单 pending link 语义）', async () => {
-    vi.mocked(prisma.teamInvitation.findFirst).mockResolvedValue({ id: 'inv0' } as never)
-    await expect(
-      createTeamInvitationFn({ data: { seatType: 'member', channel: 'link' } }),
-    ).rejects.toMatchObject({ message: expect.stringContaining('邀请链接') })
-  })
+describe('createTeamInvitationFn link 邀请', () => {
+  beforeEach(() => vi.clearAllMocks())
 
-  it('create 触发 P2002 → 转译为友好错误', async () => {
+  it('link 邀请：无旧 pending 链接 → 创建成功', async () => {
     vi.mocked(prisma.teamInvitation.findFirst).mockResolvedValue(null)
-    vi.mocked(prisma.teamInvitation.create).mockRejectedValue({ code: 'P2002' } as never)
-    await expect(
-      createTeamInvitationFn({ data: { seatType: 'member', channel: 'link' } }),
-    ).rejects.toMatchObject({ message: expect.stringContaining('待处理') })
+    vi.mocked(prisma.teamInvitation.create).mockResolvedValue(
+      { id: 'inv1', token: 'abc' } as never,
+    )
+    const result = await createTeamInvitationFn({ data: { seatType: 'member', channel: 'link' } })
+    expect(result.success).toBe(true)
+    expect(result.invitationId).toBe('inv1')
+  })
+})
+
+describe('clearExpiredInvitationsFn', () => {
+  beforeEach(() => vi.clearAllMocks())
+
+  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' }),
+      }),
+    )
   })
-})
+})

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' }] })
+  })
+})