Fix: Persist inquiry read status and archival state to server

Author: pavanpaik

web/prisma/schema.prisma

@@ -23,8 +23,10 @@ model Ticket {
   userId    String
   createdAt DateTime  @default(now())
   updatedAt DateTime  @updatedAt
-  messages  Message[]
-  user      User      @relation(fields: [userId], references: [id])
+  messages          Message[]
+  user              User      @relation(fields: [userId], references: [id])
+  lastReadMessageId String?
+  isArchived        Boolean   @default(false)
 
   @@index([userId])
 }

web/src/actions/tickets.ts

@@ -271,3 +271,66 @@ export async function userReplyToTicket(ticketId: string, text: string) {
         return { success: false, error: 'Failed to send follow-up' };
     }
 }
+
+export async function updateTicketReadStatus(ticketId: string, messageId: string) {
+    try {
+        const clerkUser = await currentUser();
+        const userEmail = clerkUser?.emailAddresses[0]?.emailAddress;
+
+        if (!userEmail) {
+            return { success: false, error: 'Unauthorized' };
+        }
+
+        // Verify ownership
+        const ticket = await prisma.ticket.findUnique({
+            where: { id: ticketId },
+            include: { user: true }
+        });
+
+        if (!ticket || ticket.user.email !== userEmail) {
+            return { success: false, error: 'Unauthorized' };
+        }
+
+        await prisma.ticket.update({
+            where: { id: ticketId },
+            data: { lastReadMessageId: messageId }
+        });
+
+        return { success: true };
+    } catch (error) {
+        console.error('Error updating read status:', error);
+        return { success: false, error: 'Failed to update' };
+    }
+}
+
+export async function archiveTicket(ticketId: string) {
+    try {
+        const clerkUser = await currentUser();
+        const userEmail = clerkUser?.emailAddresses[0]?.emailAddress;
+
+        if (!userEmail) {
+            return { success: false, error: 'Unauthorized' };
+        }
+
+        // Verify ownership
+        const ticket = await prisma.ticket.findUnique({
+            where: { id: ticketId },
+            include: { user: true }
+        });
+
+        if (!ticket || ticket.user.email !== userEmail) {
+            return { success: false, error: 'Unauthorized' };
+        }
+
+        await prisma.ticket.update({
+            where: { id: ticketId },
+            data: { isArchived: true }
+        });
+
+        revalidatePath('/ask');
+        return { success: true };
+    } catch (error) {
+        console.error('Error archiving ticket:', error);
+        return { success: false, error: 'Failed to archive' };
+    }
+}

web/src/context/InquiryContext.tsx

@@ -53,7 +53,26 @@ export function InquiryProvider({ children }: { children: React.ReactNode }) {
 
         try {
             const data = await getTickets();
-            setTickets(data as Ticket[]);
+            const ticketsData = data as Ticket[];
+            setTickets(ticketsData);
+
+            // Populate state from DB persistence
+            const dbReadMessages: { [key: string]: string } = {};
+            const dbAcknowledgedTickets: string[] = [];
+
+            ticketsData.forEach((t: any) => {
+                if (t.lastReadMessageId) {
+                    dbReadMessages[t.id] = t.lastReadMessageId;
+                }
+                if (t.isArchived) {
+                    dbAcknowledgedTickets.push(t.id);
+                }
+            });
+
+            // Merge with local state to avoid race conditions/glitches, prioritizing DB if present
+            setReadMessages(prev => ({ ...prev, ...dbReadMessages }));
+            setAcknowledgedTickets(prev => Array.from(new Set([...prev, ...dbAcknowledgedTickets])));
+
         } catch (error) {
             console.error('Failed to fetch tickets in context:', error);
         } finally {
@@ -89,17 +108,28 @@ export function InquiryProvider({ children }: { children: React.ReactNode }) {
         }
     }, [isLoaded, isSignedIn, fetchTickets]);
 
-    const markAsRead = (ticketId: string, messageId: string) => {
+    const markAsRead = async (ticketId: string, messageId: string) => {
+        // Optimistic update
         const next = { ...readMessages, [ticketId]: messageId };
         setReadMessages(next);
         localStorage.setItem('krishnasagar_read_messages', JSON.stringify(next));
+
+        // Server update
+        // Dynamically import to avoid circular dependency issues if any
+        const { updateTicketReadStatus } = await import('@/actions/tickets');
+        await updateTicketReadStatus(ticketId, messageId);
     };
 
-    const acknowledgeTicket = (ticketId: string) => {
+    const acknowledgeTicket = async (ticketId: string) => {
         if (!acknowledgedTickets.includes(ticketId)) {
+            // Optimistic update
             const next = [...acknowledgedTickets, ticketId];
             setAcknowledgedTickets(next);
             localStorage.setItem('krishnasagar_acknowledged_tickets', JSON.stringify(next));
+
+            // Server update
+            const { archiveTicket } = await import('@/actions/tickets');
+            await archiveTicket(ticketId);
         }
     };