@allbluecn/web-app 0.18.2 → 0.19.0

package/src/server/serverFns/story/__tests__/create-story-internal.test.ts

@@ -18,14 +18,16 @@
 // 任务 6：从 story-crud.ts 提取的发号 + 建单事务段（createStoryInternal）单测。
 // 锁定两个关键不变量：① 发号 scope 是裸 projectId（非 bug:{projectId}）；
 // ② 独立项目 STORY- 前缀 / 普通项目 {displayId 清洗}- 前缀。
-import { describe, it, expect, vi } from "vitest";
+import { describe, it, expect, vi, beforeEach } from "vitest";
 import type { Prisma } from "@allbluecn/database";
 
 const mocks = vi.hoisted(() => ({
   projectFindUnique: vi.fn(),
   sequenceCounterUpsert: vi.fn(),
+  sequenceCounterUpdate: vi.fn(),
   storyCreate: vi.fn(),
   storyFindUnique: vi.fn(),
+  storyAggregate: vi.fn(),
   storyActivityCreate: vi.fn(),
 }));
 
@@ -36,6 +38,12 @@ vi.mock("@allbluecn/database", () => ({
 
 import { createStoryInternal, type CreateStoryInternalInput } from "../story-crud/create-story-internal";
 
+// 既有用例不关心存量 max：默认空项目（max=null→0），不触发自愈路径；
+// 自愈用例在各自 beforeEach 内覆写为具体 max
+beforeEach(() => {
+  mocks.storyAggregate.mockResolvedValue({ _max: { sequenceId: null } });
+});
+
 const DATE = new Date("2026-01-01T00:00:00Z");
 const userBrief = {
   id: "u1",
@@ -72,8 +80,12 @@ const storyRow = {
 function makeTx() {
   return {
     project: { findUnique: mocks.projectFindUnique },
-    sequenceCounter: { upsert: mocks.sequenceCounterUpsert },
-    story: { create: mocks.storyCreate, findUnique: mocks.storyFindUnique },
+    sequenceCounter: { upsert: mocks.sequenceCounterUpsert, update: mocks.sequenceCounterUpdate },
+    story: {
+      create: mocks.storyCreate,
+      findUnique: mocks.storyFindUnique,
+      aggregate: mocks.storyAggregate,
+    },
     storyActivity: { create: mocks.storyActivityCreate },
   } as unknown as Prisma.TransactionClient;
 }
@@ -209,3 +221,100 @@ describe("createStoryInternal", () => {
     expect(mocks.storyCreate).not.toHaveBeenCalled();
   });
 });
+
+describe("计数器自愈（发号以存量最大值为下界）", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("落后自愈：counter seq=1、存量 max=5 → 跳到 6 回写计数器，独立项目发 STORY-6", async () => {
+    mocks.projectFindUnique.mockResolvedValue({ id: "p1", name: "独立需求", displayId: "STORY" });
+    mocks.sequenceCounterUpsert.mockResolvedValue({ scope: "p1", seq: 1 });
+    mocks.storyAggregate.mockResolvedValue({ _max: { sequenceId: 5 } });
+    mocks.sequenceCounterUpdate.mockResolvedValue({ scope: "p1", seq: 6 });
+    mocks.storyCreate.mockResolvedValue({ ...storyRow, identifier: "STORY-6", sequenceId: 6 });
+    mocks.storyActivityCreate.mockResolvedValue({});
+
+    const out = await createStoryInternal(makeTx(), baseInput(), "u1");
+
+    // 存量 max 读取限定同一项目
+    expect(mocks.storyAggregate).toHaveBeenCalledWith({
+      where: { projectId: "p1" },
+      _max: { sequenceId: true },
+    });
+    // 自愈：落后时回写计数器为 max+1
+    expect(mocks.sequenceCounterUpdate).toHaveBeenCalledWith({
+      where: { scope: "p1" },
+      data: { seq: 6 },
+    });
+    expect(mocks.storyCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ sequenceId: 6, identifier: "STORY-6", projectId: "p1" }),
+      }),
+    );
+    expect(out.identifier).toBe("STORY-6");
+    expect(out.sequenceId).toBe(6);
+  });
+
+  it("落后自愈：常规项目前缀为 displayId 清洗大写（ab-c → ABC-6）", async () => {
+    mocks.projectFindUnique.mockResolvedValue({ id: "p1", name: "Alpha", displayId: "ab-c" });
+    mocks.sequenceCounterUpsert.mockResolvedValue({ scope: "p1", seq: 1 });
+    mocks.storyAggregate.mockResolvedValue({ _max: { sequenceId: 5 } });
+    mocks.sequenceCounterUpdate.mockResolvedValue({ scope: "p1", seq: 6 });
+    mocks.storyCreate.mockResolvedValue({ ...storyRow, identifier: "ABC-6", sequenceId: 6 });
+    mocks.storyActivityCreate.mockResolvedValue({});
+
+    const out = await createStoryInternal(makeTx(), baseInput(), "u1");
+
+    expect(mocks.sequenceCounterUpdate).toHaveBeenCalledWith({
+      where: { scope: "p1" },
+      data: { seq: 6 },
+    });
+    expect(mocks.storyCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ sequenceId: 6, identifier: "ABC-6" }),
+      }),
+    );
+    expect(out.identifier).toBe("ABC-6");
+  });
+
+  it("正常领先：counter seq=7、存量 max=3 → 不自愈不回写，发 7", async () => {
+    mocks.projectFindUnique.mockResolvedValue({ id: "p1", name: "独立需求", displayId: "STORY" });
+    mocks.sequenceCounterUpsert.mockResolvedValue({ scope: "p1", seq: 7 });
+    mocks.storyAggregate.mockResolvedValue({ _max: { sequenceId: 3 } });
+    mocks.storyCreate.mockResolvedValue({ ...storyRow, identifier: "STORY-7", sequenceId: 7 });
+    mocks.storyActivityCreate.mockResolvedValue({});
+
+    const out = await createStoryInternal(makeTx(), baseInput(), "u1");
+
+    expect(mocks.sequenceCounterUpdate).not.toHaveBeenCalled();
+    expect(mocks.storyCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ sequenceId: 7, identifier: "STORY-7" }),
+      }),
+    );
+    expect(out.sequenceId).toBe(7);
+  });
+
+  it("空项目：存量 max=null 视为 0 → counter seq=1 不自愈，发 1", async () => {
+    mocks.projectFindUnique.mockResolvedValue({ id: "p1", name: "独立需求", displayId: "STORY" });
+    mocks.sequenceCounterUpsert.mockResolvedValue({ scope: "p1", seq: 1 });
+    mocks.storyAggregate.mockResolvedValue({ _max: { sequenceId: null } });
+    mocks.storyCreate.mockResolvedValue(storyRow);
+    mocks.storyActivityCreate.mockResolvedValue({});
+
+    const out = await createStoryInternal(makeTx(), baseInput(), "u1");
+
+    expect(mocks.storyAggregate).toHaveBeenCalledWith({
+      where: { projectId: "p1" },
+      _max: { sequenceId: true },
+    });
+    expect(mocks.sequenceCounterUpdate).not.toHaveBeenCalled();
+    expect(mocks.storyCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ sequenceId: 1, identifier: "STORY-1" }),
+      }),
+    );
+    expect(out.sequenceId).toBe(1);
+  });
+});

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

