feat: Initial Supabase and Drizzle integration for chat backend

.env.local.example

@@ -6,3 +6,9 @@ SMITHERY_API_KEY="your_smithery_api_key_here"
 # NEXT_PUBLIC_MAPBOX_ACCESS_TOKEN is already used by mapbox-map.tsx
 # Ensure it's also in your .env.local file if you haven't set it up yet.
 # NEXT_PUBLIC_MAPBOX_ACCESS_TOKEN="your_mapbox_public_token_here"
+
+# Supabase Credentials
+NEXT_PUBLIC_SUPABASE_URL="YOUR_SUPABASE_URL_HERE"
+NEXT_PUBLIC_SUPABASE_ANON_KEY="YOUR_SUPABASE_ANON_KEY_HERE"
+SUPABASE_SERVICE_ROLE_KEY="YOUR_SUPABASE_SERVICE_ROLE_KEY_HERE"
+DATABASE_URL="postgresql://postgres:[YOUR-POSTGRES-PASSWORD]@[YOUR-SUPABASE-DB-HOST]:[PORT]/postgres"

app/actions.tsx

@@ -273,6 +273,8 @@ export const AI = createAI<AIState, UIState>({
   onGetUIState: async () => {
     'use server';
 
+    // TODO: This needs to be adapted to use server-side auth if needed for initial UI state based on user.
+    // For now, it only uses getAIState().
     const aiState = getAIState() as AIState;
     if (aiState) {
       const uiState = getUIStateFromAIState(aiState);
@@ -290,13 +292,13 @@ export const AI = createAI<AIState, UIState>({
 
     const { chatId, messages } = state;
     const createdAt = new Date();
-    const userId = 'anonymous';
+    // const userId = 'anonymous'; // Replaced with actual user ID
     const path = `/search/${chatId}`;
     const title =
       messages.length > 0
         ? JSON.parse(messages[0].content)?.input?.substring(0, 100) ||
-          'Untitled'
-        : 'Untitled';
+          'Untitled Chat' // Default title consistency
+        : 'Untitled Chat';
     // Add an 'end' message at the end to determine if the history needs to be reloaded
     const updatedMessages: AIMessage[] = [
       ...messages,
@@ -308,15 +310,28 @@ export const AI = createAI<AIState, UIState>({
       },
     ];
 
-    const chat: Chat = {
+
+    // Get the actual user ID using server-side auth
+    const { getCurrentUserIdOnServer } = await import('@/lib/auth/get-current-user');
+    const actualUserId = await getCurrentUserIdOnServer();
+
+    if (!actualUserId) {
+      console.error("onSetAIState: User not authenticated. Chat not saved.");
+      // Optionally, clear the AI state or handle appropriately
+      // For now, we just won't save if there's no user.
+      // Or, if chats for anonymous users are allowed with a guest ID, that logic would go here.
+      return;
+    }
+
+    const chat: Chat = { // Chat is OldChatType from @/lib/types
       id: chatId,
       createdAt,
-      userId,
+      userId: actualUserId, // Use the authenticated user's ID
       path,
       title,
       messages: updatedMessages,
     };
-    await saveChat(chat);
+    await saveChat(chat, actualUserId); // Pass actualUserId to saveChat
   },
 });
 

app/api/chat/route.ts

@@ -0,0 +1,68 @@
+import { NextResponse, NextRequest } from 'next/server';
+import { saveChat, createMessage, NewChat, NewMessage } from '@/lib/actions/chat-db';
+import { getCurrentUserIdOnServer } from '@/lib/auth/get-current-user';
+// import { generateUUID } from '@/lib/utils'; // Assuming generateUUID is in lib/utils as per PR context - not needed for PKs
+
+// This is a simplified POST handler. PR #533's version might be more complex,
+// potentially handling streaming AI responses and then saving.
+// For now, this focuses on the database interaction part.
+export async function POST(request: NextRequest) {
+  try {
+    const userId = await getCurrentUserIdOnServer();
+    if (!userId) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const body = await request.json();
+
+    // Example: Distinguish between creating a new chat vs. adding a message to existing chat
+    // The actual structure of `body` would depend on client-side implementation.
+    // Let's assume a simple case: creating a new chat with an initial message.
+    const { title, initialMessageContent, role = 'user' } = body;
+
+    if (!initialMessageContent) {
+        return NextResponse.json({ error: 'Initial message content is required' }, { status: 400 });
+    }
+
+    const newChatData: NewChat = {
+      // id: generateUUID(), // Drizzle schema now has defaultRandom for UUIDs
+      userId: userId,
+      title: title || 'New Chat', // Default title if not provided
+      // createdAt: new Date(), // Handled by defaultNow() in schema
+      visibility: 'private', // Default visibility
+    };
+
+    // Use a transaction if creating chat and first message together
+    // For simplicity here, let's assume saveChat handles chat creation and returns ID, then we create a message.
+    // A more robust `saveChat` might create the chat and first message in one go.
+    // The `saveChat` in chat-db.ts is designed to handle this.
+
+    const firstMessage: Omit<NewMessage, 'chatId'> = {
+        // id: generateUUID(), // Drizzle schema now has defaultRandom for UUIDs
+        // chatId is omitted as it will be set by saveChat
+        userId: userId,
+        role: role as NewMessage['role'], // Ensure role type matches schema expectation
+        content: initialMessageContent,
+        // createdAt: new Date(), // Handled by defaultNow() in schema, not strictly needed here
+    };
+
+    // The saveChat in chat-db.ts is designed to take initial messages.
+    const savedChatId = await saveChat(newChatData, [firstMessage]);
+
+    if (!savedChatId) {
+         return NextResponse.json({ error: 'Failed to save chat' }, { status: 500 });
+    }
+
+    // Fetch the newly created chat and message to return (optional, but good for client)
+    // For now, just return success and the new chat ID.
+    return NextResponse.json({ message: 'Chat created successfully', chatId: savedChatId }, { status: 201 });
+
+  } catch (error) {
+    console.error('Error in POST /api/chat:', error);
+    let errorMessage = 'Internal Server Error';
+    if (error instanceof Error) {
+        errorMessage = error.message;
+    }
+    return NextResponse.json({ error: errorMessage }, { status: 500 });
+  }
+}

app/api/chats/all/route.ts

@@ -0,0 +1,37 @@
+// Content for app/api/chats/all/route.ts
+import { NextResponse } from 'next/server';
+import { clearHistory as dbClearHistory } from '@/lib/actions/chat-db';
+import { getCurrentUserIdOnServer } from '@/lib/auth/get-current-user';
+import { revalidatePath } from 'next/cache'; // For revalidating after clearing
+
+export async function DELETE() {
+  try {
+    const userId = await getCurrentUserIdOnServer();
+    if (!userId) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const success = await dbClearHistory(userId);
+    if (success) {
+      revalidatePath('/'); // Revalidate home or relevant pages
+      revalidatePath('/search'); // Revalidate search path
+      return NextResponse.json({ message: 'History cleared successfully' }, { status: 200 });
+    } else {
+      // This case might be redundant if dbClearHistory throws an error on failure,
+      // but kept for explicitness if it returns false for "no error but nothing done".
+      return NextResponse.json({ error: 'Failed to clear history' }, { status: 500 });
+    }
+  } catch (error) {
+    console.error('Error clearing history via API:', error);
+    let errorMessage = 'Internal Server Error clearing history';
+    if (error instanceof Error && error.message) {
+        // Use the error message from dbClearHistory if available (e.g., "User ID is required")
+        // This depends on dbClearHistory actually throwing or returning specific error messages.
+        // The current dbClearHistory in chat.ts returns {error: ...} which won't be caught here as an Error instance directly.
+        // However, the dbClearHistory in chat-db.ts returns boolean.
+        // Let's assume if dbClearHistory from chat-db.ts (which returns boolean) fails, it's a generic 500.
+        // If it were to throw, that would be caught.
+    }
+    return NextResponse.json({ error: errorMessage }, { status: 500 });
+  }
+}

app/api/chats/route.ts

@@ -0,0 +1,34 @@
+import { NextResponse, NextRequest } from 'next/server';
+import { getChatsPage } from '@/lib/actions/chat-db';
+import { getCurrentUserIdOnServer } from '@/lib/auth/get-current-user';
+
+export async function GET(request: NextRequest) {
+  try {
+    const userId = await getCurrentUserIdOnServer();
+    if (!userId) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const { searchParams } = new URL(request.url);
+
+    const DEFAULT_LIMIT = 20;
+    const MAX_LIMIT = 100;
+    const DEFAULT_OFFSET = 0;
+
+    let limit = parseInt(searchParams.get('limit') || '', 10);
+    if (isNaN(limit) || limit < 1 || limit > MAX_LIMIT) {
+      limit = DEFAULT_LIMIT;
+    }
+
+    let offset = parseInt(searchParams.get('offset') || '', 10);
+    if (isNaN(offset) || offset < 0) {
+      offset = DEFAULT_OFFSET;
+    }
+
+    const result = await getChatsPage(userId, limit, offset);
+    return NextResponse.json(result);
+  } catch (error) {
+    console.error('Error fetching chats:', error);
+    return NextResponse.json({ error: 'Internal Server Error fetching chats' }, { status: 500 });
+  }
+}

app/search/[id]/page.tsx

@@ -1,41 +1,71 @@
 import { notFound, redirect } from 'next/navigation';
 import { Chat } from '@/components/chat';
-import { getChat } from '@/lib/actions/chat';
+import { getChat, getChatMessages } from '@/lib/actions/chat'; // Added getChatMessages
 import { AI } from '@/app/actions';
 import { MapDataProvider } from '@/components/map/map-data-context';
+import { getCurrentUserIdOnServer } from '@/lib/auth/get-current-user'; // For server-side auth
+import type { AIMessage } from '@/lib/types'; // For AIMessage type
+import type { Message as DrizzleMessage } from '@/lib/actions/chat-db'; // For DrizzleMessage type
 
 export const maxDuration = 60;
 
 export interface SearchPageProps {
-  params: Promise<{ id: string }>; // Change to Promise
+  params: Promise<{ id: string }>; // Keep as is for now
 }
 
 export async function generateMetadata({ params }: SearchPageProps) {
-  const { id } = await params; // Unwrap the Promise
-  const chat = await getChat(id, 'anonymous');
+  const { id } = await params; // Keep as is for now
+  // TODO: Metadata generation might need authenticated user if chats are private
+  // For now, assuming getChat can be called or it handles anon access for metadata appropriately
+  const userId = await getCurrentUserIdOnServer(); // Attempt to get user for metadata
+  const chat = await getChat(id, userId || 'anonymous'); // Pass userId or 'anonymous' if none
   return {
-    title: chat?.title.toString().slice(0, 50) || 'Search',
+    title: chat?.title?.toString().slice(0, 50) || 'Search',
   };
 }
 
 export default async function SearchPage({ params }: SearchPageProps) {
-  const { id } = await params; // Unwrap the Promise
-  const userId = 'anonymous';
-  const chat = await getChat(id, userId);
+  const { id } = await params; // Keep as is for now
+  const userId = await getCurrentUserIdOnServer();
 
-  if (!chat) {
+  if (!userId) {
+    // If no user, redirect to login or show appropriate page
+    // For now, redirecting to home, but a login page would be better.
     redirect('/');
   }
 
-  if (chat?.userId !== userId) {
+  const chat = await getChat(id, userId);
+
+  if (!chat) {
+    // If chat doesn't exist or user doesn't have access (handled by getChat)
     notFound();
   }
 
+  // Fetch messages for the chat
+  const dbMessages: DrizzleMessage[] = await getChatMessages(chat.id);
+
+  // Transform DrizzleMessages to AIMessages
+  const initialMessages: AIMessage[] = dbMessages.map((dbMsg): AIMessage => {
+    return {
+      id: dbMsg.id,
+      role: dbMsg.role as AIMessage['role'], // Cast role, ensure AIMessage['role'] includes all dbMsg.role possibilities
+      content: dbMsg.content,
+      createdAt: dbMsg.createdAt ? new Date(dbMsg.createdAt) : undefined,
+      // 'type' and 'name' are not in the basic Drizzle 'messages' schema.
+      // These would be undefined unless specific logic is added to derive them.
+      // For instance, if a message with role 'tool' should have a 'name',
+      // or if some messages have a specific 'type' based on content or other flags.
+      // This mapping assumes standard user/assistant messages primarily.
+    };
+  });
+
   return (
     <AI
       initialAIState={{
         chatId: chat.id,
-        messages: chat.messages,
+        messages: initialMessages, // Use the transformed messages from the database
+        // isSharePage: true, // This was in PR#533, but share functionality is removed.
+                             // If needed for styling or other logic, it can be set.
       }}
     >
       <MapDataProvider>