@allbluecn/web-app 0.18.2 → 0.19.0

package/src/server/__tests__/csv-export.test.ts

@@ -0,0 +1,319 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// 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/>.
+
+// CSV 导出（四期 Q8 任务 44）四断言：
+// ① UTF-8 BOM（\uFEFF）前缀；② 公式注入防护（值首字符 = + - @ \t 前置 '）；
+// ③ 超 20000 行截断 truncated=true（游标/offset 分批聚合）；
+// ④ 导出范围=当前筛选（buildListWhere 同款 where 断言：filters JSON 翻译 +
+//    searchText OR + scope 聚合 projectId in）。
+// 两模块同构抽查：exportBugsFn 走 bug 侧 buildListWhere / 归档视图特殊值 /
+// 多批次翻页收口。mock 样板照 testcase-crud.test.ts（createServerFn 捕获器）。
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const H = vi.hoisted(() => {
+  const fns = {
+    requireAuth: vi.fn(),
+    resolveStoryScopeProjectIds: vi.fn(),
+  };
+  const db = {
+    caseFindMany: vi.fn(),
+    bugFindMany: vi.fn(),
+  };
+  const prisma = {
+    testCase: { findMany: db.caseFindMany },
+    bug: { findMany: db.bugFindMany },
+  };
+  return { fns, db, prisma };
+});
+
+vi.mock("@tanstack/react-start", () => {
+  // 每个 serverFn 实例独立持有自己的 capture，避免同模块多实例共用导致 validator 串号
+  const createServerFn = () => {
+    const capture: { validator?: unknown; handler?: unknown } = {};
+    const api = {
+      validator: (v: unknown) => {
+        capture.validator = v;
+        return api;
+      },
+      handler: (h: unknown) => {
+        capture.handler = h;
+        return async (args: { data: unknown }) => {
+          const v = capture.validator as { parse?: (d: unknown) => unknown } | undefined;
+          const data = v && v.parse ? v.parse(args.data) : args.data;
+          return (h as (p: { data: unknown }) => Promise<unknown>)({ data });
+        };
+      },
+    };
+    return api;
+  };
+  return { createServerFn };
+});
+
+vi.mock("@tanstack/react-start/server", () => ({ getRequest: () => ({}) }));
+
+vi.mock("@allbluecn/database/get-prisma", () => ({
+  getPrisma: async () => H.prisma,
+}));
+
+vi.mock("@/server/auth-helpers", () => ({ requireAuth: H.fns.requireAuth }));
+vi.mock("@/server/builtin-project", () => ({
+  resolveStoryScopeProjectIds: H.fns.resolveStoryScopeProjectIds,
+}));
+
+import { CSV_EXPORT_MAX_ROWS, toCsv } from "../csv";
+import { exportTestCasesFn } from "../serverFns/testcase/testcase-export";
+import { exportBugsFn } from "../serverFns/bug/bug-export";
+
+const U = "u-1";
+
+const caseRow = (over: Record<string, unknown> = {}) => ({
+  id: "c-1",
+  identifier: "WEB-TC1",
+  title: "登录成功",
+  type: "functional",
+  priority: "p1",
+  state: "approved",
+  assignee: null,
+  ...over,
+});
+
+const bugRow = (over: Record<string, unknown> = {}) => ({
+  identifier: "WEB-BUG1",
+  title: "白屏",
+  state: "open",
+  severity: "critical",
+  source: "manual",
+  totalCount: 3,
+  lastOccurAt: new Date("2026-01-01T00:00:00Z"),
+  assignee: { username: "alice" },
+  labels: [{ label: { name: "登录" } }, { label: { name: "P0" } }],
+  ...over,
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  H.fns.requireAuth.mockResolvedValue({ user: { id: U } });
+  H.fns.resolveStoryScopeProjectIds.mockImplementation(async (projectId: string | undefined) =>
+    projectId ? [projectId] : ["p1", "p2"],
+  );
+});
+
+describe("toCsv 共享工具（server/csv.ts）", () => {
+  it("断言①：输出以 UTF-8 BOM（\\uFEFF）前缀", () => {
+    const csv = toCsv([["a", "b"]]);
+    expect(csv.charCodeAt(0)).toBe(0xfeff);
+    expect(csv.startsWith("\uFEFF")).toBe(true);
+  });
+
+  it("含引号/逗号/换行的值标准 CSV 转义（包裹引号 + 引号翻倍）", () => {
+    expect(toCsv([['a"b']])).toBe('\uFEFF"a""b"');
+    expect(toCsv([["a,b"]])).toBe('\uFEFF"a,b"');
+    expect(toCsv([["a\nb"]])).toBe('\uFEFF"a\nb"');
+    expect(toCsv([['说"你好",世界']])).toBe('\uFEFF"说""你好"",世界"');
+  });
+
+  it("断言②：公式注入防护——值首字符 = + - @ \\t 前置单引号", () => {
+    expect(toCsv([["=CMD"]])).toBe("\uFEFF'=CMD");
+    expect(toCsv([["+1+1"]])).toBe("\uFEFF'+1+1");
+    expect(toCsv([["-1"]])).toBe("\uFEFF'-1");
+    expect(toCsv([["@x"]])).toBe("\uFEFF'@x");
+    expect(toCsv([["\t=CMD"]])).toBe("\uFEFF'\t=CMD");
+    // 注入前缀 + 逗号并存：先加 ' 再因逗号包引号
+    expect(toCsv([["=CMD,x"]])).toBe('\uFEFF"\'=CMD,x"');
+    // 安全值不加引号前缀
+    expect(toCsv([["普通"]])).toBe("\uFEFF普通");
+    expect(toCsv([["3-2"]])).toBe("\uFEFF3-2");
+  });
+
+  it("null/undefined 收敛为空单元格；多行多列逗号拼接（RFC 4180 CRLF 行序）", () => {
+    expect(toCsv([[null, undefined, "x"]])).toBe("\uFEFF,,x");
+    expect(toCsv([["a", "1"], ["b", "2"]])).toBe("\uFEFFa,1\r\nb,2");
+  });
+});
+
+describe("exportTestCasesFn（任务 44）", () => {
+  it("断言①+字段：csv 带 BOM、表头=列表显示属性、行含编号/标题/负责人", async () => {
+    H.db.caseFindMany.mockResolvedValue([
+      caseRow(),
+      caseRow({
+        id: "c-2",
+        identifier: "WEB-TC2",
+        title: "下单流程",
+        assignee: { username: "alice" },
+      }),
+    ]);
+    const { csv, truncated } = await exportTestCasesFn({ data: {} });
+    expect(truncated).toBe(false);
+    expect(csv.startsWith("\uFEFF")).toBe(true);
+    const body = csv.slice(1);
+    const lines = body.split("\r\n");
+    expect(lines[0]).toBe("编号,标题,类型,优先级,状态,负责人");
+    expect(lines[1]).toContain("WEB-TC1");
+    expect(lines[1]).toContain("登录成功");
+    expect(lines[2]).toContain("WEB-TC2");
+    expect(lines[2]).toContain("alice");
+  });
+
+  it("locale=en：表头切英文（数据行枚举保持 DB 原值）", async () => {
+    H.db.caseFindMany.mockResolvedValue([caseRow()]);
+    const { csv } = await exportTestCasesFn({ data: { locale: "en" } });
+    const lines = csv.slice(1).split("\r\n");
+    expect(lines[0]).toBe("ID,Title,Type,Priority,State,Assignee");
+    expect(lines[1]).toContain("登录成功");
+  });
+
+  it("断言②：单元格首字符为公式前缀时导出值前置 '（防 Excel 公式注入）", async () => {
+    H.db.caseFindMany.mockResolvedValue([caseRow({ title: "=CMD|calc" })]);
+    const { csv } = await exportTestCasesFn({ data: {} });
+    expect(csv).toContain("'=CMD|calc");
+  });
+
+  it("断言④：导出范围=当前筛选——filters JSON 经 buildListWhere 翻译 + search OR + 单项目 scope", async () => {
+    H.db.caseFindMany.mockResolvedValue([]);
+    await exportTestCasesFn({
+      data: {
+        projectId: "p1",
+        search: "登录",
+        filters: JSON.stringify([
+          { id: "c1", property: "state", operator: "is", value: "open" },
+          { id: "c2", property: "priority", operator: "is_any_of", value: "p1,p2" },
+        ]),
+      },
+    });
+    expect(H.fns.resolveStoryScopeProjectIds).toHaveBeenCalledWith("p1", U);
+    const arg = H.db.caseFindMany.mock.calls[0][0];
+    expect(arg.where.projectId).toEqual({ in: ["p1"] });
+    expect(arg.where.archived).toBe(false);
+    // searchText → title/identifier 双列 insensitive OR（list-query 同款）
+    expect(arg.where.OR).toEqual([
+      { title: { contains: "登录", mode: "insensitive" } },
+      { identifier: { contains: "登录", mode: "insensitive" } },
+    ]);
+    // filters 三段式翻译：state is → 等值；priority is_any_of 多值 → in
+    expect(arg.where.AND).toEqual([{ state: "open" }, { priority: { in: ["p1", "p2"] } }]);
+    // 服务端游标聚合首批：sequenceId asc + id tiebreaker（列表同序）
+    expect(arg.orderBy).toEqual([{ sequenceId: "asc" }, { id: "asc" }]);
+  });
+
+  it("scope 聚合：projectId 缺省 → resolveStoryScopeProjectIds 聚合成员关系内全部项目", async () => {
+    H.db.caseFindMany.mockResolvedValue([]);
+    await exportTestCasesFn({ data: {} });
+    expect(H.fns.resolveStoryScopeProjectIds).toHaveBeenCalledWith(undefined, U);
+    expect(H.db.caseFindMany.mock.calls[0][0].where.projectId).toEqual({ in: ["p1", "p2"] });
+  });
+
+  it("断言③：超上限截断——持续满批返回时 20000 行封顶且 truncated=true", async () => {
+    // 每批恒满 1000 行（模拟远大于上限的数据集）
+    H.db.caseFindMany.mockImplementation(async ({ take }: { take: number }) =>
+      Array.from({ length: take }, (_, i) =>
+        caseRow({ id: `c-${i}`, identifier: `WEB-TC${i}` }),
+      ),
+    );
+    const { csv, truncated } = await exportTestCasesFn({ data: {} });
+    expect(truncated).toBe(true);
+    const lines = csv.slice(1).split("\r\n");
+    expect(lines).toHaveLength(CSV_EXPORT_MAX_ROWS + 1); // 表头 + 20000 数据行
+    // 游标翻页：skip:1 + cursor:{id} 逐批推进
+    const secondCall = H.db.caseFindMany.mock.calls[1][0];
+    expect(secondCall.skip).toBe(1);
+    expect(secondCall.cursor).toEqual({ id: "c-999" });
+  });
+
+  it("不满一批即收口：单批尾部返回 truncated=false", async () => {
+    H.db.caseFindMany.mockResolvedValue([caseRow()]);
+    const { csv, truncated } = await exportTestCasesFn({ data: {} });
+    expect(truncated).toBe(false);
+    expect(csv.slice(1).split("\r\n")).toHaveLength(2);
+    expect(H.db.caseFindMany).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("exportBugsFn（同构抽查）", () => {
+  it("断言④同构：filters 翻译 + scope + 默认排除待确认；行含标签合并与 ISO 日期", async () => {
+    H.db.bugFindMany.mockResolvedValue([bugRow()]);
+    const { csv, truncated } = await exportBugsFn({
+      data: {
+        projectId: "p1",
+        search: "白屏",
+        filters: JSON.stringify([
+          { id: "b1", property: "severity", operator: "is", value: "critical" },
+        ]),
+      },
+    });
+    expect(truncated).toBe(false);
+    expect(H.fns.resolveStoryScopeProjectIds).toHaveBeenCalledWith("p1", U);
+    const arg = H.db.bugFindMany.mock.calls[0][0];
+    expect(arg.where.projectId).toEqual({ in: ["p1"] });
+    expect(arg.where.archived).toBe(false);
+    // Q2 待确认闸门：导出=默认列表口径，排除 pendingConfirm
+    expect(arg.where.pendingConfirm).toBe(false);
+    expect(arg.where.OR).toEqual([
+      { title: { contains: "白屏", mode: "insensitive" } },
+      { identifier: { contains: "白屏", mode: "insensitive" } },
+    ]);
+    expect(arg.where.AND).toEqual([{ severity: "critical" }]);
+    // 内容抽查：BOM + 标签逗号合并（带引号转义）+ 日期 ISO 化
+    expect(csv.startsWith("\uFEFF")).toBe(true);
+    expect(csv).toContain('"登录,P0"');
+    expect(csv).toContain("2026-01-01T00:00:00.000Z");
+    // offset 翻页首批 skip:0
+    expect(arg.skip).toBe(0);
+  });
+
+  it("归档视图特殊值：projectId=__archived__ 直达 buildListWhere（archived=true + 成员圈定）", async () => {
+    H.db.bugFindMany.mockResolvedValue([]);
+    await exportBugsFn({ data: { projectId: "__archived__" } });
+    expect(H.fns.resolveStoryScopeProjectIds).not.toHaveBeenCalled();
+    const arg = H.db.bugFindMany.mock.calls[0][0];
+    expect(arg.where.archived).toBe(true);
+    expect(arg.where.project).toEqual({
+      members: { some: { userId: U, status: { not: "suspended" } } },
+    });
+  });
+
+  it("多批次翻页：满批续拉、尾批收口 truncated=false", async () => {
+    H.db.bugFindMany
+      .mockResolvedValueOnce(Array.from({ length: 1000 }, (_, i) => bugRow({ identifier: `B${i}` })))
+      .mockResolvedValueOnce([bugRow({ identifier: "B-last" })]);
+    const { csv, truncated } = await exportBugsFn({ data: {} });
+    expect(truncated).toBe(false);
+    expect(H.db.bugFindMany).toHaveBeenCalledTimes(2);
+    expect(H.db.bugFindMany.mock.calls[1][0].skip).toBe(1000);
+    expect(csv).toContain("B-last");
+  });
+
+  it("断言③同构：满批持续返回时同上限截断 truncated=true", async () => {
+    H.db.bugFindMany.mockImplementation(async ({ take }: { take: number }) =>
+      Array.from({ length: take }, (_, i) => bugRow({ identifier: `B${i}` })),
+    );
+    const { csv, truncated } = await exportBugsFn({ data: {} });
+    expect(truncated).toBe(true);
+    expect(csv.slice(1).split("\r\n")).toHaveLength(CSV_EXPORT_MAX_ROWS + 1);
+  });
+
+  it("locale=en 同构：表头切英文（缺省仍中文）", async () => {
+    H.db.bugFindMany.mockResolvedValue([bugRow()]);
+    const zh = await exportBugsFn({ data: {} });
+    expect(zh.csv.slice(1).split("\r\n")[0]).toBe(
+      "标识,标题,状态,严重级别,来源,负责人,标签,发生次数,最近发生",
+    );
+    const en = await exportBugsFn({ data: { locale: "en" } });
+    expect(en.csv.slice(1).split("\r\n")[0]).toBe(
+      "Identifier,Title,State,Severity,Source,Assignee,Labels,Occurrences,Last Occurred",
+    );
+  });
+});

package/src/server/__tests__/share-version.test.ts

@@ -64,7 +64,10 @@ import { getVersionShareFn } from "@/server/serverFns/share/version"
 const versionId = "version-001"
 const now = new Date("2026-10-06T10:00:00.000Z")
 
-const validShareVersionRow = { id: "sv-001" }
+const validShareVersionRow = {
+  id: "sv-001",
+  share: { token: "tok-abc", designId: "design-001" },
+}
 
 const designVersionRow = {
   versionLabel: "v1.2",
@@ -101,7 +104,7 @@ describe("getVersionShareFn", () => {
           OR: [{ expiresAt: null }, { expiresAt: { gt: expect.any(Date) } }],
         },
       },
-      select: { id: true },
+      select: { id: true, share: { select: { token: true, designId: true } } },
     })
     expect(mocks.designVersionFindUnique).not.toHaveBeenCalled()
   })
@@ -135,6 +138,8 @@ describe("getVersionShareFn", () => {
       prdName: "Marketing Site",
       versionLabel: "v1.2",
       notes: "first release",
+      shareToken: "tok-abc",
+      designId: "design-001",
       pageVersions: [
         {
           pageId: "page-001",

package/src/server/__tests__/task-assigned-query.test.ts

@@ -0,0 +1,232 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import { prisma } from "@allbluecn/database"
+import { fetchAssignedToMe } from "@/server/ai-task/assigned-query"
+
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    story: { findMany: vi.fn() },
+    bug: { findMany: vi.fn() },
+    testCase: { findMany: vi.fn() },
+  },
+}))
+
+const storyFindMany = prisma.story.findMany as ReturnType<typeof vi.fn>
+const bugFindMany = prisma.bug.findMany as ReturnType<typeof vi.fn>
+const testCaseFindMany = prisma.testCase.findMany as ReturnType<typeof vi.fn>
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+afterEach(() => {
+  vi.unstubAllEnvs()
+})
+
+const storyRow = {
+  id: "story-1",
+  identifier: "ALB-S12",
+  name: "登录页重构",
+  state: "in_progress",
+  priority: "high",
+  targetDate: new Date("2026-10-15T00:00:00.000Z"),
+  updatedAt: new Date("2026-10-08T10:00:00.000Z"),
+  projectId: "project-1",
+  project: { name: "理想之海" },
+}
+
+const storyRowNoDate = {
+  id: "story-2",
+  identifier: "ALB-S13",
+  name: "设置页改版",
+  state: "todo",
+  priority: "none",
+  targetDate: null,
+  updatedAt: new Date("2026-10-05T10:00:00.000Z"),
+  projectId: "project-1",
+  project: { name: "理想之海" },
+}
+
+const bugRow = {
+  id: "bug-1",
+  identifier: "ALB-B3",
+  title: "首页白屏",
+  state: "open",
+  severity: "critical",
+  updatedAt: new Date("2026-10-09T08:00:00.000Z"),
+  projectId: "project-1",
+  project: { name: "理想之海" },
+}
+
+const testCaseRow = {
+  id: "case-1",
+  identifier: "ALB-TC7",
+  title: "登录冒烟用例",
+  state: "in_review",
+  priority: "p2",
+  updatedAt: new Date("2026-10-07T09:00:00.000Z"),
+  projectId: "project-1",
+  project: { name: "理想之海" },
+}
+
+function mockAllTables() {
+  storyFindMany.mockResolvedValue([storyRow, storyRowNoDate])
+  bugFindMany.mockResolvedValue([bugRow])
+  testCaseFindMany.mockResolvedValue([testCaseRow])
+}
+
+const MEMBER_SOME = { userId: "u1", status: { not: "suspended" } }
+const BASE_WHERE = {
+  assigneeId: "u1",
+  archived: false,
+  project: { members: { some: MEMBER_SOME } },
+}
+
+describe("fetchAssignedToMe", () => {
+  it("对 story/bug/testCase 三表各发一次 findMany", async () => {
+    mockAllTables()
+    await fetchAssignedToMe("u1")
+    expect(storyFindMany).toHaveBeenCalledTimes(1)
+    expect(bugFindMany).toHaveBeenCalledTimes(1)
+    expect(testCaseFindMany).toHaveBeenCalledTimes(1)
+  })
+
+  it("story 查询：成员圈定 + 状态口径 + updatedAt 倒序", async () => {
+    mockAllTables()
+    await fetchAssignedToMe("u1")
+    expect(storyFindMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          ...BASE_WHERE,
+          state: { in: ["backlog", "todo", "in_progress"] },
+        }),
+        orderBy: { updatedAt: "desc" },
+      }),
+    )
+  })
+
+  it("bug 查询：成员圈定 + 状态口径 + updatedAt 倒序", async () => {
+    mockAllTables()
+    await fetchAssignedToMe("u1")
+    expect(bugFindMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          ...BASE_WHERE,
+          state: { in: ["open", "in_progress"] },
+        }),
+        orderBy: { updatedAt: "desc" },
+      }),
+    )
+  })
+
+  it("testCase 查询：成员圈定 + 状态口径 + updatedAt 倒序", async () => {
+    mockAllTables()
+    await fetchAssignedToMe("u1")
+    expect(testCaseFindMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          ...BASE_WHERE,
+          state: { in: ["draft", "in_review"] },
+        }),
+        orderBy: { updatedAt: "desc" },
+      }),
+    )
+  })
+
+  it("返回项映射正确：title/priority/href/identifier/dueAt，组序 story→bug→testcase", async () => {
+    mockAllTables()
+    const result = await fetchAssignedToMe("u1")
+    expect(result.degraded).toEqual([])
+    // 组序固定 story → bug → testcase（bug updatedAt 最新但不跨组重排）
+    expect(result.items.map((item) => item.source)).toEqual([
+      "story",
+      "story",
+      "bug",
+      "testcase",
+    ])
+    expect(result.items[0]).toEqual({
+      source: "story",
+      id: "story-1",
+      identifier: "ALB-S12",
+      title: "登录页重构",
+      projectId: "project-1",
+      projectName: "理想之海",
+      priority: "P1", // mapToUnifiedPriority("story", "high")
+      dueAt: "2026-10-15T00:00:00.000Z",
+      href: "/stories/story-1",
+      updatedAt: "2026-10-08T10:00:00.000Z",
+    })
+    // story 无 targetDate / priority none → dueAt null、priority null
+    expect(result.items[1]).toEqual({
+      source: "story",
+      id: "story-2",
+      identifier: "ALB-S13",
+      title: "设置页改版",
+      projectId: "project-1",
+      projectName: "理想之海",
+      priority: null,
+      dueAt: null,
+      href: "/stories/story-2",
+      updatedAt: "2026-10-05T10:00:00.000Z",
+    })
+    expect(result.items[2]).toEqual({
+      source: "bug",
+      id: "bug-1",
+      identifier: "ALB-B3",
+      title: "首页白屏",
+      projectId: "project-1",
+      projectName: "理想之海",
+      priority: "P0", // mapToUnifiedPriority("bug", "critical")
+      dueAt: null,
+      href: "/bugs/bug-1",
+      updatedAt: "2026-10-09T08:00:00.000Z",
+    })
+    expect(result.items[3]).toEqual({
+      source: "testcase",
+      id: "case-1",
+      identifier: "ALB-TC7",
+      title: "登录冒烟用例",
+      projectId: "project-1",
+      projectName: "理想之海",
+      priority: "P2", // mapToUnifiedPriority("testcase", "p2")
+      dueAt: null,
+      href: "/test-cases/case-1",
+      updatedAt: "2026-10-07T09:00:00.000Z",
+    })
+  })
+
+  it("DATABASE_PROVIDER=sqlite：只查 story，bug/testcase 降级", async () => {
+    vi.stubEnv("DATABASE_PROVIDER", "sqlite")
+    storyFindMany.mockResolvedValue([storyRow])
+    const result = await fetchAssignedToMe("u1")
+    expect(storyFindMany).toHaveBeenCalledTimes(1)
+    expect(bugFindMany).not.toHaveBeenCalled()
+    expect(testCaseFindMany).not.toHaveBeenCalled()
+    expect(result.degraded).toEqual(["bug", "testcase"])
+    expect(result.items).toHaveLength(1)
+    expect(result.items[0]?.source).toBe("story")
+  })
+
+  it("DATABASE_PROVIDER 未设置时默认 postgresql：三表全查", async () => {
+    vi.stubEnv("DATABASE_PROVIDER", undefined)
+    mockAllTables()
+    const result = await fetchAssignedToMe("u1")
+    expect(storyFindMany).toHaveBeenCalledTimes(1)
+    expect(bugFindMany).toHaveBeenCalledTimes(1)
+    expect(testCaseFindMany).toHaveBeenCalledTimes(1)
+    expect(result.degraded).toEqual([])
+  })
+
+  it("select 收窄：不含大字段（bug.stackSummary / 双方 description 不出现在 select）", async () => {
+    mockAllTables()
+    await fetchAssignedToMe("u1")
+    const bugSelect = bugFindMany.mock.calls[0]?.[0]?.select
+    expect(bugSelect).toBeDefined()
+    expect(bugSelect).not.toHaveProperty("stackSummary")
+    expect(bugSelect).not.toHaveProperty("description")
+    expect(bugSelect).not.toHaveProperty("reproduceSteps")
+    expect(bugSelect).toHaveProperty("title")
+    const storySelect = storyFindMany.mock.calls[0]?.[0]?.select
+    expect(storySelect).not.toHaveProperty("description")
+    expect(storySelect).toHaveProperty("name")
+  })
+})