@allbluecn/web-app 0.4.22 → 0.5.0

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

@@ -0,0 +1,239 @@
+// 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(),
+  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 },
+  };
+  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([]);
+});
+
+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 },
+    });
+  });
+
+  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 {

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

@@ -20,199 +20,143 @@ import { getRequest } from "@tanstack/react-start/server";
 import { z } from "zod";
 import { prisma } from "@allbluecn/database";
 import { requireAuth } from "@/server/auth-helpers";
-import type { DependencyType } from "@/components/story/types";
+import { STORY_LIST_SELECT, castStoryUsers } from "./types";
+import type { DependencyRow } from "@/components/story/types";
 
-async function hasCycle(sourceId: string, targetId: string): Promise<boolean> {
-  const visited = new Set<string>();
+const edgeTypeSchema = z.enum(["BLOCKS", "STARTS_BEFORE", "FINISHES_BEFORE"]);
 
-  async function dfs(currentId: string): Promise<boolean> {
-    if (visited.has(currentId)) return false;
-    visited.add(currentId);
-
-    const outgoing = await prisma.storyDependency.findMany({
-      where: { sourceId: currentId, type: "BLOCKS" },
-      select: { targetId: true },
-    });
-
-    for (const dep of outgoing) {
-      if (dep.targetId === targetId) return true;
-      if (await dfs(dep.targetId)) return true;
-    }
-
-    return false;
-  }
-
-  return dfs(sourceId);
-}
-
-export const addDependencyFn = createServerFn({ method: "POST" })
+export const addDependenciesFn = createServerFn({ method: "POST" })
   .validator(
     z.object({
-      sourceId: z.string(),
-      targetId: z.string(),
-      type: z.enum(["BLOCKS", "BLOCKED_BY", "RELATES_TO"]),
+      items: z
+        .array(
+          z.object({
+            sourceId: z.string(),
+            targetId: z.string(),
+            type: edgeTypeSchema,
+          }),
+        )
+        .min(1),
     }),
   )
   .handler(async ({ data }) => {
     const request = getRequest();
-    const session = await requireAuth(request);
+    await requireAuth(request);
 
-    const existing = await prisma.storyDependency.findUnique({
-      where: {
-        sourceId_targetId_type: {
-          sourceId: data.sourceId,
-          targetId: data.targetId,
-          type: data.type,
-        },
-      },
+    // 一次性取全部出边（3 类型合并；不按 projectId 裁剪——跨项目边同样参与环判定），
+    // 构建内存邻接表供本批循环的环检测复用，避免 O(items × 可达节点) 次串行 RTT
+    const allEdges = await prisma.storyDependency.findMany({
+      select: { sourceId: true, targetId: true },
     });
-    if (existing) {
-      throw new Error("依赖关系已存在");
+    const adjacency = new Map<string, string[]>();
+    for (const e of allEdges) {
+      const list = adjacency.get(e.sourceId);
+      if (list) list.push(e.targetId);
+      else adjacency.set(e.sourceId, [e.targetId]);
     }
 
-    const dep = await prisma.storyDependency.create({
-      data: {
-        sourceId: data.sourceId,
-        targetId: data.targetId,
-        type: data.type,
-      },
-    });
+    // 环检测：从 fromId 出发沿 source→target 有向边能否到达 toId（纯内存遍历）
+    // batchEdges：本批已插入边（防批内互指环漏检）
+    function reaches(
+      fromId: string,
+      toId: string,
+      batchEdges: Array<{ sourceId: string; targetId: string }>,
+    ): boolean {
+      const visited = new Set<string>();
+      const stack = [fromId];
+      while (stack.length > 0) {
+        const current = stack.pop()!;
+        if (current === toId) return true;
+        if (visited.has(current)) continue;
+        visited.add(current);
+        for (const next of adjacency.get(current) ?? []) {
+          if (!visited.has(next)) stack.push(next);
+        }
+        for (const e of batchEdges) {
+          if (e.sourceId === current && !visited.has(e.targetId)) stack.push(e.targetId);
+        }
+      }
+      return false;
+    }
 
-    return dep;
+    const created: string[] = [];
+    const failed: Array<{ targetId: string; reason: "SELF" | "DUPLICATED" | "CYCLE" }> = [];
+    const batchEdges: Array<{ sourceId: string; targetId: string }> = [];
+
+    for (const item of data.items) {
+      if (item.sourceId === item.targetId) {
+        failed.push({ targetId: item.targetId, reason: "SELF" });
+        continue;
+      }
+      const existing = await prisma.storyDependency.findFirst({
+        where: {
+          OR: [
+            { sourceId: item.sourceId, targetId: item.targetId },
+            { sourceId: item.targetId, targetId: item.sourceId },
+          ],
+        },
+        select: { id: true },
+      });
+      if (existing) {
+        failed.push({ targetId: item.targetId, reason: "DUPLICATED" });
+        continue;
+      }
+      // 插入 (S,T) 后成环 ⇔ 已存在路径 T →…→ S（含本批边）
+      if (reaches(item.targetId, item.sourceId, batchEdges)) {
+        failed.push({ targetId: item.targetId, reason: "CYCLE" });
+        continue;
+      }
+      const dep = await prisma.storyDependency.create({ data: item });
+      created.push(dep.id);
+      batchEdges.push({ sourceId: item.sourceId, targetId: item.targetId });
+    }
+
+    return { created, failed };
   });
 
 export const removeDependencyFn = createServerFn({ method: "POST" })
-  .validator(
-    z.object({
-      sourceId: z.string(),
-      targetId: z.string(),
-      type: z.enum(["BLOCKS", "BLOCKED_BY", "RELATES_TO"]),
-    }),
-  )
+  .validator(z.object({ depId: z.string() }))
   .handler(async ({ data }) => {
     const request = getRequest();
-    const session = await requireAuth(request);
-
-    const dep = await prisma.storyDependency.delete({
-      where: {
-        sourceId_targetId_type: {
-          sourceId: data.sourceId,
-          targetId: data.targetId,
-          type: data.type,
-        },
-      },
-    });
-
-    return dep;
+    await requireAuth(request);
+    return prisma.storyDependency.delete({ where: { id: data.depId } });
   });
 
 export const getDependenciesFn = createServerFn({ method: "GET" })
   .validator(z.object({ storyId: z.string() }))
   .handler(async ({ data }) => {
     const request = getRequest();
-    const session = await requireAuth(request);
+    await requireAuth(request);
 
     const deps = await prisma.storyDependency.findMany({
-      where: {
-        OR: [{ sourceId: data.storyId }, { targetId: data.storyId }],
-      },
-      include: {
-        source: {
-          select: { id: true, name: true, state: true },
-        },
-        target: {
-          select: { id: true, name: true, state: true },
-        },
-      },
+      where: { OR: [{ targetId: data.storyId }, { sourceId: data.storyId }] },
+      select: { id: true, sourceId: true, targetId: true, type: true },
     });
-
-    const grouped = {
-      blocking: deps
-        .filter((d) => d.sourceId === data.storyId && d.type === "BLOCKS")
-        .map((d) => ({
-          id: d.target.id,
-          title: d.target.name,
-          status: d.target.state,
-          type: "blocks" as DependencyType,
-        })),
-      blockedBy: deps
-        .filter((d) => d.targetId === data.storyId && d.type === "BLOCKS")
-        .map((d) => ({
-          id: d.source.id,
-          title: d.source.name,
-          status: d.source.state,
-          type: "blocked_by" as DependencyType,
-        })),
-      relatesTo: deps
-        .filter((d) => d.type === "RELATES_TO")
-        .map((d) => {
-          const isSource = d.sourceId === data.storyId;
-          const other = isSource ? d.target : d.source;
-          return {
-            id: other.id,
-            title: other.name,
-            status: other.state,
-            type: "relates_to" as DependencyType,
-          };
-        }),
-    };
-
-    return grouped;
-  });
-
-export const validateDependencyFn = createServerFn({ method: "POST" })
-  .validator(
-    z.object({
-      sourceId: z.string(),
-      targetId: z.string(),
-      type: z.enum(["BLOCKS", "BLOCKED_BY", "RELATES_TO"]),
-    }),
-  )
-  .handler(async ({ data }) => {
-    const request = getRequest();
-    const session = await requireAuth(request);
-
-    if (data.sourceId === data.targetId) {
-      return { valid: false, reason: "不能创建自我依赖" };
-    }
-
-    if (data.type === "BLOCKS") {
-      const reverse = await prisma.storyDependency.findUnique({
-        where: {
-          sourceId_targetId_type: {
-            sourceId: data.targetId,
-            targetId: data.sourceId,
-            type: "BLOCKS",
-          },
-        },
-      });
-      if (!reverse) {
-        return {
-          valid: false,
-          reason: "blocks 依赖必须成对出现（需要同时创建反向 blocks）",
-        };
-      }
+    if (deps.length === 0) {
+      return { dependsOn: [] as DependencyRow[], dependents: [] as DependencyRow[] };
     }
 
-    const source = await prisma.story.findUnique({
-      where: { id: data.sourceId },
-      select: { parentId: true },
+    const ids = [...new Set(deps.flatMap((d) => [d.sourceId, d.targetId]))];
+    const stories = await prisma.story.findMany({
+      where: { id: { in: ids } },
+      select: STORY_LIST_SELECT,
     });
-    const target = await prisma.story.findUnique({
-      where: { id: data.targetId },
-      select: { parentId: true },
-    });
-
-    if (source?.parentId === data.targetId || target?.parentId === data.sourceId) {
-      return {
-        valid: false,
-        reason: "父子需求之间不能有 blocks/blocked_by 依赖",
-      };
-    }
+    const byId = new Map(stories.map((s) => [s.id, castStoryUsers(s)]));
 
-    if (await hasCycle(data.sourceId, data.targetId)) {
-      return { valid: false, reason: "会形成循环依赖" };
-    }
+    const build = (d: (typeof deps)[number], storyId: string): DependencyRow | null => {
+      const otherId = d.sourceId === storyId ? d.targetId : d.sourceId;
+      const s = byId.get(otherId);
+      return s ? ({ ...s, depId: d.id, depType: d.type } as DependencyRow) : null;
+    };
 
-    return { valid: true };
+    return {
+      dependsOn: deps
+        .filter((d) => d.targetId === data.storyId)
+        .map((d) => build(d, data.storyId))
+        .filter((r): r is DependencyRow => r !== null),
+      dependents: deps
+        .filter((d) => d.sourceId === data.storyId)
+        .map((d) => build(d, data.storyId))
+        .filter((r): r is DependencyRow => r !== null),
+    };
   });

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

@@ -78,9 +78,11 @@ export const listStoriesInGroupFn = createServerFn({ method: "GET" })
 
     const field = ORDER_FIELD[data.orderBy];
     const dir: "asc" | "desc" = data.orderDir === "asc" ? "asc" : "desc";
-    const orderBy: Prisma.StoryOrderByWithRelationInput = field
+    const primary: Prisma.StoryOrderByWithRelationInput = field
       ? { [field]: dir }
       : { createdAt: dir };
+    // id tiebreaker：主排序键相同的行（同批创建等）顺序必须确定，否则重拉时顺序抖动
+    const orderBy: Prisma.StoryOrderByWithRelationInput[] = [primary, { id: "asc" }];
 
     const items = await prisma.story.findMany({
       where,
@@ -132,9 +134,11 @@ export const listAllGroupsItemsFn = createServerFn({ method: "GET" })
     const base = buildListWhere({ ...data, projectId });
     const field = ORDER_FIELD[data.orderBy];
     const dir: "asc" | "desc" = data.orderDir === "asc" ? "asc" : "desc";
-    const orderBy: Prisma.StoryOrderByWithRelationInput = field
+    const primary: Prisma.StoryOrderByWithRelationInput = field
       ? { [field]: dir }
       : { createdAt: dir };
+    // id tiebreaker：与 listStoriesInGroupFn 保持一致，保证分页跨批次全序稳定
+    const orderBy: Prisma.StoryOrderByWithRelationInput[] = [primary, { id: "asc" }];
 
     const batchTake = data.take * data.groupCount;
     const items = await prisma.story.findMany({
@@ -216,6 +220,19 @@ function deriveGroupKey(groupBy: GroupKey, row: Record<string, unknown>): string
   }
 }
 
+/** 组间显示顺序与筛选 pop 的值顺序一致（state/priority 按枚举序，其余维度保持 DB 返回序；未知 key 排最后） */
+const GROUP_DISPLAY_ORDER: Partial<Record<GroupKey, readonly string[]>> = {
+  state: STORY_STATES.map((s) => s.value),
+  priority: STORY_PRIORITIES.map((p) => p.value),
+};
+
+function sortGroupKeys(groupBy: GroupKey, keys: string[]): string[] {
+  const order = GROUP_DISPLAY_ORDER[groupBy];
+  if (!order) return keys;
+  const rank = new Map(order.map((k, i) => [k, i]));
+  return [...keys].sort((a, b) => (rank.get(a) ?? order.length) - (rank.get(b) ?? order.length));
+}
+
 export const listStoryGroupsFn = createServerFn({ method: "GET" })
   .validator(listGroupsSchema)
   .handler(async ({ data }) => {
@@ -293,6 +310,9 @@ export const listStoryGroupsFn = createServerFn({ method: "GET" })
         if (!keys.includes(k)) keys.push(k);
       }
     }
-    const groups: Array<{ key: string; total: number }> = keys.map((k) => ({ key: k, total: totalMap.get(k) ?? 0 }));
+    const groups: Array<{ key: string; total: number }> = sortGroupKeys(data.groupBy, keys).map((k) => ({
+      key: k,
+      total: totalMap.get(k) ?? 0,
+    }));
     return { groups };
   });

package/src/server/serverFns/story/story-transfer.ts

@@ -349,7 +349,8 @@ const listProjectStoriesSchema = z.object({
   search: z.string().optional(),
   cursor: z.string().optional(),
   excludeStoryId: z.string().optional(),
-  mode: z.enum(["parent", "child"]).default("parent"),
+  excludeIds: z.array(z.string()).optional(),
+  mode: z.enum(["parent", "child", "dependency"]).default("parent"),
   pageSize: z.number().int().min(1).max(50).default(20),
 });
 
@@ -365,16 +366,17 @@ export const listProjectStoriesFn = createServerFn({ method: "GET" })
       if (data.mode === "parent") {
         const descendants = await collectDescendantIds(data.excludeStoryId);
         for (const id of descendants) excludeIds.add(id);
-      } else {
+      } else if (data.mode === "child") {
         const ancestors = await collectAncestorIds(data.excludeStoryId);
         for (const id of ancestors) excludeIds.add(id);
       }
     }
+    for (const id of data.excludeIds ?? []) excludeIds.add(id);
 
     const stories = await prisma.story.findMany({
       where: {
         ...(data.projectId ? { projectId: data.projectId } : {}),
-        parentId: null,
+        ...(data.mode === "dependency" ? {} : { parentId: null }),
         archived: false,
         ...(excludeIds.size > 0
           ? { id: { notIn: Array.from(excludeIds) } }