@allbluecn/web-app 0.10.3 → 0.11.1

package/src/server/serverFns/__tests__/story-crud-archive-detail.test.ts

@@ -0,0 +1,266 @@
+// 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/>.
+
+
+// story-crud 衍生域覆盖补全：archiveStoryFn / unarchiveStoryFn / getStoryNeighborsFn /
+// getStoryDetailFn。关键断言：归档状态流转与相邻节点排序；详情查询断言 select 形状；
+// 未登录/不存在拒绝且零资源查询。mock 骨架同 workspace-kb-idor.test.ts 样板。
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@tanstack/react-start", () => ({
+  createServerFn: (_config: unknown) => {
+    const api: any = {
+      _validator: undefined,
+      validator(schema: any) {
+        this._validator = schema;
+        return this;
+      },
+      handler(fn: Function) {
+        return async (args: any) => {
+          let data = args?.data;
+          if (this._validator && data !== undefined) {
+            data = this._validator.parse(data);
+          }
+          return fn({ data });
+        };
+      },
+    };
+    return api;
+  },
+}));
+vi.mock("@tanstack/react-start/server", () => ({ getRequest: () => ({}) }));
+
+const M = vi.hoisted(() => {
+  const f = () => vi.fn();
+  return {
+    requireAuth: f(),
+    story: { findUnique: f(), findFirst: f(), update: f() },
+    storyActivity: { create: f() },
+  };
+});
+
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    story: M.story,
+    storyActivity: M.storyActivity,
+  },
+  Prisma: {},
+}));
+vi.mock("@/server/auth-helpers", () => ({ requireAuth: M.requireAuth }));
+
+import { archiveStoryFn, unarchiveStoryFn } from "../story/story-crud/archive";
+import { getStoryDetailFn, getStoryNeighborsFn } from "../story/story-crud/detail";
+import { STORY_LIST_SELECT } from "../story/types";
+
+const USER = "u-current";
+const STORY_ID = "st-1";
+const PROJECT_ID = "pr-1";
+const T1 = new Date("2026-01-01T00:00:00Z");
+const T2 = new Date("2026-01-02T00:00:00Z");
+
+const userRow = {
+  id: USER,
+  username: "alice",
+  email: "alice@example.com",
+  avatarConfig: null,
+  bgShape: null,
+  bgColor: null,
+};
+/** STORY_LIST_SELECT 形状的需求行 fixture（castStoryUsers 需要 createdBy/labels 等） */
+const storyRow = (over: Record<string, unknown> = {}) => ({
+  id: STORY_ID,
+  identifier: "STORY-1",
+  sequenceId: 1,
+  name: "需求A",
+  description: null,
+  state: "backlog",
+  priority: "none",
+  archived: false,
+  startDate: null,
+  targetDate: null,
+  boardOrder: 0,
+  projectId: PROJECT_ID,
+  parentId: null,
+  parent: null,
+  assignee: null,
+  createdBy: userRow,
+  updatedBy: null,
+  labels: [],
+  createdAt: T1,
+  updatedAt: T2,
+  ...over,
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  M.requireAuth.mockResolvedValue({ user: { id: USER } });
+  M.story.update.mockResolvedValue(storyRow());
+  M.storyActivity.create.mockResolvedValue({});
+});
+
+describe("archiveStoryFn", () => {
+  it("归档时置 archived 并写入 archivedAt 与活动记录", async () => {
+    M.story.update.mockResolvedValue(storyRow({ archived: true, archivedAt: new Date("2026-01-03T00:00:00Z") }));
+    const res = await archiveStoryFn({ data: { storyId: STORY_ID } });
+
+    expect(M.story.update).toHaveBeenCalledWith({
+      where: { id: STORY_ID },
+      data: expect.objectContaining({ archived: true, archivedAt: expect.any(Date) }),
+      select: STORY_LIST_SELECT,
+    });
+    expect(M.storyActivity.create).toHaveBeenCalledWith({
+      data: {
+        storyId: STORY_ID,
+        userId: USER,
+        action: "archived",
+        field: "archived",
+        oldValue: "false",
+        newValue: "true",
+      },
+    });
+    expect(res).toMatchObject({
+      id: STORY_ID,
+      identifier: "STORY-1",
+      name: "需求A",
+      archived: true,
+      createdAt: T1.toISOString(),
+      updatedAt: T2.toISOString(),
+      labels: [],
+    });
+    expect(res.createdBy).toMatchObject({ id: USER, username: "alice" });
+    expect(res.startDate).toBeNull();
+  });
+
+  it("未登录拒绝且不更新不写活动", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(archiveStoryFn({ data: { storyId: STORY_ID } })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.story.update).not.toHaveBeenCalled();
+    expect(M.storyActivity.create).not.toHaveBeenCalled();
+  });
+});
+
+describe("unarchiveStoryFn", () => {
+  it("恢复时清空 archivedAt 并写入 unarchived 活动记录", async () => {
+    const res = await unarchiveStoryFn({ data: { storyId: STORY_ID } });
+
+    expect(M.story.update).toHaveBeenCalledWith({
+      where: { id: STORY_ID },
+      data: { archived: false, archivedAt: null },
+      select: STORY_LIST_SELECT,
+    });
+    expect(M.storyActivity.create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ action: "unarchived", oldValue: "true", newValue: "false" }),
+      }),
+    );
+    expect(res.archived).toBe(false);
+  });
+
+  it("未登录拒绝且不更新", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(unarchiveStoryFn({ data: { storyId: STORY_ID } })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.story.update).not.toHaveBeenCalled();
+  });
+});
+
+describe("getStoryNeighborsFn", () => {
+  it("需求不存在时返回双 null 且不查询相邻需求", async () => {
+    M.story.findUnique.mockResolvedValue(null);
+
+    await expect(getStoryNeighborsFn({ data: { storyId: STORY_ID } })).resolves.toEqual({
+      prevId: null,
+      nextId: null,
+    });
+    expect(M.story.findFirst).not.toHaveBeenCalled();
+  });
+
+  it("按 createdAt 分别取最新与最早作为前后邻居", async () => {
+    M.story.findUnique.mockResolvedValue({ id: STORY_ID, projectId: PROJECT_ID, createdAt: T1 });
+    M.story.findFirst.mockImplementation(({ orderBy }: { orderBy: unknown }) => {
+      const desc = JSON.stringify(orderBy).includes('"desc"');
+      return Promise.resolve(desc ? { id: "st-prev" } : { id: "st-next" });
+    });
+
+    const res = await getStoryNeighborsFn({ data: { storyId: STORY_ID } });
+
+    expect(M.story.findUnique).toHaveBeenCalledWith({
+      where: { id: STORY_ID },
+      select: { id: true, projectId: true, createdAt: true },
+    });
+    expect(M.story.findFirst).toHaveBeenCalledTimes(2);
+    expect(M.story.findFirst).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({ projectId: PROJECT_ID, archived: false, id: { not: STORY_ID } }),
+        orderBy: [{ createdAt: "desc" }, { id: "desc" }],
+        select: { id: true },
+      }),
+    );
+    expect(res).toEqual({ prevId: "st-prev", nextId: "st-next" });
+  });
+
+  it("查询到邻居为空时对应字段为 null", async () => {
+    M.story.findUnique.mockResolvedValue({ id: STORY_ID, projectId: PROJECT_ID, createdAt: T1 });
+    M.story.findFirst.mockResolvedValue(null);
+    await expect(getStoryNeighborsFn({ data: { storyId: STORY_ID } })).resolves.toEqual({
+      prevId: null,
+      nextId: null,
+    });
+  });
+
+  it("未登录拒绝且不查询", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(getStoryNeighborsFn({ data: { storyId: STORY_ID } })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.story.findUnique).not.toHaveBeenCalled();
+  });
+});
+
+describe("getStoryDetailFn", () => {
+  it("返回序列化后的需求详情", async () => {
+    M.story.findUnique.mockResolvedValue(
+      storyRow({ name: "需求详情", startDate: T1, labels: [{ label: { id: "lb-1", name: "标签", color: "#f00" } }] }),
+    );
+
+    const res = await getStoryDetailFn({ data: { storyId: STORY_ID } });
+
+    expect(M.story.findUnique).toHaveBeenCalledWith({
+      where: { id: STORY_ID },
+      select: STORY_LIST_SELECT,
+    });
+    expect(res).toMatchObject({
+      id: STORY_ID,
+      name: "需求详情",
+      state: "backlog",
+      priority: "none",
+      startDate: T1.toISOString(),
+      targetDate: null,
+      parent: null,
+      assignee: null,
+      labels: [{ id: "lb-1", name: "标签", color: "#f00" }],
+    });
+  });
+
+  it("需求不存在时报错", async () => {
+    M.story.findUnique.mockResolvedValue(null);
+    await expect(getStoryDetailFn({ data: { storyId: "missing" } })).rejects.toThrow("需求不存在");
+  });
+
+  it("未登录拒绝且不查询详情", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(getStoryDetailFn({ data: { storyId: STORY_ID } })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.story.findUnique).not.toHaveBeenCalled();
+  });
+});

