@allbluecn/web-app 0.3.0

package/src/server/serverFns/settings/account-team.ts

@@ -0,0 +1,66 @@
+// 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/>.
+
+import { createServerFn } from '@tanstack/react-start'
+import { getRequest } from '@tanstack/react-start/server'
+import { prisma } from '@allbluecn/database'
+import { getCurrentSession } from '@/lib/session'
+
+interface AccountTeamSuccess {
+  error?: undefined
+  initialAvatarConfig: Record<string, number> | null
+  initialBgShape: string
+  initialBgColor: string
+  user: {
+    id: string
+    name: string | null | undefined
+    email: string | null | undefined
+    role: string | undefined
+    createdAt: Date | null
+  }
+}
+
+interface AccountTeamError {
+  error: 'unauthorized'
+}
+
+type AccountTeamResult = AccountTeamSuccess | AccountTeamError
+
+export const getAccountTeamFn = createServerFn({ method: 'GET' })
+  .handler(async (): Promise<AccountTeamResult> => {
+    const request = getRequest()
+    const session = await getCurrentSession(request)
+    if (!session?.user?.id) return { error: 'unauthorized' as const }
+
+    const dbUser = await prisma.user.findUnique({
+      where: { id: session.user.id },
+      select: { avatarConfig: true, bgShape: true, bgColor: true, username: true, email: true, createdAt: true },
+    })
+
+    return {
+      initialAvatarConfig: (dbUser?.avatarConfig ?? null) as Record<string, number> | null,
+      initialBgShape: dbUser?.bgShape ?? 'square',
+      initialBgColor: dbUser?.bgColor ?? '#fff',
+      user: {
+        id: session.user.id,
+        name: dbUser?.username || session.user.name,
+        email: dbUser?.email || session.user.email,
+        role: (session.user as { role?: string })?.role,
+        createdAt: dbUser?.createdAt ?? null,
+      },
+    }
+  })

package/src/server/serverFns/share/prd/[prdId]/events.ts

@@ -0,0 +1,33 @@
+// 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/>.
+
+import { createServerFn } from '@tanstack/react-start'
+import { getRequest } from '@tanstack/react-start/server'
+import { z } from 'zod'
+import { requireAuth } from '@/server/auth-helpers'
+
+const schema = z.object({
+  prdId: z.string(),
+})
+
+export const shareEventsFn = createServerFn({ method: 'GET' })
+  .validator(schema)
+  .handler(async ({ data }) => {
+    const request = getRequest()
+    await requireAuth(request)
+    return { prdId: data.prdId, subscribed: true }
+  })

package/src/server/serverFns/share/verify-password.ts

@@ -0,0 +1 @@
+export * from '@allbluecn/plugins-core/prd/serverFns/share/verify-password'

package/src/server/serverFns/share/version.ts

@@ -0,0 +1,70 @@
+// 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/>.
+
+import { createServerFn } from '@tanstack/react-start'
+import { z } from 'zod'
+import { prisma } from '@allbluecn/database'
+
+interface ShareVersionData {
+  prdName: string
+  versionLabel: string
+  notes: string | null
+  pageVersions: Array<{
+    pageId: string
+    pageName: string
+    version: number
+    canvas: { elements: Array<Record<string, number | string | boolean>>; device: string } | null
+    content: string | null
+  }>
+}
+
+export const getVersionShareFn = createServerFn({ method: 'GET' })
+  .validator(z.object({ versionId: z.string() }))
+  .handler(async ({ data: { versionId } }): Promise<ShareVersionData | null> => {
+    const version = await prisma.pRDVersion.findUnique({
+      where: { id: versionId },
+      select: {
+        versionLabel: true,
+        notes: true,
+        pageVersions: true,
+        prd: { select: { name: true } },
+      },
+    })
+    if (!version) return null
+
+    const rawPageVersions = version.pageVersions as unknown as Array<{
+      pageId: string
+      pageName: string
+      version: number
+      canvas: unknown[] | { elements: unknown[]; device: string } | null
+      content: unknown
+    }>
+
+    const pageVersions = rawPageVersions.map((pv) => ({
+      ...pv,
+      canvas: Array.isArray(pv.canvas)
+        ? { elements: pv.canvas, device: 'desktop' }
+        : pv.canvas,
+    })) as ShareVersionData['pageVersions']
+
+    return {
+      prdName: version.prd.name,
+      versionLabel: version.versionLabel,
+      notes: version.notes,
+      pageVersions,
+    }
+  })

