@allbluecn/web-app 0.17.2 → 0.18.1

package/src/server/serverFns/workspace-kb.ts

@@ -22,15 +22,14 @@ import { z } from "zod";
 import { createServerFn } from "@tanstack/react-start";
 import { getRequest } from "@tanstack/react-start/server";
 import { requireAuth } from "@/server/auth-helpers";
-import { GENERAL_GROUP_TABLES, GENERAL_GROUPS, type GeneralGroup } from "./story/kb-general";
+import { GENERAL_GROUP_TABLES, GENERAL_GROUPS, type GeneralGroup } from "@/server/knowledge/kb-general";
 import type { QuickDocRow, WorkspaceKbCardData, QuickDocItem } from "./workspace-kb-utils";
 import {
   searchGeneralGroupDocs,
   listUserTeamKbIds,
   SEARCH_DOC_SELECT,
   toSearchDocRow,
-  type SearchDocRow,
-} from "./kb-doc-search";
+} from "@/server/knowledge/kb-doc-search";
 import { quickDocItemSchema, quickDocItemKey, QUICK_DOC_COLUMNS } from "./workspace-kb-utils";
 
 /** owner 或 active 成员可访问 */
@@ -251,85 +250,109 @@ export const addQuickDocsFn = createServerFn({ method: "POST" })
     const userId = session.user!.id!;
     await requireWorkspaceMember(data.workspaceId, userId);
 
+    // DB-01：批量快捷文档原每项 2~3 次串行查询（存在性 findFirst + 查重 findFirst + create）。
+    // 改预取：存在性按 id in 批量取（文档 1 次 + 每通用组 1 次），查重复用 existing 集合（扩 select，0 额外查询），
+    // 写入收敛为 1 次 createMany。查询次数 before: 2~3N + 1 → after: ≤ 7（常数，与项数无关）
     const existing = await prisma.workspaceQuickDoc.findMany({
       where: { workspaceId: data.workspaceId },
-      select: { columnIndex: true, sortOrder: true },
+      select: { columnIndex: true, sortOrder: true, docId: true, externalGroup: true, externalId: true },
     });
     // 看板式追加：新文档放到「最短列」末尾（并列取最左），保持各列视觉均衡
     const counts = new Array(QUICK_DOC_COLUMNS).fill(0) as number[];
     const maxOrder = new Array(QUICK_DOC_COLUMNS).fill(-1) as number[];
+    const dupDocIds = new Set<string>();
+    const dupExternalKeys = new Set<string>();
     for (const row of existing) {
       const c = Math.min(Math.max(row.columnIndex, 0), QUICK_DOC_COLUMNS - 1);
       counts[c] += 1;
       maxOrder[c] = Math.max(maxOrder[c], row.sortOrder);
+      if (row.docId) dupDocIds.add(row.docId);
+      if (row.externalGroup && row.externalId) dupExternalKeys.add(`${row.externalGroup}|${row.externalId}`);
+    }
+
+    // 预取存在性：知识库文档一次 in 查询；通用组表按出现的分组各一次 in 查询
+    const docIds = [...new Set((data.items as QuickDocItem[]).map((i) => i.docId).filter((id): id is string => !!id))];
+    const existingDocIds = docIds.length
+      ? new Set(
+          (
+            await prisma.knowledgeDocument.findMany({
+              where: { id: { in: docIds }, isDeleted: false },
+              select: { id: true },
+            })
+          ).map((d) => d.id),
+        )
+      : new Set<string>();
+    const externalIdsByGroup = new Map<Exclude<GeneralGroup, "summary">, string[]>();
+    for (const item of data.items as QuickDocItem[]) {
+      if (item.docId || !item.externalGroup || item.externalGroup === "summary") continue;
+      const ids = externalIdsByGroup.get(item.externalGroup) ?? [];
+      if (item.externalId) ids.push(item.externalId);
+      externalIdsByGroup.set(item.externalGroup, ids);
+    }
+    const existingExternalIds = new Map<string, Set<string>>();
+    for (const [group, ids] of externalIdsByGroup) {
+      const rows = await (
+        prisma[GENERAL_GROUP_TABLES[group]] as unknown as {
+          findMany: (args: Record<string, unknown>) => Promise<Array<{ id: string }>>;
+        }
+      ).findMany({ where: { id: { in: [...new Set(ids)] }, isDeleted: false }, select: { id: true } });
+      existingExternalIds.set(group, new Set(rows.map((r) => r.id)));
     }
 
     const created: string[] = [];
     const failed: Array<{ key: string; reason: "outOfScope" | "duplicate" }> = [];
