@allbluecn/web-app 0.4.22 → 0.5.1

package/src/server/serverFns/project.ts

@@ -573,3 +573,46 @@ export const ensureBuiltinProjectFn = createServerFn({ method: "GET" }).handler(
   const projectId = await ensureBuiltinIndependentProject(userId);
   return { id: projectId, name: BUILTIN_INDEPENDENT_NAME, displayId: BUILTIN_INDEPENDENT_DISPLAY_ID, icon: BUILTIN_INDEPENDENT_ICON };
 });
+
+export const listProjectKbsFn = createServerFn({ method: "GET" })
+  .validator(z.object({ projectId: z.string() }))
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    await requireAuth(request);
+    const rows = await prisma.projectKnowledgeBase.findMany({
+      where: { projectId: data.projectId },
+      select: {
+        kb: { select: { id: true, name: true, icon: true, visibility: true } },
+      },
+      orderBy: { createdAt: "asc" },
+    });
+    return rows.map((r) => r.kb);
+  });
+
+export const setProjectKbsFn = createServerFn({ method: "POST" })
+  .validator(z.object({ projectId: z.string(), kbIds: z.array(z.string()) }))
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    await requireAuth(request);
+    if (data.kbIds.length > 0) {
+      const valid = await prisma.knowledgeBase.findMany({
+        where: { id: { in: data.kbIds }, visibility: "team", isDeleted: false },
+        select: { id: true },
+      });
+      if (valid.length !== data.kbIds.length) {
+        throw new Error("仅允许团队可见的知识库关联项目");
+      }
+    }
+    await prisma.$transaction(async (tx) => {
+      await tx.projectKnowledgeBase.deleteMany({
+        where: { projectId: data.projectId, kbId: { notIn: data.kbIds } },
+      });
+      if (data.kbIds.length > 0) {
+        await tx.projectKnowledgeBase.createMany({
+          data: data.kbIds.map((kbId) => ({ projectId: data.projectId, kbId })),
+          skipDuplicates: true,
+        });
+      }
+    });
+    return { ok: true };
+  });

package/src/server/serverFns/story/__tests__/kb-scope.test.ts

@@ -0,0 +1,56 @@
+// 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 } from "vitest";
+import { isIndependentProject, buildKbScopeWhere } from "../kb-scope";
+
+describe("kb-scope 可用范围判定", () => {
+  it("独立需求项目（displayId=STORY）识别", () => {
+    expect(isIndependentProject("STORY")).toBe(true);
+    expect(isIndependentProject("story")).toBe(false);
+    expect(isIndependentProject(null)).toBe(false);
+    expect(isIndependentProject("PROJ")).toBe(false);
+  });
+
+  it("普通项目：general ∪ 项目关联（不含他人 private/team）", () => {
+    const where = buildKbScopeWhere({
+      projectId: "p1",
+      projectDisplayId: "PROJ",
+      userId: "u1",
+    });
+    expect(where).toEqual({
+      OR: [
+        { visibility: "general" },
+        { projectLinks: { some: { projectId: "p1" } } },
+      ],
+    });
+  });
+
+  it("独立需求项目：自己的全部 ∪ 他人 team/general", () => {
+    const where = buildKbScopeWhere({
+      projectId: "p2",
+      projectDisplayId: "STORY",
+      userId: "u1",
+    });
+    expect(where).toEqual({
+      OR: [
+        { userId: "u1" },
+        { visibility: { in: ["team", "general"] } },
+      ],
+    });
+  });
+});

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