@@ -51,6 +51,8 @@ const mocks = vi.hoisted(() => ({
   docFindMany: vi.fn(),
   linkFindMany: vi.fn(),
   linkCreateMany: vi.fn(),
+  designLinkFindMany: vi.fn(),
+  designLinkCreateMany: vi.fn(),
   extLinkFindMany: vi.fn(),
   extLinkCreateMany: vi.fn(),
   extLinkDeleteMany: vi.fn(),
@@ -66,6 +68,7 @@ vi.mock("@allbluecn/database", () => {
     knowledgeBase: { findMany: mocks.kbFindMany, findFirst: mocks.kbFindFirst },
     knowledgeDocument: { findMany: mocks.docFindMany },
     storyDocLink: { findMany: mocks.linkFindMany, createMany: mocks.linkCreateMany },
+    storyDesignLink: { findMany: mocks.designLinkFindMany, createMany: mocks.designLinkCreateMany },
     storyExternalLink: {
       findMany: mocks.extLinkFindMany,
       createMany: mocks.extLinkCreateMany,
@@ -88,6 +91,8 @@ import {
   linkDocsFn,
   getLinkedDocsFn,
   searchDesignsFn,
+  linkDesignsFn,
+  getLinkedDesignsFn,
 } from "../story-assoc";
 
 const SESSION = { user: { id: "u1" } };
@@ -213,23 +218,23 @@ describe("linkDocsFn 批量关联", () => {
 
 describe("searchDesignsFn 属主圈定", () => {
   it("where 圈定 userId + 未删除——非属主/已删除设计在 DB 层不可见", async () => {
-    mocks.designFindMany.mockResolvedValue([{ id: "d1", name: "我的设计" }]);
+    mocks.designFindMany.mockResolvedValue([{ id: "d1", name: "我的设计", icon: "file" }]);
     const result = await searchDesignsFn({ data: { query: "设计" } });
     const where = mocks.designFindMany.mock.calls[0][0].where;
     expect(where.userId).toBe("u1"); // 非属主设计被过滤（跨用户越权读封堵）
     expect(where.isDeleted).toBe(false); // 已删除设计不进 mention 候选
-    expect(result).toEqual([{ id: "d1", title: "我的设计" }]);
+    expect(result).toEqual([{ id: "d1", title: "我的设计", icon: "file" }]);
   });
 
   it("属主设计正常返回，保留 name 模糊匹配与 take 10", async () => {
     mocks.designFindMany.mockResolvedValue([
-      { id: "d1", name: "登录页" },
-      { id: "d2", name: "落地页" },
+      { id: "d1", name: "登录页", icon: "file" },
+      { id: "d2", name: "落地页", icon: "pen" },
     ]);
     const result = await searchDesignsFn({ data: { query: "页" } });
     expect(result).toEqual([
-      { id: "d1", title: "登录页" },
-      { id: "d2", title: "落地页" },
+      { id: "d1", title: "登录页", icon: "file" },
+      { id: "d2", title: "落地页", icon: "pen" },
     ]);
     const args = mocks.designFindMany.mock.calls[0][0];
     expect(args.where.name).toEqual({ contains: "页", mode: "insensitive" });
@@ -237,6 +242,72 @@ describe("searchDesignsFn 属主圈定", () => {
   });
 });
 
+describe("linkDesignsFn 批量关联设计", () => {
+  it("批量建链、已关联跳过、越界 id 归 failed", async () => {
+    mocks.storyFindUnique.mockResolvedValue(STORY_WITH_PROJECT);
+    // d1 本人有效设计；d2 非本人（越界）；d3 不存在
+    mocks.designFindMany.mockResolvedValue([{ id: "d1" }]);
+    mocks.designLinkFindMany.mockResolvedValue([{ designId: "d1" }]); // d1 已关联
+    const result = await linkDesignsFn({ data: { storyId: "s1", designIds: ["d1", "d2", "d3"] } });
+    expect(result.linked).toEqual([]);
+    expect(result.failed).toEqual([
+      { designId: "d2", reason: "outOfScope" },
+      { designId: "d3", reason: "outOfScope" },
+    ]);
+    expect(mocks.linkCreateMany).not.toHaveBeenCalled(); // 无新增
+    expect(mocks.activityCreate).not.toHaveBeenCalled(); // 零关联不记活动
+  });
+
+  it("SEC-03：非项目成员关联被拒且零写入", async () => {
+    mocks.storyFindUnique.mockResolvedValue(STORY_WITH_PROJECT);
+    mocks.memberFindUnique.mockResolvedValue(null); // 无成员关系
+    await expect(
+      linkDesignsFn({ data: { storyId: "s1", designIds: ["d1"] } }),
+    ).rejects.toThrow("无权限操作该项目的需求");
+    expect(mocks.designFindMany).not.toHaveBeenCalled();
+    expect(mocks.linkCreateMany).not.toHaveBeenCalled();
+  });
+
+  it("新增项走 createMany skipDuplicates 并记 prd_linked 活动（value=数量）", async () => {
+    mocks.storyFindUnique.mockResolvedValue(STORY_WITH_PROJECT);
+    mocks.designFindMany.mockResolvedValue([{ id: "d1" }, { id: "d2" }]);
+    mocks.designLinkFindMany.mockResolvedValue([]);
+    mocks.activityCreate.mockResolvedValue({
+      id: "act-prd",
+      action: "prd_linked",
+      field: null,
+      oldValue: null,
+      newValue: "2",
+      isAI: false,
+      createdAt: new Date("2026-10-11T00:00:00Z"),
+      user: { id: "u1", username: "u1", email: "e", avatarConfig: null, bgShape: null, bgColor: null },
+    });
+    const result = await linkDesignsFn({ data: { storyId: "s1", designIds: ["d1", "d2"] } });
+    expect(result.linked).toEqual(["d1", "d2"]);
+    expect(mocks.designLinkCreateMany.mock.calls[0][0].data).toEqual([
+      { storyId: "s1", designId: "d1" },
+      { storyId: "s1", designId: "d2" },
+    ]);
+    expect(mocks.activityCreate.mock.calls[0][0].data).toMatchObject({
+      action: "prd_linked",
+      newValue: "2",
+    });
+    expect(result.activity).toMatchObject({ action: "prd_linked", newValue: "2" });
+  });
+});
+
+describe("getLinkedDesignsFn 返回设计元数据", () => {
+  it("where 过滤已删除设计，返回对齐 DesignBrief 的字段", async () => {
+    mocks.designLinkFindMany.mockResolvedValue([
+      { design: { id: "d1", name: "PRD 文档", icon: "file" } },
+    ]);
+    const result = await getLinkedDesignsFn({ data: { storyId: "s1" } });
+    expect(result).toEqual([{ id: "d1", title: "PRD 文档", icon: "file" }]);
+    const where = mocks.designLinkFindMany.mock.calls[0][0].where;
+    expect(where).toMatchObject({ storyId: "s1", design: { isDeleted: false } });
+  });
+});
+
 describe("getLinkedDocsFn 扩展返回 KB 元数据", () => {
   it("返回对齐 DocBrief 的字段", async () => {
     mocks.linkFindMany.mockResolvedValue([

package/src/server/serverFns/story/__tests__/story-crud-date-key.test.ts

@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (C) 2026 AllBlue Contributors
+
+// updateStoryFn 日期变化检测的接线级回归钉（date-key 场景，task-8 根因 B）：
+// 历史数据旧值带晚间时刻（2026-10-01T19:47:18Z）时，客户端 UTC 日键是
+// "2026-10-01"；+1 天改期 payload = "2026-10-02" 必须被判为「有变化」走
+// UPDATE 分支。若旧值键误用服务器本地日键（+08 会切到 "2026-10-02"），
+// 本次改期被误判「无变化」→ 200 但静默丢写（UI 乐观态与 DB 分叉）。
+// prisma 为 mock：承重断言是 update 是否被调与 activity 的日键内容，
+// OR/事务的 DB 命中语义不在行使范围（同 story-gantt-deps.test.ts 惯例）。
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("@tanstack/react-start", () => ({
+  createServerFn: (config: unknown) => {
+    const api: {
+      _validator: unknown;
+      validator(schema: unknown): unknown;
+      handler(
+        fn: (args: { data: unknown }) => unknown,
+      ): (args: { data: unknown }) => Promise<unknown>;
+    } = {
+      _validator: undefined,
+      validator(schema: unknown) {
+        this._validator = schema;
+        return this;
+      },
+      handler(fn: (args: { data: unknown }) => unknown) {
+        const validate = () => this._validator;
+        return async (args: { data: unknown }) => {
+          let data = args?.data;
+          const schema = validate();
+          if (schema && data !== undefined) {
+            const parse = (schema as { parse?: (v: unknown) => unknown }).parse;
+            if (typeof parse === "function") data = parse(data);
+          }
+          return fn({ data });
+        };
+      },
+    };
+    return api;
+  },
+}));
+
+vi.mock("@tanstack/react-start/server", () => ({
+  getRequest: () => ({}),
+}));
+
+const mocks = vi.hoisted(() => ({
+  storyFindUnique: vi.fn(),
+  storyUpdate: vi.fn(),
+  memberFindUnique: vi.fn(),
+  activityCreate: vi.fn(),
+  currentSession: vi.fn(),
+  withCollabGuard: vi.fn(),
+}));
+
+vi.mock("@allbluecn/database/get-prisma", () => {
+  const tx = {
+    story: { findUnique: mocks.storyFindUnique, update: mocks.storyUpdate },
+    storyActivity: { create: mocks.activityCreate },
+  };
+  return {
+    getPrisma: async () => ({
+      projectMember: { findUnique: mocks.memberFindUnique },
+      $transaction: async (cb: (t: typeof tx) => unknown) => cb(tx),
+    }),
+  };
+});
+
+vi.mock("@allbluecn/database", () => ({ prisma: {}, Prisma: {} }));
+vi.mock("@allbluecn/collab-core/rooms", () => ({
+  buildRoomName: () => "entity-story:s1",
+}));
+vi.mock("@/server/auth-helpers", () => ({ requireAuth: mocks.currentSession }));
+vi.mock("@/server/collab/write-guard", () => ({
+  withCollabGuard: mocks.withCollabGuard,
+}));
+vi.mock("@/server/collab/touch-snapshot", () => ({
+  touchCollabSnapshot: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock("@/server/team-access", () => ({
+  isUserInTeam: vi.fn().mockResolvedValue(true),
+}));
+
+import { updateStoryFn } from "../story-crud";
+
+/** 旧值：UTC 晚间 19:47 时刻（+08 本地日键会切到次日——正是被禁的错位口径） */
+const EVENING_LEGACY_START = new Date("2026-10-01T19:47:18.000Z");
+
+function existingStory() {
+  return {
+    id: "s1",
+    identifier: "STORY-1",
+    name: "甘特改期回归钉",
+    description: null,
+    state: "todo",
+    priority: "medium",
+    archived: false,
+    startDate: EVENING_LEGACY_START,
+    targetDate: null,
+    boardOrder: 0,
+    sequenceId: 1,
+    projectId: "p1",
+    parentId: null,
+    parent: null,
+    assignee: null,
+    createdBy: {
+      id: "u1",
+      username: "u1",
+      email: "u1@example.com",
+      avatarConfig: null,
+      bgShape: null,
+      bgColor: null,
+    },
+    updatedBy: null,
+    labels: [],
+    iteration: null,
+    createdAt: new Date("2026-10-01T00:00:00.000Z"),
+    updatedAt: new Date("2026-10-01T00:00:00.000Z"),
+  };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.currentSession.mockResolvedValue({ user: { id: "u1" } });
+  mocks.memberFindUnique.mockResolvedValue({ status: "active" });
+  // 非 forwarded 门卫裁决 → 直写分支（Y 面直写 = 旁路语义，不 touch 快照）
+  mocks.withCollabGuard.mockResolvedValue({ kind: "pass-through", reason: "no-snapshot" });
+  mocks.storyFindUnique.mockResolvedValue(existingStory());
+  mocks.storyUpdate.mockImplementation(({ where }: { where: { id: string } }) =>
+    Promise.resolve({ ...existingStory(), id: where.id }),
+  );
+  mocks.activityCreate.mockResolvedValue({
+    id: "act1",
+    isAI: false,
+    createdAt: new Date("2026-10-01T00:00:00.000Z"),
+    user: {
+      id: "u1",
+      username: "u1",
+      email: "u1@example.com",
+      avatarConfig: null,
+      bgShape: null,
+      bgColor: null,
+    },
+  });
+});
+
+describe("updateStoryFn 日期变化检测（date-key 接线级回归钉）", () => {
+  it("晚间时刻旧值 +1 天 payload → 走 UPDATE 分支（update 被调 + 日键活动）", async () => {
+    await updateStoryFn({ data: { storyId: "s1", startDate: "2026-10-02" } });
+
+    expect(mocks.storyUpdate).toHaveBeenCalledTimes(1);
+    expect(mocks.storyUpdate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: { id: "s1" },
+        data: expect.objectContaining({
+          // 新值经 new Date("2026-10-02")（UTC 零点）落库
+          startDate: new Date("2026-10-02"),
+        }),
+      }),
+    );
+    // 活动：旧值键 = UTC 日切片 "2026-10-01"（非本地日键 "2026-10-02"）
+    expect(mocks.activityCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          action: "startDate_changed",
+          oldValue: "2026-10-01",
+          newValue: "2026-10-02",
+        }),
+      }),
+    );
+  });
+
+  it("同 UTC 日键（晚间旧值 + 当日 payload）→ 判无变化：不写 startDate、不写活动", async () => {
+    // 回归补面：payload 日键与旧值 UTC 日键相同时不得触发 startDate 写入——
+    // 否则每次非日期编辑都会重写日期列（update 本身恒发生：updatedBy 连接）
+    await updateStoryFn({ data: { storyId: "s1", startDate: "2026-10-01" } });
+
+    expect(mocks.storyUpdate).toHaveBeenCalledTimes(1);
+    expect(mocks.storyUpdate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.not.objectContaining({ startDate: expect.anything() }),
+      }),
+    );
+    expect(mocks.activityCreate).not.toHaveBeenCalled();
+  });
+});

package/src/server/serverFns/story/__tests__/story-gantt-deps.test.ts

@@ -0,0 +1,163 @@
+// 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/>.
+
+// 甘特图依赖箭头数据源：listStoryDependenciesFn（列表/聚合场景，走 resolveStoryScopeProjectIds）
+
+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(() => ({
+  currentSession: vi.fn(),
+  getPrisma: vi.fn(),
+  depFindMany: vi.fn(),
+  resolveScopeProjectIds: vi.fn(),
+}));
+
+vi.mock("@allbluecn/database/get-prisma", () => ({
+  getPrisma: mocks.getPrisma,
+}));
+
+vi.mock("@/server/auth-helpers", () => ({
+  requireAuth: mocks.currentSession,
+}));
+
+vi.mock("@/server/builtin-project", () => ({
+  resolveStoryScopeProjectIds: mocks.resolveScopeProjectIds,
+}));
+
+import { listStoryDependenciesFn } from "../story-dependencies";
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.currentSession.mockResolvedValue({ user: { id: "u1" } });
+  mocks.getPrisma.mockResolvedValue({
+    storyDependency: { findMany: mocks.depFindMany },
+  });
+  mocks.depFindMany.mockResolvedValue([]);
+  mocks.resolveScopeProjectIds.mockResolvedValue(["p1"]);
+});
+
+describe("listStoryDependenciesFn", () => {
+  it("① 无 session 抛鉴权错，且不触达 scope 聚合与依赖查询（首行鉴权）", async () => {
+    mocks.currentSession.mockRejectedValue(new Error("未登录"));
+    await expect(listStoryDependenciesFn({ data: { projectId: "p1" } })).rejects.toThrow(
+      "未登录",
+    );
+    expect(mocks.resolveScopeProjectIds).not.toHaveBeenCalled();
+    expect(mocks.depFindMany).not.toHaveBeenCalled();
+  });
+
+  it("② projectId 缺省走 resolveStoryScopeProjectIds 聚合，where 断言 OR 双向 scope（R-5：source/target 任一端 in + archived:false）", async () => {
+    mocks.resolveScopeProjectIds.mockResolvedValue(["p1", "p2", "p3"]);
+    await listStoryDependenciesFn({ data: {} });
+    expect(mocks.resolveScopeProjectIds).toHaveBeenCalledWith(undefined, "u1");
+    expect(mocks.depFindMany).toHaveBeenCalledTimes(1);
+    expect(mocks.depFindMany).toHaveBeenCalledWith({
+      where: {
+        OR: [
+          { source: { projectId: { in: ["p1", "p2", "p3"] }, archived: false } },
+          { target: { projectId: { in: ["p1", "p2", "p3"] }, archived: false } },
+        ],
+      },
+      select: { sourceId: true, targetId: true, type: true },
+    });
+  });
+
+  it("②b 显式 projectId 透传给聚合函数（单项目场景不绕过聚合入口）", async () => {
+    mocks.resolveScopeProjectIds.mockResolvedValue(["p9"]);
+    await listStoryDependenciesFn({ data: { projectId: "p9" } });
+    expect(mocks.resolveScopeProjectIds).toHaveBeenCalledWith("p9", "u1");
+    expect(mocks.depFindMany).toHaveBeenCalledWith({
+      where: {
+        OR: [
+          { source: { projectId: { in: ["p9"] }, archived: false } },
+          { target: { projectId: { in: ["p9"] }, archived: false } },
+        ],
+      },
+      select: { sourceId: true, targetId: true, type: true },
+    });
+  });
+
+  it("④ where 含 target 分支（R-5 双向口径：source/target 双分支同 scope 同 archived）", async () => {
+    mocks.resolveScopeProjectIds.mockResolvedValue(["p1"]);
+    // 注：prisma 为 mock，OR 的 DB 命中语义未被行使；「target 在 scope 也命中」
+    // 的承重断言是下方 where 深度相等（target 分支存在且口径与 source 分支一致），
+    // 首个断言仅证明返回链路对 mock 边原样透传
+    mocks.depFindMany.mockResolvedValue([
+      { sourceId: "s-out", targetId: "t-in", type: "BLOCKS" },
+    ]);
+    const res = await listStoryDependenciesFn({ data: { projectId: "p1" } });
+    expect(res.edges).toEqual([
+      { sourceId: "s-out", targetId: "t-in", type: "BLOCKS" },
+    ]);
+    const where = mocks.depFindMany.mock.calls[0]![0]!.where;
+    expect(where.OR).toEqual([
+      { source: { projectId: { in: ["p1"] }, archived: false } },
+      { target: { projectId: { in: ["p1"] }, archived: false } },
+    ]);
+  });
+
+  it("③ 返回 shape { edges: [{sourceId,targetId,type}] }，type 仅含三种合法字面量", async () => {
+    mocks.depFindMany.mockResolvedValue([
+      { sourceId: "a", targetId: "b", type: "BLOCKS" },
+      { sourceId: "c", targetId: "d", type: "STARTS_BEFORE" },
+      { sourceId: "e", targetId: "f", type: "FINISHES_BEFORE" },
+    ]);
+    const res = await listStoryDependenciesFn({ data: {} });
+    expect(res).toEqual({
+      edges: [
+        { sourceId: "a", targetId: "b", type: "BLOCKS" },
+        { sourceId: "c", targetId: "d", type: "STARTS_BEFORE" },
+        { sourceId: "e", targetId: "f", type: "FINISHES_BEFORE" },
+      ],
+    });
+    for (const edge of res.edges) {
+      expect(["BLOCKS", "STARTS_BEFORE", "FINISHES_BEFORE"]).toContain(edge.type);
+    }
+  });
+
+  it("③b 无依赖边时返回空数组", async () => {
+    const res = await listStoryDependenciesFn({ data: {} });
+    expect(res).toEqual({ edges: [] });
+  });
+});

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

@@ -51,6 +51,7 @@ const mocks = vi.hoisted(() => ({
   storyLabelGroupBy: vi.fn(),
   currentSession: vi.fn(),
   projectFindFirst: vi.fn(),
+  projectMemberFindMany: vi.fn(),
 }));
 
 vi.mock("@allbluecn/database", () => ({
@@ -58,6 +59,7 @@ vi.mock("@allbluecn/database", () => ({
     story: { findMany: mocks.findMany, count: mocks.count, groupBy: mocks.groupBy },
     storyLabel: { groupBy: mocks.storyLabelGroupBy },
     project: { findFirst: mocks.projectFindFirst },
+    projectMember: { findMany: mocks.projectMemberFindMany },
   },
   Prisma: {},
 }));
@@ -72,6 +74,7 @@ describe("listStoriesInGroupFn", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mocks.currentSession.mockResolvedValue({ user: { id: "u1" } });
+    mocks.projectMemberFindMany.mockResolvedValue([]);
     mocks.projectFindFirst.mockResolvedValue({ id: "proj-independent-1" });
   });
 
@@ -173,6 +176,7 @@ describe("listStoryGroupsFn", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mocks.currentSession.mockResolvedValue({ user: { id: "u1" } });
+    mocks.projectMemberFindMany.mockResolvedValue([]);
     mocks.projectFindFirst.mockResolvedValue({ id: "proj-independent-1" });
   });