package/src/server/serverFns/share/versions.ts

@@ -0,0 +1 @@
+export * from '@allbluecn/plugins-core/prd/serverFns/share/versions'

package/src/server/serverFns/sso.ts

@@ -0,0 +1,27 @@
+import { createServerFn } from '@tanstack/react-start'
+import { z } from 'zod'
+import { getProService } from '@/server/pro-services'
+import { prisma } from '@allbluecn/database'
+import { checkRateLimit } from '@/lib/pacer'
+
+const SSO_DOMAIN_RATE_LIMIT = { max: 20, windowMs: 60_000 }
+
+export const checkSsoDomainFn = createServerFn({ method: 'GET' })
+  .validator(z.object({ email: z.string().min(3).max(254) }))
+  .handler(async ({ data }) => {
+    if (!getProService('sso')) return null
+
+    const at = data.email.lastIndexOf('@')
+    if (at < 0) return null
+    const domain = data.email.slice(at + 1).toLowerCase()
+
+    const rl = checkRateLimit(`sso-domain:${domain}`, SSO_DOMAIN_RATE_LIMIT)
+    if (!rl.allowed) return null
+
+    const provider = await prisma.ssoProvider.findFirst({
+      where: { domain, enabled: true },
+      select: { id: true, name: true, type: true },
+    })
+    if (!provider) return null
+    return { providerId: provider.id, name: provider.name, type: provider.type }
+  })

package/src/server/serverFns/story/__tests__/bulk.test.ts