+    const rowsToCreate: Array<Record<string, unknown>> = [];
 
     for (const item of data.items as QuickDocItem[]) {
       const key = quickDocItemKey(item);
       const targetCol = counts.indexOf(Math.min(...counts));
       const order = maxOrder[targetCol] + 1;
       if (item.docId) {
-        const doc = await prisma.knowledgeDocument.findFirst({
-          where: { id: item.docId, isDeleted: false },
-          select: { id: true },
-        });
-        if (!doc) {
+        if (!existingDocIds.has(item.docId)) {
           failed.push({ key, reason: "outOfScope" });
           continue;
         }
-        const dup = await prisma.workspaceQuickDoc.findFirst({
-          where: { workspaceId: data.workspaceId, docId: item.docId },
-          select: { id: true },
-        });
-        if (dup) {
+        // 批内重复同样命中（新行加入 dupDocIds，与原 create 后查重可见语义一致）
+        if (dupDocIds.has(item.docId)) {
           failed.push({ key, reason: "duplicate" });
           continue;
         }
-        await prisma.workspaceQuickDoc.create({
-          data: {
-            workspaceId: data.workspaceId, docId: item.docId,
-            displayTitle: item.displayTitle, columnIndex: targetCol, sortOrder: order, label: item.label ?? null, icon: item.icon ?? null, createdBy: userId,
-          },
+        dupDocIds.add(item.docId);
+        rowsToCreate.push({
+          workspaceId: data.workspaceId, docId: item.docId,
+          displayTitle: item.displayTitle, columnIndex: targetCol, sortOrder: order, label: item.label ?? null, icon: item.icon ?? null, createdBy: userId,
         });
         counts[targetCol] += 1;
         maxOrder[targetCol] = order;
         created.push(key);
       } else {
         const group = item.externalGroup!;
+        // 原 summary 组存在性查询短路为 null → 一律 outOfScope，保持该语义
         const exists =
-          group === "summary"
-            ? null
-            : await (
-                prisma[GENERAL_GROUP_TABLES[group as Exclude<GeneralGroup, "summary">]] as unknown as {
-                  findFirst: (args: Record<string, unknown>) => Promise<{ id: string } | null>;
-                }
-              ).findFirst({ where: { id: item.externalId!, isDeleted: false }, select: { id: true } });
+          group === "summary" ? false : (existingExternalIds.get(group as Exclude<GeneralGroup, "summary">)?.has(item.externalId!) ?? false);
         if (!exists) {
           failed.push({ key, reason: "outOfScope" });
           continue;
         }
-        const dup = await prisma.workspaceQuickDoc.findFirst({
-          where: { workspaceId: data.workspaceId, externalGroup: group, externalId: item.externalId },
-          select: { id: true },
-        });
-        if (dup) {
+        const dupKey = `${group}|${item.externalId}`;
+        if (dupExternalKeys.has(dupKey)) {
           failed.push({ key, reason: "duplicate" });
           continue;
         }
-        await prisma.workspaceQuickDoc.create({
-          data: {
-            workspaceId: data.workspaceId, externalGroup: group, externalId: item.externalId,
-            displayTitle: item.displayTitle, columnIndex: targetCol, sortOrder: order, label: item.label ?? null, icon: item.icon ?? null, createdBy: userId,
-          },
+        dupExternalKeys.add(dupKey);
+        rowsToCreate.push({
+          workspaceId: data.workspaceId, externalGroup: group, externalId: item.externalId,
+          displayTitle: item.displayTitle, columnIndex: targetCol, sortOrder: order, label: item.label ?? null, icon: item.icon ?? null, createdBy: userId,
         });
         counts[targetCol] += 1;
         maxOrder[targetCol] = order;
         created.push(key);
       }
     }
+    // 单条批量写自带原子性，无需 $transaction
+    if (rowsToCreate.length > 0) {
+      await prisma.workspaceQuickDoc.createMany({ data: rowsToCreate as never });
+    }
     return { created, failed };
   });
 

package/src/server/story/types.ts

@@ -0,0 +1,305 @@
+// 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 type { Prisma } from "@allbluecn/database";
+import { getPrisma } from "@allbluecn/database/get-prisma";
+import type { AvatarConfig } from "@allbluecn/kernel";
+import type { StoryState, StoryPriority } from "@/components/story/constants";
+import type {
+  UserBrief,
+  ReactionGroup,
+  ActivityItem,
+} from "@/components/story/types";
+
+export const USER_BRIEF_SELECT = {
+  id: true,
+  username: true,
+  email: true,
+  avatarConfig: true,
+  bgShape: true,
+  bgColor: true,
+} satisfies Prisma.UserDefaultArgs["select"];
+
+export const STORY_LIST_SELECT = {
+  id: true,
+  identifier: true,
+  sequenceId: true,
+  name: true,
+  description: true,
+  state: true,
+  priority: true,
+  archived: true,
+  startDate: true,
+  targetDate: true,
+  boardOrder: true,
+  projectId: true,
+  parentId: true,
+  parent: { select: { id: true, name: true, state: true, identifier: true } },
+  assignee: { select: USER_BRIEF_SELECT },
+  createdBy: { select: USER_BRIEF_SELECT },
+  updatedBy: { select: USER_BRIEF_SELECT },
+  labels: { select: { label: { select: { id: true, name: true, color: true } } } },
+  createdAt: true,
+  updatedAt: true,
+} satisfies Prisma.StoryDefaultArgs["select"];
+
+export const STORY_LIST_SELECT_LIGHT = {
+  id: true,
+  identifier: true,
+  sequenceId: true,
+  name: true,
+  state: true,
+  priority: true,
+  archived: true,
+  startDate: true,
+  targetDate: true,
+  boardOrder: true,
+  projectId: true,
+  parentId: true,
+  parent: { select: { id: true, name: true, state: true, identifier: true } },
+  assignee: { select: USER_BRIEF_SELECT },
+  createdBy: { select: USER_BRIEF_SELECT },
+  labels: { select: { label: { select: { id: true, name: true, color: true } } } },
+  createdAt: true,
+  updatedAt: true,
+  iteration: { select: { id: true, name: true } },
+} satisfies Prisma.StoryDefaultArgs["select"];
+
+export type StoryListRow = Prisma.StoryGetPayload<{ select: typeof STORY_LIST_SELECT }>;
+
+export type StoryListRowLight = Prisma.StoryGetPayload<{ select: typeof STORY_LIST_SELECT_LIGHT }>;
+
+export function castStoryUsers<S extends StoryListRow>(s: S) {
+  return {
+    ...s,
+    state: s.state as StoryState,
+    priority: s.priority as StoryPriority,
+    startDate: s.startDate ? s.startDate.toISOString() : null,
+    targetDate: s.targetDate ? s.targetDate.toISOString() : null,
+    createdAt: s.createdAt.toISOString(),
+    updatedAt: s.updatedAt.toISOString(),
+    assignee: s.assignee
+      ? { ...s.assignee, avatarConfig: (s.assignee.avatarConfig as AvatarConfig | null) ?? null }
+      : null,
+    createdBy: {
+      ...s.createdBy,
+      avatarConfig: (s.createdBy.avatarConfig as AvatarConfig | null) ?? null,
+    },
+    updatedBy: s.updatedBy
+      ? { ...s.updatedBy, avatarConfig: (s.updatedBy.avatarConfig as AvatarConfig | null) ?? null }
+      : null,
+    parent: s.parent ? { id: s.parent.id, title: s.parent.name, status: s.parent.state as StoryState, identifier: s.parent.identifier } : null,
+    labels: s.labels.map((sl) => sl.label),
+  };
+}
+
+export function castStoryUsersLight<S extends StoryListRowLight>(s: S) {
+  return {
+    ...s,
+    description: null,
+    state: s.state as StoryState,
+    priority: s.priority as StoryPriority,
+    startDate: s.startDate ? s.startDate.toISOString() : null,
+    targetDate: s.targetDate ? s.targetDate.toISOString() : null,
+    createdAt: s.createdAt.toISOString(),
+    updatedAt: s.updatedAt.toISOString(),
+    assignee: s.assignee
+      ? { ...s.assignee, avatarConfig: (s.assignee.avatarConfig as AvatarConfig | null) ?? null }
+      : null,
+    createdBy: {
+      ...s.createdBy,
+      avatarConfig: (s.createdBy.avatarConfig as AvatarConfig | null) ?? null,
+    },
+    parent: s.parent ? { id: s.parent.id, title: s.parent.name, status: s.parent.state as StoryState, identifier: s.parent.identifier } : null,
+    labels: s.labels.map((sl) => sl.label),
+  };
+}
+
+export function castUserBrief(u: {
+  id: string;
+  username: string;
+  email: string;
+  avatarConfig: unknown;
+  bgShape: string | null;
+  bgColor: string | null;
+}): UserBrief {
+  return {
+    ...u,
+    avatarConfig: (u.avatarConfig as AvatarConfig | null) ?? null,
+  };
+}
+
+/** 活动记录 select（含 user brief），供 serverFn 返回新创建的活动给 UI 即时追加 */
+export const ACTIVITY_SELECT = {
+  id: true,
+  action: true,
+  field: true,
+  oldValue: true,
+  newValue: true,
+  isAI: true,
+  createdAt: true,
+  user: { select: USER_BRIEF_SELECT },
+} as const;
+
+export interface ActivityRow {
+  id: string;
+  action: string;
+  field: string | null;
+  oldValue: string | null;
+  newValue: string | null;
+  isAI: boolean;
+  createdAt: Date;
+  user: { id: string; username: string; email: string; avatarConfig: unknown; bgShape: string | null; bgColor: string | null };
+}
+
+export function toActivityItem(a: ActivityRow): ActivityItem {
+  return {
+    id: a.id,
+    action: a.action,
+    field: a.field,
+    oldValue: a.oldValue,
+    newValue: a.newValue,
+    isAI: a.isAI,
+    createdAt: a.createdAt.toISOString(),
+    user: castUserBrief(a.user),
+  };
+}
+
+export function aggregateReactions(
+  reactions: { emoji: string; userId: string }[],
+  currentUserId: string,
+): ReactionGroup[] {
+  const map = new Map<string, string[]>();
+  for (const r of reactions) {
+    const arr = map.get(r.emoji) ?? [];
+    arr.push(r.userId);
+    map.set(r.emoji, arr);
+  }
+  return Array.from(map.entries()).map(([emoji, userIds]) => ({
+    emoji,
+    count: userIds.length,
+    userIds,
+    reacted: userIds.includes(currentUserId),
+  }));
+}
+
+export function toValidDate(value: string): Date | null {
+  const d = new Date(value);
+  return isNaN(d.getTime()) ? null : d;
+}
+
+export function toDateOnly(d: Date): string {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+
+export interface StoryTreeNode {
+  id: string;
+  title: string;
+  status: string;
+  parentId: string | null;
+  depth: number;
+  hasChildren: boolean;
+  childrenCount: number;
+  children?: StoryTreeNode[];
+}
+
+export async function buildStoryTree(story: any, depth = 0): Promise<StoryTreeNode> {
+  const prisma = await getPrisma()
+  const childrenCount = await prisma.story.count({
+    where: { parentId: story.id },
+  });
+
+  return {
+    id: story.id,
+    title: story.name,
+    status: story.state,
+    parentId: story.parentId,
+    depth,
+    hasChildren: childrenCount > 0,
+    childrenCount,
+    children: story.children
+      ? await Promise.all(
+          story.children.map((child: any) => buildStoryTree(child, depth + 1)),
+        )
+      : undefined,
+  };
+}
+
+/**
+ * 判断 ancestorId 是否为 descendantId 的祖先（沿 parentId 向上爬链）。
+ *
+ * DB-01：原实现逐级 findUnique，O(depth) 次串行查询且无环保护（环上不含 ancestorId 时死循环）。
+ * 改两轮 findMany 收敛：
+ *   第一轮取两端点行（id/parentId/projectId），第二轮按两端点所属项目批量取 id→parentId 关系
+ *   内存建图后向上爬链（visited + 深度上限 20 防循环引用）。
+ * 查询次数 before: 1 + depth → after: 2（常数，与深度无关）。
+ * 等价性：图缺节点（父链跨 ≥3 个项目的极端脏数据、story 无 projectId）时回退逐级
+ * findUnique 补齐，命中判定与原实现一致。
+ */
+const CHECK_DESCENDANT_MAX_DEPTH = 20;
+
+export async function checkDescendant(
+  ancestorId: string,
+  descendantId: string,
+): Promise<boolean> {
+  const prisma = await getPrisma()
+  const endpoints = await prisma.story.findMany({
+    where: { id: { in: [ancestorId, descendantId] } },
+    select: { id: true, parentId: true, projectId: true },
+  });
+  const descendant = endpoints.find((s) => s.id === descendantId);
+  const ancestor = endpoints.find((s) => s.id === ancestorId);
+  // 端点缺失：原实现爬链永不命中 → false
+  if (!descendant || !ancestor) return false;
+
+  const projectIds = [...new Set(endpoints.map((s) => s.projectId).filter((p): p is string => !!p))];
+  const parentById = new Map<string, string | null>();
+  if (projectIds.length > 0) {
+    const rows = await prisma.story.findMany({
+      where: { projectId: { in: projectIds } },
+      select: { id: true, parentId: true },
+    });
+    for (const row of rows) parentById.set(row.id, row.parentId);
+  }
+
+  // 沿内存图向上爬链；图缺节点时回退逐级 findUnique 补齐（rows 里 parentId 为 null = 链到根）
+  const visited = new Set<string>();
+  let currentId: string = descendantId;
+  let depth = 0;
+  while (depth < CHECK_DESCENDANT_MAX_DEPTH) {
+    let parentId = parentById.get(currentId);
+    if (parentId === undefined && !parentById.has(currentId)) {
+      const row = await prisma.story.findUnique({
+        where: { id: currentId },
+        select: { parentId: true },
+      });
+      if (!row) return false;
+      parentById.set(currentId, row.parentId);
+      parentId = row.parentId;
+    }
+    if (parentId === ancestorId) return true;
+    if (!parentId) return false;
+    if (visited.has(parentId)) return false;
+    visited.add(currentId);
+    depth += 1;
+    currentId = parentId;
+  }
+  return false;
+}