Momento/memento-note/app/api/notebooks/route.ts

import { NextRequest, NextResponse } from 'next/server'
import prisma from '@/lib/prisma'
import { auth } from '@/auth'
import { revalidatePath } from 'next/cache'

const DEFAULT_COLORS = ['#3B82F6', '#8B5CF6', '#EC4899', '#F59E0B', '#10B981', '#06B6D4']
const DEFAULT_ICONS = ['📁', '📚', '💼', '🎯', '📊', '🎨', '💡', '🔧']

function buildTree(notebooks: any[]): any[] {
  const map = new Map<string, any>()
  const roots: any[] = []
  for (const nb of notebooks) {
    map.set(nb.id, { ...nb, children: [] })
  }
  for (const nb of notebooks) {
    const node = map.get(nb.id)!
    if (nb.parentId && map.has(nb.parentId)) {
      map.get(nb.parentId)!.children.push(node)
    } else {
      roots.push(node)
    }
  }
  return roots
}

export async function GET(request: NextRequest) {
  const session = await auth()
  if (!session?.user?.id) {
    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
  }

  try {
    const notebooks = await prisma.notebook.findMany({
      where: { userId: session.user.id, trashedAt: null },
      include: {
        labels: { orderBy: { name: 'asc' } },
        _count: {
          select: { notes: { where: { isArchived: false, trashedAt: null } } }
        }
      },
      orderBy: { order: 'asc' }
    })

    const flat = notebooks.map(nb => ({
      ...nb,
      notesCount: nb._count.notes
    }))

    const tree = buildTree(flat)

    return NextResponse.json({ success: true, notebooks: flat, tree })
  } catch (error) {
    console.error('Error fetching notebooks:', error)
    return NextResponse.json({ success: false, error: 'Failed to fetch notebooks' }, { status: 500 })
  }
}

export async function POST(request: NextRequest) {
  const session = await auth()
  if (!session?.user?.id) {
    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
  }

  try {
    const body = await request.json()
    const { name, icon, color, parentId } = body

    if (!name || typeof name !== 'string') {
      return NextResponse.json({ success: false, error: 'Notebook name is required' }, { status: 400 })
    }

    if (parentId) {
      const parent = await prisma.notebook.findFirst({
        where: { id: parentId, userId: session.user.id }
      })
      if (!parent) {
        return NextResponse.json({ success: false, error: 'Parent notebook not found' }, { status: 400 })
      }
    }

    const whereClause: any = { userId: session.user.id }
    if (parentId) whereClause.parentId = parentId
    else whereClause.parentId = null

    const highestOrder = await prisma.notebook.findFirst({
      where: whereClause,
      orderBy: { order: 'desc' },
      select: { order: true }
    })

    const nextOrder = (highestOrder?.order ?? -1) + 1

    const notebook = await prisma.notebook.create({
      data: {
        name: name.trim(),
        icon: icon || DEFAULT_ICONS[Math.floor(Math.random() * DEFAULT_ICONS.length)],
        color: color || DEFAULT_COLORS[Math.floor(Math.random() * DEFAULT_COLORS.length)],
        order: nextOrder,
        parentId: parentId || null,
        userId: session.user.id
      },
      include: {
        labels: true,
        _count: { select: { notes: { where: { isArchived: false, trashedAt: null } } } }
      }
    })

    try { revalidatePath('/home') } catch {}

    return NextResponse.json({
      success: true,
      ...notebook,
      notesCount: notebook._count.notes
    }, { status: 201 })
  } catch (error) {
    console.error('Error creating notebook:', error)
    return NextResponse.json({ success: false, error: 'Failed to create notebook' }, { status: 500 })
  }
}