0.3.0.0

app/api/trees/[treeId]/members/route.ts

@@ -60,19 +60,20 @@ export async function GET(
       return NextResponse.json({ error: "无权访问此家族树" }, { status: 403 })
     }
 
-    // 获取家族树信息
-    const tree = await prisma.familyTree.findUnique({
-      where: { id: treeId },
-      select: { rootMemberId: true }
-    })
-
-    const members = await prisma.familyMember.findMany({
-      where: { treeId },
-      orderBy: [
-        { generation: 'asc' },
-        { createdAt: 'asc' }
-      ]
-    })
+    // 并行获取家族树信息和成员数据
+    const [tree, members] = await Promise.all([
+      prisma.familyTree.findUnique({
+        where: { id: treeId },
+        select: { rootMemberId: true }
+      }),
+      prisma.familyMember.findMany({
+        where: { treeId },
+        orderBy: [
+          { generation: 'asc' },
+          { createdAt: 'asc' }
+        ]
+      })
+    ])
 
     // 如果没有设置 rootMemberId，尝试找到第一代成员作为根
     let rootId = tree?.rootMemberId
@@ -80,22 +81,14 @@ export async function GET(
       const firstGenMember = members.find((m: any) => m.generation === 1)
       if (firstGenMember) {
         rootId = firstGenMember.id
-        // 更新家族树的 rootMemberId
-        await prisma.familyTree.update({
+        // 异步更新家族树的 rootMemberId（不阻塞响应）
+        prisma.familyTree.update({
           where: { id: treeId },
           data: { rootMemberId: firstGenMember.id }
-        })
+        }).catch(err => console.error('更新 rootMemberId 失败:', err))
       }
     }
 