@@ -0,0 +1,222 @@
+// 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(() => ({
+  storyFindUnique: vi.fn(),
+  kbFindMany: vi.fn(),
+  kbFindFirst: vi.fn(),
+  docFindMany: vi.fn(),
+  linkFindMany: vi.fn(),
+  linkCreateMany: vi.fn(),
+  extLinkFindMany: vi.fn(),
+  extLinkCreateMany: vi.fn(),
+  extLinkDeleteMany: vi.fn(),
+  activityCreate: vi.fn(),
+  currentSession: vi.fn(),
+}));
+
+vi.mock("@allbluecn/database", () => {
+  const prisma = {
+    story: { findUnique: mocks.storyFindUnique },
+    knowledgeBase: { findMany: mocks.kbFindMany, findFirst: mocks.kbFindFirst },
+    knowledgeDocument: { findMany: mocks.docFindMany },
+    storyDocLink: { findMany: mocks.linkFindMany, createMany: mocks.linkCreateMany },
+    storyExternalLink: {
+      findMany: mocks.extLinkFindMany,
+      createMany: mocks.extLinkCreateMany,
+      deleteMany: mocks.extLinkDeleteMany,
+    },
+    storyActivity: { create: mocks.activityCreate },
+  };
+  return { prisma, Prisma: {} };
+});
+
+vi.mock("@/server/auth-helpers", () => ({
+  requireAuth: mocks.currentSession,
+}));
+
+import {
+  listStoryAvailableKbsFn,
+  searchKbDocsFn,
+  linkDocsFn,
+  getLinkedDocsFn,
+} from "../story-assoc";
+
+const SESSION = { user: { id: "u1" } };
+const STORY_WITH_PROJECT = {
+  project: { id: "p1", displayId: "PROJ" },
+};
+const STORY_INDEPENDENT = {
+  project: { id: "p2", displayId: "STORY" },
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.currentSession.mockResolvedValue(SESSION);
+  mocks.storyFindUnique.mockResolvedValue(STORY_WITH_PROJECT);
+  mocks.extLinkFindMany.mockResolvedValue([]);
+  mocks.extLinkCreateMany.mockResolvedValue({ count: 0 });
+  mocks.extLinkDeleteMany.mockResolvedValue({ count: 0 });
+  mocks.activityCreate.mockResolvedValue({
+    id: "act1",
+    action: "kb_linked",
+    field: null,
+    oldValue: null,
+    newValue: "1",
+    isAI: false,
+    createdAt: new Date("2026-08-31T00:00:00Z"),
+    user: { id: "u1", username: "u1", email: "e", avatarConfig: null, bgShape: null, bgColor: null },
+  });
+});
+
+describe("listStoryAvailableKbsFn", () => {
+  it("普通项目：按 scope 查询返回 KB 列表", async () => {
+    mocks.kbFindMany.mockResolvedValue([
+      { id: "kb1", name: "团队库", icon: "notebook", visibility: "team" },
+      { id: "kb2", name: "通用库", icon: "book", visibility: "general" },
+    ]);
+    const result = await listStoryAvailableKbsFn({ data: { storyId: "s1" } });
+    expect(result).toHaveLength(2);
+    expect(result[0]).toMatchObject({ id: "kb1", name: "团队库" });
+    const where = mocks.kbFindMany.mock.calls[0][0].where;
+    expect(where.AND).toBeDefined(); // AND: [scope, { isDeleted: false }]
+  });
+
+  it("需求不存在抛错", async () => {
+    mocks.storyFindUnique.mockResolvedValue(null);
+    await expect(listStoryAvailableKbsFn({ data: { storyId: "nope" } })).rejects.toMatchObject({
+      message: expect.stringContaining("需求不存在"),
+    });
+  });
+});
+
+describe("searchKbDocsFn 两态", () => {
+  it("指定 kbId：全量树查询（take 500，含 parentId/type/kb 元数据）", async () => {
+    mocks.storyFindUnique.mockResolvedValue(STORY_WITH_PROJECT);
+    mocks.kbFindFirst.mockResolvedValue({ id: "kb1" }); // 范围内
+    mocks.docFindMany.mockResolvedValue([
+      { id: "d1", title: "页1", parentId: null, kb: { id: "kb1", name: "团队库", icon: "notebook" }, icon: "doc" },
+    ]);
+    const result = await searchKbDocsFn({ data: { storyId: "s1", kbId: "kb1", query: "" } });
+    expect(result.items[0]).toMatchObject({ id: "d1", kbName: "团队库" });
+    expect(result.nextCursor).toBeNull();
+    const args = mocks.docFindMany.mock.calls[0][0];
+    expect(args.take).toBe(500);
+    expect(args.where.kbId).toBe("kb1");
+  });
+
+  it("指定范围外 kbId：抛越界错误", async () => {
+    mocks.storyFindUnique.mockResolvedValue(STORY_WITH_PROJECT);
+    mocks.kbFindFirst.mockResolvedValue(null); // 不在 scope 内
+    await expect(
+      searchKbDocsFn({ data: { storyId: "s1", kbId: "kbX", query: "" } }),
+    ).rejects.toMatchObject({ message: expect.stringContaining("不在可用范围") });
+  });
+
+  it("全部模式：平铺分页（take 21 判 hasMore）", async () => {
+    mocks.storyFindUnique.mockResolvedValue(STORY_WITH_PROJECT);
+    mocks.docFindMany.mockResolvedValue([]);
+    await searchKbDocsFn({ data: { storyId: "s1", query: "关键词" } });
+    const args = mocks.docFindMany.mock.calls[0][0];
+    expect(args.take).toBe(21);
+    expect(args.where.kb).toBeDefined(); // scope 下推到 kb 关系
+  });
+});
+
+describe("linkDocsFn 批量关联", () => {
+  it("合法项批量建链、已存在跳过、越界归 failed", async () => {
+    mocks.storyFindUnique.mockResolvedValue(STORY_WITH_PROJECT);
+    mocks.docFindMany.mockResolvedValue([
+      { id: "d1", kbId: "kb1" }, // 合法
+      { id: "d2", kbId: "kb9" }, // 越界（kb9 不在 scope）
+    ]);
+    mocks.kbFindMany.mockResolvedValue([{ id: "kb1" }, { id: "kb2" }]); // scope 内 KB 集合
+    mocks.linkFindMany.mockResolvedValue([{ docId: "d1" }]); // d1 已关联
+    mocks.linkCreateMany.mockResolvedValue({ count: 0 });
+
+    const result = await linkDocsFn({ data: { storyId: "s1", docIds: ["d1", "d2"] } });
+    expect(result.linked).toEqual([]);
+    expect(result.skipped).toEqual(["d1"]);
+    expect(result.failed).toEqual([{ docId: "d2", reason: "outOfScope" }]);
+    expect(mocks.linkCreateMany).not.toHaveBeenCalled(); // 无新增
+  });
+
+  it("新增项走 createMany skipDuplicates", async () => {
+    mocks.docFindMany.mockResolvedValue([{ id: "d3", kbId: "kb1" }]);
+    mocks.kbFindMany.mockResolvedValue([{ id: "kb1" }]);
+    mocks.linkFindMany.mockResolvedValue([]);
+    mocks.linkCreateMany.mockResolvedValue({ count: 1 });
+    const result = await linkDocsFn({ data: { storyId: "s1", docIds: ["d3"] } });
+    expect(result.linked).toEqual(["d3"]);
+    expect(mocks.linkCreateMany.mock.calls[0][0].data).toEqual([{ storyId: "s1", docId: "d3" }]);
+  });
+});
+
+describe("getLinkedDocsFn 扩展返回 KB 元数据", () => {
+  it("返回对齐 DocBrief 的字段", async () => {
+    mocks.linkFindMany.mockResolvedValue([
+      {
+        doc: {
+          id: "d1",
+          title: "页1",
+          kb: { id: "kb1", name: "团队库", icon: "notebook" },
+          icon: "doc",
+          parentId: null,
+        },
+      },
+    ]);
+    const result = await getLinkedDocsFn({ data: { storyId: "s1" } });
+    expect(result[0]).toEqual({
+      id: "d1",
+      title: "页1",
+      kbId: "kb1",
+      kbName: "团队库",
+      kbIcon: "notebook",
+      docIcon: "doc",
+      parentId: null,
+    });
+  });
+});

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

