Momento/memento-note/app/api/ai/echo/connections/route.ts

import { NextRequest, NextResponse } from 'next/server'
import { auth } from '@/auth'
import { memoryEchoService } from '@/lib/ai/services/memory-echo.service'

/**
 * GET /api/ai/echo/connections?noteId={id}&page={page}&limit={limit}
 * Fetch all connections for a specific note
 */
export async function GET(req: NextRequest) {
  try {
    const session = await auth()

    if (!session?.user?.id) {
      return NextResponse.json(
        { error: 'Unauthorized' },
        { status: 401 }
      )
    }

    // Get query parameters
    const { searchParams } = new URL(req.url)
    const noteId = searchParams.get('noteId')
    const page = parseInt(searchParams.get('page') || '1')
    const limit = parseInt(searchParams.get('limit') || '10')

    // Validate noteId
    if (!noteId) {
      return NextResponse.json(
        { error: 'noteId parameter is required' },
        { status: 400 }
      )
    }

    // Validate pagination parameters
    if (page < 1 || limit < 1 || limit > 50) {
      return NextResponse.json(
        { error: 'Invalid pagination parameters. page >= 1, limit between 1 and 50' },
        { status: 400 }
      )
    }

    // Get all connections for the note
    const allConnections = await memoryEchoService.getConnectionsForNote(noteId, session.user.id)

    // Calculate pagination
    const total = allConnections.length
    const startIndex = (page - 1) * limit
    const endIndex = startIndex + limit
    const paginatedConnections = allConnections.slice(startIndex, endIndex)

    // Format connections for response
    const connections = paginatedConnections.map(conn => {
      // Determine which note is the "other" note (not the target note)
      const isNote1Target = conn.note1.id === noteId
      const otherNote = isNote1Target ? conn.note2 : conn.note1

      return {
        noteId: otherNote.id,
        title: otherNote.title,
        content: otherNote.content,
        createdAt: otherNote.createdAt,
        similarity: conn.similarityScore,
        daysApart: conn.daysApart
      }
    })

    return NextResponse.json({
      connections,
      pagination: {
        total,
        page,
        limit,
        totalPages: Math.ceil(total / limit),
        hasNext: endIndex < total,
        hasPrev: page > 1
      }
    })

  } catch (error) {
    return NextResponse.json(
      { error: 'Failed to fetch connections' },
      { status: 500 }
    )
  }
}