-    console.log('👥 GET /api/trees/[treeId]/members 返回数据:', {
-      treeId,
-      userId: session.user.id,
-      membersCount: members.length,
-      rootId,
-      members: members.map(m => ({ id: m.id, fullName: m.fullName, generation: m.generation }))
-    })
-
     return NextResponse.json({ members, rootId })
   } catch (error) {
     console.error("获取成员失败:", error)

app/api/trees/[treeId]/route.ts

@@ -17,69 +17,68 @@ export async function GET(
 
     const { treeId } = await params
 
-    const tree = await prisma.familyTree.findFirst({
-      where: {
-        id: treeId,
-        OR: [
-          { ownerId: session.user.id },
-          {
-            collaborators: {
-              some: {
-                userId: session.user.id
+    // 并行查询树信息和协作者角色
+    const [tree, collaborator] = await Promise.all([
+      prisma.familyTree.findFirst({
+        where: {
+          id: treeId,
+          OR: [
+            { ownerId: session.user.id },
+            {
+              collaborators: {
+                some: {
+                  userId: session.user.id
+                }
               }
             }
-          }
-        ]
-      },
-      include: {
-        owner: {
-          select: {
-            id: true,
-            name: true,
-            email: true,
-          }
+          ]
         },
-        _count: {
-          select: {
-            members: true,
-            collaborators: true,
+        select: {
+          id: true,
+          name: true,
+          description: true,
+          rootMemberId: true,
+          ownerId: true,
+          createdAt: true,
+          updatedAt: true,
+          owner: {
+            select: {
+              id: true,
+              name: true,
+              email: true,
+            }
+          },
+          _count: {
+            select: {
+              members: true,
+              collaborators: true,
+            }
           }
         }
-      }
-    })
+      }),
+      prisma.treeCollaborator.findFirst({
+        where: {
+          treeId,
+          userId: session.user.id
+        },
+        select: { role: true }
+      })
+    ])
 
     if (!tree) {
       return NextResponse.json({ error: "家族树不存在或无权访问" }, { status: 404 })
     }
 
     // 计算当前用户角色
-    let currentUserRole = "VIEWER"
-    if (tree.ownerId === session.user.id) {
-      currentUserRole = "OWNER"
-    } else {
-      const collaborator = await prisma.treeCollaborator.findUnique({
-        where: {
-          treeId_userId: {
-            treeId: tree.id,
-            userId: session.user.id
-          }
-        }
-      })
-      if (collaborator) {
-        currentUserRole = collaborator.role
-      }
-    }
+    const currentUserRole = tree.ownerId === session.user.id 
+      ? "OWNER" 
+      : (collaborator?.role || "VIEWER")
 
-    console.log('🌳 GET /api/trees/[treeId] 返回数据:', {
-      treeId,
-      userId: session.user.id,
-      treeName: tree.name,
-      currentUserRole,
-      membersCount: tree._count.members,
-      collaboratorsCount: tree._count.collaborators
-    })
-
-    return NextResponse.json({ tree: { ...tree, currentUserRole } })
+    // 添加缓存头
+    const response = NextResponse.json({ tree: { ...tree, currentUserRole } })
+    response.headers.set('Cache-Control', 'private, max-age=60, stale-while-revalidate=30')
+    
+    return response
   } catch (error) {
     console.error("获取家族树失败:", error)
     return NextResponse.json(

app/api/trees/route.ts

@@ -18,42 +18,59 @@ export async function GET(req: NextRequest) {
       return NextResponse.json({ error: "未授权" }, { status: 401 })
     }
 
-    // 1. 查询拥有的家族树
-    const ownedTrees = await prisma.familyTree.findMany({
-      where: { ownerId: session.user.id },
-      include: {
-        owner: {
-          select: { id: true, name: true, email: true }
+    // 使用并行查询优化性能
+    const [ownedTrees, collaboratedRelations] = await Promise.all([
+      // 1. 查询拥有的家族树 - 只选择必要字段
+      prisma.familyTree.findMany({
+        where: { ownerId: session.user.id },
+        select: {
+          id: true,
+          name: true,
+          description: true,
+          rootMemberId: true,
+          ownerId: true,
+          createdAt: true,
+          updatedAt: true,
+          owner: {
+            select: { id: true, name: true, email: true }
+          },
+          _count: {
+            select: { members: true, collaborators: true }
+          }
         },
-        _count: {
-          select: { members: true, collaborators: true }
-        }
-      },
-      orderBy: { updatedAt: 'desc' }
-    })
-
-    // 2. 查询协作的家族树
-    const collaboratedRelations = await prisma.treeCollaborator.findMany({
-      where: { userId: session.user.id },
-      include: {
-        tree: {
-          include: {
-            owner: {
-              select: { id: true, name: true, email: true }
-            },
-            _count: {
-              select: { members: true, collaborators: true }
+        orderBy: { updatedAt: 'desc' }
+      }),
+      // 2. 查询协作的家族树
+      prisma.treeCollaborator.findMany({
+        where: { userId: session.user.id },
+        select: {
+          role: true,
+          tree: {
+            select: {
+              id: true,
+              name: true,
+              description: true,
+              rootMemberId: true,
+              ownerId: true,
+              createdAt: true,
+              updatedAt: true,
+              owner: {
+                select: { id: true, name: true, email: true }
+              },
+              _count: {
+                select: { members: true, collaborators: true }
+              }
             }
           }
-        }
-      },
-      orderBy: { invitedAt: 'desc' }
-    })
+        },
+        orderBy: { invitedAt: 'desc' }
+      })
+    ])
 
     // 3. 格式化数据
     const formattedOwnedTrees = ownedTrees.map(tree => ({
       ...tree,
-      currentUserRole: "OWNER"
+      currentUserRole: "OWNER" as const
     }))
 
     const formattedCollaboratedTrees = collaboratedRelations.map(relation => ({
@@ -64,14 +81,6 @@ export async function GET(req: NextRequest) {
     // 4. 合并列表
     const trees = [...formattedOwnedTrees, ...formattedCollaboratedTrees]
 
-    console.log('🌳 GET /api/trees 返回数据:', {
-      userId: session.user.id,
-      ownedCount: formattedOwnedTrees.length,
-      collaboratedCount: formattedCollaboratedTrees.length,
-      totalCount: trees.length,
-      trees: trees.map(t => ({ id: t.id, name: t.name, role: t.currentUserRole }))
-    })
-
     return NextResponse.json({ trees })
   } catch (error) {
     console.error("获取家族树失败:", error)

app/api/users/me/seen-help/route.ts

@@ -0,0 +1,24 @@
+import { NextResponse } from "next/server"
+import { getServerSession } from "next-auth"
+import { authOptions } from "@/lib/auth"
+import { prisma } from "@/lib/prisma"
+
+export async function PATCH() {
+  try {
+    const session = await getServerSession(authOptions)
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: "未授权" }, { status: 401 })
+    }
+
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { hasSeenHelp: true },
+    })
+
+    return NextResponse.json({ success: true })
+  } catch (error) {
+    console.error("更新使用帮助标记失败:", error)
+    return NextResponse.json({ error: "更新失败" }, { status: 500 })
+  }
+}