@@ -0,0 +1,265 @@
+// 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(() => ({
+  depFindMany: vi.fn(),
+  depFindFirst: vi.fn(),
+  depCreate: vi.fn(),
+  depDelete: vi.fn(),
+  storyFindMany: vi.fn(),
+  activityCreate: vi.fn(),
+  currentSession: vi.fn(),
+}));
+
+vi.mock("@allbluecn/database", () => {
+  const prisma = {
+    storyDependency: {
+      findMany: mocks.depFindMany,
+      findFirst: mocks.depFindFirst,
+      create: mocks.depCreate,
+      delete: mocks.depDelete,
+    },
+    story: { findMany: mocks.storyFindMany },
+    storyActivity: { create: mocks.activityCreate },
+  };
+  return { prisma, Prisma: {} };
+});
+
+vi.mock("@/server/auth-helpers", () => ({
+  requireAuth: mocks.currentSession,
+}));
+
+import {
+  addDependenciesFn,
+  removeDependencyFn,
+  getDependenciesFn,
+} from "../story-dependencies";
+
+const STORY_ROW = (id: string) => ({
+  id,
+  identifier: `PROJ-${id}`,
+  sequenceId: 1,
+  name: `story ${id}`,
+  description: null,
+  state: "backlog",
+  priority: "medium",
+  archived: false,
+  startDate: null,
+  targetDate: null,
+  boardOrder: 0,
+  projectId: "p1",
+  parentId: null,
+  parent: null,
+  assignee: null,
+  createdBy: { id: "u1", username: "u1", email: "e", avatarConfig: null, bgShape: null, bgColor: null },
+  updatedBy: null,
+  labels: [],
+  createdAt: new Date("2026-01-01T00:00:00Z"),
+  updatedAt: new Date("2026-01-01T00:00:00Z"),
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.currentSession.mockResolvedValue({ user: { id: "u1" } });
+  // 默认 DB 无既有依赖边（handler 开头一次性取全边建邻接表，必须返回数组）
+  mocks.depFindMany.mockResolvedValue([]);
+  // 活动写入段：端点 label 查询 + create 返回（含 select 字段）
+  mocks.storyFindMany.mockResolvedValue([
+    { id: "a", identifier: "A-1", name: "story a" },
+    { id: "b", identifier: "B-1", name: "story b" },
+  ]);
+  mocks.activityCreate.mockImplementation(({ data }: any) =>
+    Promise.resolve({
+      id: `act-${data.storyId}`,
+      action: "dependency_added",
+      field: null,
+      oldValue: null,
+      newValue: data.newValue,
+      isAI: false,
+      createdAt: new Date("2026-08-31T00:00:00Z"),
+      storyId: data.storyId,
+      user: { id: "u1", username: "u1", email: "e", avatarConfig: null, bgShape: null, bgColor: null },
+    }),
+  );
+});
+
+describe("addDependenciesFn", () => {
+  it("自依赖拒绝并计入 failed", async () => {
+    const res = await addDependenciesFn({
+      data: { items: [{ sourceId: "a", targetId: "a", type: "BLOCKS" }] },
+    });
+    expect(res.created).toHaveLength(0);
+    expect(res.failed[0].targetId).toBe("a");
+    expect(mocks.depCreate).not.toHaveBeenCalled();
+  });
+
+  it("pair 级判重：同 pair 任意方向任意类型已存在则拒绝", async () => {
+    mocks.depFindFirst.mockResolvedValue({ id: "d0" }); // 命中已有边
+    const res = await addDependenciesFn({
+      data: {
+        items: [
+          { sourceId: "a", targetId: "b", type: "STARTS_BEFORE" }, // 正向查 (a,b,*)
+        ],
+      },
+    });
+    expect(res.failed[0].targetId).toBe("b");
+    expect(mocks.depCreate).not.toHaveBeenCalled();
+    // 守住双向查询：实现退化为单方向（漏掉反向 OR）时本断言必须失败
+    expect(mocks.depFindFirst).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          OR: expect.arrayContaining([
+            { sourceId: "a", targetId: "b" },
+            { sourceId: "b", targetId: "a" },
+          ]),
+        }),
+      }),
+    );
+  });
+
+  it("循环依赖拒绝：target 可达 source（跨类型混合环）", async () => {
+    mocks.depFindFirst.mockResolvedValue(null); // 无重复
+    // 图：b -> a 已存在（b BLOCKS a）；插入 a -> b 成环
+    // handler 开头一次性取全边，返回全图唯一一条边
+    mocks.depFindMany.mockResolvedValue([{ sourceId: "b", targetId: "a" }]);
+    const res = await addDependenciesFn({
+      data: { items: [{ sourceId: "a", targetId: "b", type: "BLOCKS" }] },
+    });
+    expect(res.failed[0].targetId).toBe("b");
+    expect(mocks.depCreate).not.toHaveBeenCalled();
+  });
+
+  it("批内互指环：第二条被逐条拦截", async () => {
+    mocks.depFindFirst.mockResolvedValue(null);
+    mocks.depFindMany.mockResolvedValue([]);
+    mocks.depCreate.mockImplementation(({ data }: any) =>
+      Promise.resolve({ id: `d-${data.sourceId}-${data.targetId}`, ...data }),
+    );
+    // 第一条插入 a->b 后，第二条 b->a 的环检测需看到它：
+    // 实现必须把本批已插入边并入检测图（depFindMany 之后的内存集合）
+    // 这里 mock depFindMany 每次返回空（DB 无边），实现需自维护本批边
+    const res = await addDependenciesFn({
+      data: {
+        items: [
+          { sourceId: "a", targetId: "b", type: "BLOCKS" },
+          { sourceId: "b", targetId: "a", type: "STARTS_BEFORE" },
+        ],
+      },
+    });
+    expect(res.created).toHaveLength(1);
+    expect(res.failed[0].targetId).toBe("a");
+  });
+
+  it("合法边创建成功", async () => {
+    mocks.depFindFirst.mockResolvedValue(null);
+    mocks.depFindMany.mockResolvedValue([]);
+    mocks.depCreate.mockResolvedValue({ id: "d1" });
+    const res = await addDependenciesFn({
+      data: { items: [{ sourceId: "a", targetId: "b", type: "BLOCKS" }] },
+    });
+    expect(res.created).toHaveLength(1);
+    expect(mocks.depCreate).toHaveBeenCalledOnce();
+    // 性能契约：环检测的图只查一次（取全边），且不带任何 where 过滤
+    expect(mocks.depFindMany).toHaveBeenCalledTimes(1);
+    expect(mocks.depFindMany).toHaveBeenCalledWith({
+      select: { sourceId: true, targetId: true },
+    });
+    // 活动契约：依赖两端各记一条「添加依赖关系」，newValue 为对方描述
+    expect(res.activities).toHaveLength(2);
+    expect(res.activities.map((x) => [x.storyId, x.newValue]).sort()).toEqual([
+      ["a", "B-1 story b"],
+      ["b", "A-1 story a"],
+    ]);
+  });
+
+  it("validator 拒绝旧枚举值：BLOCKED_BY 不再合法", async () => {
+    await expect(
+      addDependenciesFn({
+        data: { items: [{ sourceId: "a", targetId: "b", type: "BLOCKED_BY" as any }] },
+      }),
+    ).rejects.toThrow();
+    expect(mocks.depCreate).not.toHaveBeenCalled();
+  });
+});
+
+describe("removeDependencyFn", () => {
+  it("按 depId 删除", async () => {
+    mocks.depDelete.mockResolvedValue({ id: "d1" });
+    const res = await removeDependencyFn({ data: { depId: "d1" } });
+    expect(res.id).toBe("d1");
+    expect(mocks.depDelete).toHaveBeenCalledWith({ where: { id: "d1" } });
+  });
+});
+
+describe("getDependenciesFn", () => {
+  it("双视角分组：dependsOn 取 source，dependents 取 target", async () => {
+    mocks.depFindMany.mockResolvedValue([
+      { id: "d1", sourceId: "s1", targetId: "me", type: "BLOCKS" },
+      { id: "d2", sourceId: "me", targetId: "t1", type: "STARTS_BEFORE" },
+    ]);
+    mocks.storyFindMany.mockImplementation(({ where }: any) => {
+      const rows = [STORY_ROW("s1"), STORY_ROW("t1"), STORY_ROW("me")];
+      return Promise.resolve(rows.filter((r) => where.id.in.includes(r.id)));
+    });
+    const res = await getDependenciesFn({ data: { storyId: "me" } });
+    expect(res.dependsOn).toHaveLength(1);
+    expect(res.dependsOn[0].id).toBe("s1");
+    expect(res.dependsOn[0].depId).toBe("d1");
+    expect(res.dependsOn[0].depType).toBe("BLOCKS");
+    expect(res.dependents).toHaveLength(1);
+    expect(res.dependents[0].id).toBe("t1");
+    expect(res.dependents[0].depType).toBe("STARTS_BEFORE");
+    // 日期已 ISO 化（castStoryUsers）
+    expect(res.dependsOn[0].createdAt).toBe("2026-01-01T00:00:00.000Z");
+  });
+
+  it("无边时返回空分组且不查需求表", async () => {
+    mocks.depFindMany.mockResolvedValue([]);
+    const res = await getDependenciesFn({ data: { storyId: "me" } });
+    expect(res).toEqual({ dependsOn: [], dependents: [] });
+    expect(mocks.storyFindMany).not.toHaveBeenCalled();
+  });
+});

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