@@ -0,0 +1,156 @@
+// 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/>.
+
+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: () => ({}),
+}));
+
+const mocks = vi.hoisted(() => ({
+  findMany: vi.fn(),
+  update: vi.fn(),
+  deleteMany: vi.fn(),
+  activityCreate: vi.fn(),
+  currentSession: vi.fn(),
+  txRunner: vi.fn(),
+}));
+
+vi.mock("@allbluecn/database", () => {
+  const prisma = {
+    story: { findMany: mocks.findMany, update: mocks.update, deleteMany: mocks.deleteMany },
+    storyActivity: { create: mocks.activityCreate },
+    $transaction: (cb: any) => cb(prisma),
+  };
+  return { prisma, Prisma: {} };
+});
+
+vi.mock("@/server/auth-helpers", () => ({
+  requireAuth: mocks.currentSession,
+}));
+
+import { bulkArchiveStoriesFn, bulkDeleteStoriesFn, bulkUpdateStoriesFn } from "../story-crud/bulk";
+
+describe("bulkArchiveStoriesFn", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.currentSession.mockResolvedValue({ user: { id: "u1" } });
+  });
+
+  it("仅归档未归档且 state=done/cancelled，返回 archived/skipped 计数", async () => {
+    mocks.findMany.mockResolvedValue([
+      { id: "a", state: "done", archived: false },
+      { id: "b", state: "cancelled", archived: false },
+      { id: "c", state: "todo", archived: false },
+      { id: "d", state: "done", archived: true },
+    ]);
+    const out = await bulkArchiveStoriesFn({ data: { storyIds: ["a", "b", "c", "d"] } });
+    expect(out).toEqual({ archived: 2, skipped: 2 });
+    expect(mocks.findMany).toHaveBeenCalledWith({
+      where: { id: { in: ["a", "b", "c", "d"] } },
+      select: { id: true, state: true, archived: true },
+    });
+    expect(mocks.update).toHaveBeenCalledTimes(2);
+    expect(mocks.update).toHaveBeenCalledWith(expect.objectContaining({
+      where: { id: "a" },
+      data: expect.objectContaining({ archived: true }),
+    }));
+    expect(mocks.activityCreate).toHaveBeenCalledTimes(2);
+    expect(mocks.activityCreate).toHaveBeenCalledWith(expect.objectContaining({
+      data: expect.objectContaining({ storyId: "a", action: "archived" }),
+    }));
+  });
+
+  it("未登录时拒绝且不查询", async () => {
+    mocks.currentSession.mockRejectedValue(new Error("unauthorized"));
+    await expect(bulkArchiveStoriesFn({ data: { storyIds: ["a"] } })).rejects.toMatchObject({ message: expect.stringContaining("unauthorized") });
+    expect(mocks.findMany).not.toHaveBeenCalled();
+  });
+});
+
+describe("bulkDeleteStoriesFn", () => {
+  it("批量删除并返回 deleted 计数", async () => {
+    mocks.currentSession.mockResolvedValue({ user: { id: "u1" } });
+    mocks.deleteMany.mockResolvedValue({ count: 3 });
+    const out = await bulkDeleteStoriesFn({ data: { storyIds: ["a", "b", "c"] } });
+    expect(out).toEqual({ deleted: 3 });
+    expect(mocks.deleteMany).toHaveBeenCalledWith({ where: { id: { in: ["a", "b", "c"] } } });
+  });
+});
+
+describe("bulkUpdateStoriesFn", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.currentSession.mockResolvedValue({ user: { id: "u1" } });
+  });
+
+  it("批量更新 state/priority 并对有变化的项写活动记录", async () => {
+    mocks.findMany.mockResolvedValue([
+      { id: "a", state: "todo", priority: "low", assignee: null, startDate: null, targetDate: null },
+      { id: "b", state: "done", priority: "high", assignee: null, startDate: null, targetDate: null },
+    ]);
+    mocks.update.mockResolvedValue({});
+    const out = await bulkUpdateStoriesFn({
+      data: { storyIds: ["a", "b"], patch: { state: "in_progress" } },
+    });
+    expect(out).toEqual({ updated: 2 });
+    expect(mocks.update).toHaveBeenCalledTimes(2);
+    expect(mocks.update).toHaveBeenCalledWith(expect.objectContaining({
+      where: { id: "a" },
+      data: expect.objectContaining({ state: "in_progress" }),
+    }));
+    expect(mocks.activityCreate).toHaveBeenCalledTimes(2); // a: todo→in_progress, b: done→in_progress
+  });
+
+  it("同值更新不写活动", async () => {
+    mocks.findMany.mockResolvedValue([
+      { id: "a", state: "todo", priority: "low", assignee: null, startDate: null, targetDate: null },
+    ]);
+    mocks.update.mockResolvedValue({});
+    await bulkUpdateStoriesFn({ data: { storyIds: ["a"], patch: { state: "todo" } } });
+    expect(mocks.activityCreate).not.toHaveBeenCalled();
+  });
+
+  it("空 patch 被 validator 拒绝", async () => {
+    await expect(
+      bulkUpdateStoriesFn({ data: { storyIds: ["a"], patch: {} as never } }),
+    ).rejects.toThrow();
+  });
+});

package/src/server/serverFns/story/__tests__/story-groups.test.ts