package/src/server/serverFns/__tests__/story-crud-labels-users.test.ts

@@ -0,0 +1,227 @@
+// 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/>.
+
+
+// story-crud 衍生域覆盖补全：listUsersBriefFn / listLabelsFn / createLabelFn。
+// 关键断言：用户简要列表按团队范围过滤（断言 where teamId）；标签颜色校验与去重；
+// 未登录拒绝且零资源查询。mock 骨架同 workspace-kb-idor.test.ts 样板。
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@tanstack/react-start", () => ({
+  createServerFn: (_config: unknown) => {
+    const api: any = {
+      _validator: undefined,
+      validator(schema: any) {
+        this._validator = schema;
+        return this;
+      },
+      handler(fn: Function) {
+        return 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 api;
+  },
+}));
+vi.mock("@tanstack/react-start/server", () => ({ getRequest: () => ({}) }));
+
+const M = vi.hoisted(() => {
+  const f = () => vi.fn();
+  return {
+    requireAuth: f(),
+    project: { findUnique: f() },
+    projectMember: { findMany: f() },
+    teamMembership: { findMany: f() },
+    user: { findMany: f() },
+    label: { findMany: f() },
+    upsertLabel: f(),
+  };
+});
+
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    project: M.project,
+    projectMember: M.projectMember,
+    teamMembership: M.teamMembership,
+    user: M.user,
+    label: M.label,
+  },
+  Prisma: {},
+}));
+vi.mock("@/server/auth-helpers", () => ({ requireAuth: M.requireAuth }));
+vi.mock("../story/story-crud/label-upsert", () => ({ upsertLabel: M.upsertLabel }));
+
+import {
+  createLabelFn,
+  listLabelsFn,
+  listUsersBriefFn,
+} from "../story/story-crud/labels";
+import { USER_BRIEF_SELECT } from "../story/types";
+
+const USER = "u-current";
+const OWNER = "u-owner";
+const PROJECT_ID = "pr-1";
+
+const userRow = (id: string, username: string) => ({
+  id,
+  username,
+  email: `${username}@example.com`,
+  avatarConfig: null,
+  bgShape: null,
+  bgColor: null,
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  M.requireAuth.mockResolvedValue({ user: { id: USER } });
+  M.user.findMany.mockResolvedValue([]);
+});
+
+describe("listUsersBriefFn", () => {
+  it("传 projectId 时只返回项目成员（含项目 owner）", async () => {
+    M.project.findUnique.mockResolvedValue({ ownerId: OWNER, workspaceId: "ws-1" });
+    M.projectMember.findMany.mockResolvedValue([{ userId: "u-m1" }]);
+    M.user.findMany.mockResolvedValue([userRow("u-m1", "member"), userRow(OWNER, "owner")]);
+
+    const res = await listUsersBriefFn({ data: { projectId: PROJECT_ID } });
+
+    expect(M.project.findUnique).toHaveBeenCalledWith({
+      where: { id: PROJECT_ID },
+      select: { ownerId: true, workspaceId: true },
+    });
+    expect(M.projectMember.findMany).toHaveBeenCalledWith({
+      where: { projectId: PROJECT_ID },
+      select: { userId: true },
+    });
+    expect(M.teamMembership.findMany).not.toHaveBeenCalled();
+    expect(M.user.findMany).toHaveBeenCalledWith({
+      where: { id: { in: ["u-m1", OWNER] }, status: "ACTIVE" },
+      orderBy: { username: "asc" },
+      select: USER_BRIEF_SELECT,
+    });
+    expect(res).toEqual([userRow("u-m1", "member"), userRow(OWNER, "owner")]);
+  });
+
+  it("项目不存在时返回空数组且不查询用户", async () => {
+    M.project.findUnique.mockResolvedValue(null);
+    await expect(listUsersBriefFn({ data: { projectId: "missing" } })).resolves.toEqual([]);
+    expect(M.projectMember.findMany).not.toHaveBeenCalled();
+    expect(M.user.findMany).not.toHaveBeenCalled();
+  });
+
+  it("未传 projectId 时按当前用户所属团队返回成员（含自己）", async () => {
+    M.teamMembership.findMany.mockResolvedValue([{ memberId: "u-m2" }]);
+    M.user.findMany.mockResolvedValue([userRow(USER, "self"), userRow("u-m2", "teammate")]);
+
+    const res = await listUsersBriefFn({ data: {} });
+
+    expect(M.teamMembership.findMany).toHaveBeenCalledWith({
+      where: { ownerId: USER },
+      select: { memberId: true },
+    });
+    expect(M.user.findMany).toHaveBeenCalledWith({
+      where: { id: { in: ["u-m2", USER] }, status: "ACTIVE" },
+      orderBy: { username: "asc" },
+      select: USER_BRIEF_SELECT,
+    });
+    expect(M.project.findUnique).not.toHaveBeenCalled();
+    expect(res.map((u) => u.username)).toContain("self");
+    expect(res.map((u) => u.avatarConfig)).toEqual([null, null]);
+  });
+
+  it("当前用户无任何团队成员关系时返回空数组", async () => {
+    M.teamMembership.findMany.mockResolvedValue([]);
+    await expect(listUsersBriefFn({ data: {} })).resolves.toEqual([]);
+    expect(M.user.findMany).not.toHaveBeenCalled();
+  });
+
+  it("未登录拒绝且不查询任何资源", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(listUsersBriefFn({ data: {} })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.teamMembership.findMany).not.toHaveBeenCalled();
+    expect(M.user.findMany).not.toHaveBeenCalled();
+  });
+});
+
+describe("listLabelsFn", () => {
+  it("按名称升序返回全部标签", async () => {
+    M.label.findMany.mockResolvedValue([
+      { id: "lb-2", name: "Beta", color: "#ff0000" },
+      { id: "lb-1", name: "Alpha", color: null },
+    ]);
+
+    const res = await listLabelsFn({ data: undefined });
+
+    expect(M.label.findMany).toHaveBeenCalledWith({
+      orderBy: { name: "asc" },
+      select: { id: true, name: true, color: true },
+    });
+    expect(res).toEqual([
+      { id: "lb-2", name: "Beta", color: "#ff0000" },
+      { id: "lb-1", name: "Alpha", color: null },
+    ]);
+  });
+
+  it("无标签时返回空数组", async () => {
+    M.label.findMany.mockResolvedValue([]);
+    await expect(listLabelsFn({ data: undefined })).resolves.toEqual([]);
+  });
+
+  it("未登录拒绝且不查询", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(listLabelsFn({ data: undefined })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.label.findMany).not.toHaveBeenCalled();
+  });
+});
+
+describe("createLabelFn", () => {
+  it("透传名称与颜色给 upsertLabel 并使用当前用户", async () => {
+    M.upsertLabel.mockResolvedValue({ id: "lb-9", name: "新标签", color: "#00ff00" });
+
+    const res = await createLabelFn({ data: { name: "新标签", color: "#00ff00" } });
+
+    expect(M.upsertLabel).toHaveBeenCalledWith("新标签", USER, "#00ff00");
+    expect(res).toEqual({ id: "lb-9", name: "新标签", color: "#00ff00" });
+  });
+
+  it("未传颜色时以 undefined 透传", async () => {
+    M.upsertLabel.mockResolvedValue({ id: "lb-9", name: "B", color: null });
+    await createLabelFn({ data: { name: "B" } });
+    expect(M.upsertLabel).toHaveBeenCalledWith("B", USER, undefined);
+  });
+
+  it("非法颜色格式被 validator 拒绝（不写库）", async () => {
+    await expect(createLabelFn({ data: { name: "X", color: "red" } })).rejects.toThrow();
+    expect(M.upsertLabel).not.toHaveBeenCalled();
+  });
+
+  it("空名称被 validator 拒绝", async () => {
+    await expect(createLabelFn({ data: { name: "" } })).rejects.toThrow();
+    expect(M.upsertLabel).not.toHaveBeenCalled();
+  });
+
+  it("未登录拒绝且不写库", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(createLabelFn({ data: { name: "X" } })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.upsertLabel).not.toHaveBeenCalled();
+  });
+});