@@ -84,7 +84,7 @@ describe("listStoriesInGroupFn", () => {
     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(arg.orderBy).toEqual([{ createdAt: "desc" }, { id: "asc" }]);
     expect(mocks.count).not.toHaveBeenCalled();
   });
 
@@ -222,6 +222,24 @@ describe("listStoryGroupsFn", () => {
     expect(out.groups.find((g) => g.key === "backlog")?.total).toBe(0);
   });
 
+  it("state/priority 组间顺序按枚举序排列（与筛选 pop 一致），不受 DB 返回顺序影响", async () => {
+    mocks.groupBy.mockResolvedValue([
+      { state: "done", _count: { _all: 91 } },
+      { state: "in_progress", _count: { _all: 2 } },
+      { state: "todo", _count: { _all: 1 } },
+    ]);
+    const stateOut = await listStoryGroupsFn({ data: { archived: false, groupBy: "state" } });
+    expect(stateOut.groups.map((g) => g.key)).toEqual(["todo", "in_progress", "done"]);
+
+    mocks.groupBy.mockResolvedValue([
+      { priority: "low", _count: { _all: 4 } },
+      { priority: "urgent", _count: { _all: 2 } },
+      { priority: "medium", _count: { _all: 1 } },
+    ]);
+    const priorityOut = await listStoryGroupsFn({ data: { archived: false, groupBy: "priority" } });
+    expect(priorityOut.groups.map((g) => g.key)).toEqual(["urgent", "medium", "low"]);
+  });
+
   it("labels 分组按 storyLabel.groupBy 聚合并计入 no-labels", async () => {
     mocks.storyLabelGroupBy.mockResolvedValue([
       { labelId: "l1", _count: { _all: 2 } },

package/src/server/serverFns/story/index.ts

@@ -81,10 +81,9 @@ export {
 } from "./story-children";
 
 export {
-  addDependencyFn,
+  addDependenciesFn,
   removeDependencyFn,
   getDependenciesFn,
-  validateDependencyFn,
 } from "./story-dependencies";
 
 export {
@@ -94,11 +93,11 @@ export {
   getLinksFn,
 } from "./story-links";
 
+export { checkLinkEmbeddableFn } from "./link-preview";
+
 export {
-  uploadAttachmentFn,
   removeAttachmentFn,
   getAttachmentsFn,
-  mockCloudStorageFn,
 } from "./story-attachments";
 
 export {
@@ -106,10 +105,12 @@ export {
   unlinkPrdFn,
   getLinkedPrdsFn,
   searchPrdsFn,
-  linkDocFn,
+  listStoryAvailableKbsFn,
+  searchKbDocsFn,
+  linkDocsFn,
   unlinkDocFn,
   getLinkedDocsFn,
-  searchDocsFn,
+  type SearchDocRow,
 } from "./story-assoc";
 
 export {