@@ -0,0 +1,329 @@
+// 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/>.
+
+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: () => ({}),
+}));
+
+const mocks = vi.hoisted(() => ({
+  findMany: vi.fn(),
+  count: vi.fn(),
+  groupBy: vi.fn(),
+  storyLabelGroupBy: vi.fn(),
+  currentSession: vi.fn(),
+}));
+
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    story: { findMany: mocks.findMany, count: mocks.count, groupBy: mocks.groupBy },
+    storyLabel: { groupBy: mocks.storyLabelGroupBy },
+  },
+  Prisma: {},
+}));
+
+vi.mock("@/server/auth-helpers", () => ({
+  requireAuth: mocks.currentSession,
+}));
+
+import { listStoriesInGroupFn, listStoryGroupsFn } from "../story-groups";
+
+describe("listStoriesInGroupFn", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.currentSession.mockResolvedValue({ user: { id: "u1" } });
+  });
+
+  it("构建含 group 过滤的 where 并返回 total/hasMore", async () => {
+    mocks.findMany.mockResolvedValue([]);
+    const out = await listStoriesInGroupFn({
+      data: { archived: false, groupBy: "state", groupKey: "todo" },
+    });
+    expect(out).toEqual({ items: [], total: undefined, hasMore: false });
+    const arg = mocks.findMany.mock.calls[0][0] as any;
+    expect(arg.where.AND).toContainEqual({ state: "todo" });
+    expect(arg.where.archived).toBe(false);
+    expect(arg.orderBy).toEqual({ createdAt: "desc" });
+    expect(mocks.count).not.toHaveBeenCalled();
+  });
+
+  it("group 过滤与 base 的 AND 合并时不被覆盖", async () => {
+    mocks.findMany.mockResolvedValue([]);
+    mocks.count.mockResolvedValue(100);
+    const out = await listStoriesInGroupFn({
+      data: {
+        archived: false,
+        state: "backlog",
+        filters: JSON.stringify([{ property: "priority", operator: "is_not", value: "low" }]),
+        groupBy: "priority",
+        groupKey: "urgent",
+        skip: 50,
+        take: 50,
+      },
+    });
+    const arg = mocks.findMany.mock.calls[0][0] as any;
+    expect(arg.where.state).toBe("backlog");
+    expect(arg.where.AND).toHaveLength(2);
+    expect(arg.where.AND).toContainEqual({ priority: { notIn: ["low"] } });
+    expect(arg.where.AND).toContainEqual({ priority: "urgent" });
+    expect(out.hasMore).toBe(true);
+    expect(mocks.count).toHaveBeenCalledWith({ where: arg.where });
+  });
+
+  it("groupBy=none 时不合并 group 过滤", async () => {
+    mocks.findMany.mockResolvedValue([]);
+    await listStoriesInGroupFn({
+      data: { archived: false, groupBy: "none", groupKey: "" },
+    });
+    const arg = mocks.findMany.mock.calls[0][0] as any;
+    expect(arg.where.AND).toBeUndefined();
+    expect(arg.where.archived).toBe(false);
+  });
+
+  it("subGroupBy+subGroupKey 时 where.AND 同时含主组与子组过滤", async () => {
+    mocks.findMany.mockResolvedValue([]);
+    await listStoriesInGroupFn({
+      data: {
+        archived: false,
+        groupBy: "state",
+        groupKey: "todo",
+        subGroupBy: "assignee",
+        subGroupKey: "unassigned",
+        skip: 50,
+        take: 50,
+      },
+    });
+    const arg = mocks.findMany.mock.calls[0][0] as any;
+    expect(arg.where.archived).toBe(false);
+    expect(arg.where.AND).toContainEqual({ state: "todo" });
+    expect(arg.where.AND).toContainEqual({ assigneeId: null });
+    expect(mocks.count).toHaveBeenCalledWith({ where: arg.where });
+  });
+
+  it("subGroupBy 默认 none 时不加子组过滤", async () => {
+    mocks.findMany.mockResolvedValue([]);
+    await listStoriesInGroupFn({
+      data: { archived: false, groupBy: "state", groupKey: "todo" },
+    });
+    const arg = mocks.findMany.mock.calls[0][0] as any;
+    expect(arg.where.AND).toHaveLength(1);
+    expect(arg.where.AND).toContainEqual({ state: "todo" });
+  });
+
+  it("非法 groupBy 被 validator 拒绝", async () => {
+    await expect(
+      listStoriesInGroupFn({ data: { archived: false, groupBy: "garbage" as never } }),
+    ).rejects.toThrow();
+  });
+
+  it("未登录时拒绝且不查询数据库", async () => {
+    mocks.currentSession.mockRejectedValue(new Error("unauthorized"));
+    mocks.findMany.mockResolvedValue([]);
+    mocks.count.mockResolvedValue(0);
+    await expect(
+      listStoriesInGroupFn({ data: { archived: false } }),
+    ).rejects.toMatchObject({ message: expect.stringContaining("unauthorized") });
+    expect(mocks.findMany).not.toHaveBeenCalled();
+    expect(mocks.count).not.toHaveBeenCalled();
+  });
+});
+
+describe("listStoryGroupsFn", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.currentSession.mockResolvedValue({ user: { id: "u1" } });
+  });
+
+  it("按 groupBy 聚合返回组 key 列表", async () => {
+    mocks.groupBy.mockResolvedValue([
+      { state: "todo", _count: { _all: 3 } },
+      { state: "doing", _count: { _all: 1 } },
+    ]);
+    const out = await listStoryGroupsFn({
+      data: { archived: false, groupBy: "state" },
+    });
+    expect(out).toEqual({ groups: [{ key: "todo", total: 3 }, { key: "doing", total: 1 }] });
+    const arg = mocks.groupBy.mock.calls[0][0] as any;
+    expect(arg.by).toEqual(["state"]);
+    expect(arg.where.archived).toBe(false);
+    expect(arg._count).toEqual({ _all: true });
+  });
+
+  it("groupBy 默认 state", async () => {
+    mocks.groupBy.mockResolvedValue([]);
+    const out = await listStoryGroupsFn({ data: { archived: false } });
+    expect(out).toEqual({ groups: [] });
+    const arg = mocks.groupBy.mock.calls[0][0] as any;
+    expect(arg.by).toEqual(["state"]);
+  });
+
+  it("assignee 空值归并为 unassigned", async () => {
+    mocks.groupBy.mockResolvedValue([
+      { assigneeId: null, _count: { _all: 3 } },
+      { assigneeId: "u9", _count: { _all: 1 } },
+    ]);
+    const out = await listStoryGroupsFn({
+      data: { archived: false, groupBy: "assignee" },
+    });
+    expect(out).toEqual({ groups: [{ key: "unassigned", total: 3 }, { key: "u9", total: 1 }] });
+    const arg = mocks.groupBy.mock.calls[0][0] as any;
+    expect(arg.by).toEqual(["assigneeId"]);
+  });
+
+  it("showEmptyGroups 时前置空组枚举并去重", async () => {
+    mocks.groupBy.mockResolvedValue([{ state: "todo", _count: { _all: 5 } }]);
+    const out = await listStoryGroupsFn({
+      data: { archived: false, groupBy: "state", showEmptyGroups: true },
+    });
+    expect(out.groups.map((g) => g.key)).toEqual(["backlog", "todo", "in_progress", "done", "cancelled"]);
+    expect(out.groups.find((g) => g.key === "todo")?.total).toBe(5);
+    expect(out.groups.find((g) => g.key === "backlog")?.total).toBe(0);
+  });
+
+  it("labels 分组按 storyLabel.groupBy 聚合并计入 no-labels", async () => {
+    mocks.storyLabelGroupBy.mockResolvedValue([
+      { labelId: "l1", _count: { _all: 2 } },
+      { labelId: "l2", _count: { _all: 1 } },
+    ]);
+    mocks.count.mockResolvedValue(3);
+    const out = await listStoryGroupsFn({
+      data: { archived: false, groupBy: "labels" },
+    });
+    expect(out.groups.map((g) => g.key)).toEqual(["no-labels", "l1", "l2"]);
+    expect(out.groups.find((g) => g.key === "no-labels")?.total).toBe(3);
+    expect(out.groups.find((g) => g.key === "l1")?.total).toBe(2);
+    const arg = mocks.storyLabelGroupBy.mock.calls[0][0] as any;
+    expect(arg.by).toEqual(["labelId"]);
+    expect(arg.where.story.archived).toBe(false);
+    expect(mocks.count).toHaveBeenCalledWith({
+      where: expect.objectContaining({ AND: [{ labels: { none: {} } }] }),
+    });
+  });
+
+  it("labels 分组 + labelId 过滤时 no-labels 计数不覆盖顶层 labels 过滤", async () => {
+    mocks.storyLabelGroupBy.mockResolvedValue([
+      { labelId: "l1", _count: { _all: 2 } },
+    ]);
+    mocks.count.mockResolvedValue(0);
+    const out = await listStoryGroupsFn({
+      data: { archived: false, groupBy: "labels", labelId: "l1" },
+    });
+    expect(out).toEqual({ groups: [{ key: "l1", total: 2 }] });
+    const labelArg = mocks.storyLabelGroupBy.mock.calls[0][0] as any;
+    expect(labelArg.where.story.labels).toEqual({ some: { labelId: "l1" } });
+    const countArg = mocks.count.mock.calls[0][0] as any;
+    expect(countArg.where.labels).toEqual({ some: { labelId: "l1" } });
+    expect(countArg.where.AND).toContainEqual({ labels: { none: {} } });
+  });
+
+  it("no-labels 计数为 0 时不加入 no-labels 组", async () => {
+    mocks.storyLabelGroupBy.mockResolvedValue([
+      { labelId: "l1", _count: { _all: 2 } },
+    ]);
+    mocks.count.mockResolvedValue(0);
+    const out = await listStoryGroupsFn({
+      data: { archived: false, groupBy: "labels" },
+    });
+    expect(out).toEqual({ groups: [{ key: "l1", total: 2 }] });
+  });
+
+  it("groupBy=none 时返回空列表且不查询", async () => {
+    const out = await listStoryGroupsFn({
+      data: { archived: false, groupBy: "none" },
+    });
+    expect(out).toEqual({ groups: [] });
+    expect(mocks.groupBy).not.toHaveBeenCalled();
+    expect(mocks.storyLabelGroupBy).not.toHaveBeenCalled();
+  });
+
+  it("parentGroupKey 使 groupBy 调用 where 先加载父组条件", async () => {
+    mocks.groupBy.mockResolvedValue([
+      { assigneeId: "u1", _count: { _all: 1 } },
+    ]);
+    const out = await listStoryGroupsFn({
+      data: {
+        archived: false,
+        groupBy: "assignee",
+        parentGroupBy: "state",
+        parentGroupKey: "todo",
+      },
+    });
+    expect(out).toEqual({ groups: [{ key: "u1", total: 1 }] });
+    const arg = mocks.groupBy.mock.calls[0][0] as any;
+    expect(arg.by).toEqual(["assigneeId"]);
+    expect(arg.where.archived).toBe(false);
+    expect(arg.where.AND).toContainEqual({ state: "todo" });
+  });
+
+  it("parentGroupKey 未传 parentGroupBy 时不叠加父组条件", async () => {
+    mocks.groupBy.mockResolvedValue([{ assigneeId: "u1", _count: { _all: 1 } }]);
+    const out = await listStoryGroupsFn({
+      data: { archived: false, groupBy: "assignee", parentGroupKey: "todo" },
+    });
+    const arg = mocks.groupBy.mock.calls[0][0] as any;
+    expect(arg.where.AND).toBeUndefined();
+    expect(out).toEqual({ groups: [{ key: "u1", total: 1 }] });
+  });
+
+  it("labels 子组枚举可选叠加父组过滤", async () => {
+    mocks.storyLabelGroupBy.mockResolvedValue([{ labelId: "l1", _count: { _all: 1 } }]);
+    mocks.count.mockResolvedValue(0);
+    const out = await listStoryGroupsFn({
+      data: {
+        archived: false,
+        groupBy: "labels",
+        parentGroupBy: "state",
+        parentGroupKey: "todo",
+      },
+    });
+    expect(out).toEqual({ groups: [{ key: "l1", total: 1 }] });
+    const labelArg = mocks.storyLabelGroupBy.mock.calls[0][0] as any;
+    expect(labelArg.where.story.AND).toContainEqual({ state: "todo" });
+  });
+
+  it("未登录时拒绝且不查询数据库", async () => {
+    mocks.currentSession.mockRejectedValue(new Error("unauthorized"));
+    await expect(
+      listStoryGroupsFn({ data: { archived: false, groupBy: "state" } }),
+    ).rejects.toMatchObject({ message: expect.stringContaining("unauthorized") });
+    expect(mocks.groupBy).not.toHaveBeenCalled();
+  });
+});