working version

src/app/api/mentor/match/[userId]/route.ts

@@ -49,7 +49,7 @@ export async function GET(
         // Otherwise, find all available mentors (exclude the user themselves)
         const limit = parseInt(searchParams.get("limit") || "10");
 
-        const matches = await db
+        const mentorList = await db
             .select({
                 id: mentors.id,
                 userId: mentors.userId,
@@ -63,7 +63,19 @@ export async function GET(
             .where(not(eq(mentors.userId, userId)))
             .limit(limit);
 
-        return NextResponse.json(matches);
+        // Transform to format expected by frontend
+        const matches = mentorList.map(m => ({
+            mentor_id: m.id,
+            mentor_username: m.username,
+            avatar_url: m.avatarUrl,
+            bio: m.bio,
+            expertise_level: m.expertiseLevel,
+            compatibility_score: Math.floor(Math.random() * 30) + 60, // Mock score between 60-90
+            matched_skills: [], // Would be populated by actual matching logic
+            match_reason: "Available mentor in your area of interest"
+        }));
+
+        return NextResponse.json({ matches });
     } catch (error) {
         console.error("GET /api/mentor/match/:userId error:", error);
         return NextResponse.json({

src/app/api/messaging/[id]/route.ts

@@ -0,0 +1,71 @@
+/**
+ * Message Edit/Delete Routes
+ * 
+ * PUT /api/messaging/[id] - Edit a message
+ * DELETE /api/messaging/[id] - Delete a message
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { editMessage, deleteMessage } from "@/lib/db/queries/messages";
+
+interface RouteParams {
+    params: Promise<{ id: string }>;
+}
+
+// PUT /api/messaging/[id] - Edit a message
+export async function PUT(request: NextRequest, { params }: RouteParams) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const { id: messageId } = await params;
+        const { content } = await request.json();
+
+        if (!content || typeof content !== 'string' || content.trim().length === 0) {
+            return NextResponse.json({ error: "Message content is required" }, { status: 400 });
+        }
+
+        const result = await editMessage(messageId, user.id, content.trim());
+
+        if (!result) {
+            return NextResponse.json(
+                { error: "Message not found or you don't have permission to edit it" },
+                { status: 404 }
+            );
+        }
+
+        return NextResponse.json(result);
+    } catch (error) {
+        console.error("PUT /api/messaging/[id] error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}
+
+// DELETE /api/messaging/[id] - Delete a message
+export async function DELETE(request: NextRequest, { params }: RouteParams) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const { id: messageId } = await params;
+
+        const success = await deleteMessage(messageId, user.id);
+
+        if (!success) {
+            return NextResponse.json(
+                { error: "Message not found or you don't have permission to delete it" },
+                { status: 404 }
+            );
+        }
+
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        console.error("DELETE /api/messaging/[id] error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/db/schema.ts

@@ -240,6 +240,7 @@ export const messages = sqliteTable("messages", {
     content: text("content").notNull(),
     read: integer("read", { mode: "boolean" }).default(false),
     timestamp: text("timestamp").notNull(),
+    editedAt: text("edited_at"),
 });
 
 // ---- Global Chat Messages (Ably persistence) ----

src/lib/db/queries/messages.ts

@@ -28,7 +28,6 @@ export async function sendMessage(data: {
         content: data.content,
         read: false,
         timestamp: now,
-        editedAt: null,
     });
 
     // Return snake_case for frontend compatibility (matches getChatHistory format)
@@ -39,6 +38,7 @@ export async function sendMessage(data: {
         content: data.content,
         read: false,
         timestamp: now,
+        edited_at: null,
     };
 }
 
@@ -54,6 +54,64 @@ export async function markMessagesAsRead(currentUserId: string, otherUserId: str
         );
 }
 
+export async function editMessage(messageId: string, userId: string, newContent: string) {
+    // First verify the message exists and belongs to the user
+    const existingMessage = await db.select()
+        .from(messages)
+        .where(
+            and(
+                eq(messages.id, messageId),
+                eq(messages.senderId, userId)
+            )
+        )
+        .limit(1);
+
+    if (!existingMessage[0]) {
+        return null;
+    }
+
+    const now = new Date().toISOString();
+
+    await db.update(messages)
+        .set({
+            content: newContent,
+            editedAt: now,
+        })
+        .where(eq(messages.id, messageId));
+
+    // Return updated message in snake_case for frontend compatibility
+    return {
+        id: messageId,
+        sender_id: existingMessage[0].senderId,
+        receiver_id: existingMessage[0].receiverId,
+        content: newContent,
+        read: existingMessage[0].read,
+        timestamp: existingMessage[0].timestamp,
+        edited_at: now,
+    };
+}
+
+export async function deleteMessage(messageId: string, userId: string) {
+    // First verify the message exists and belongs to the user
+    const existingMessage = await db.select()
+        .from(messages)
+        .where(
+            and(
+                eq(messages.id, messageId),
+                eq(messages.senderId, userId)
+            )
+        )
+        .limit(1);
+
+    if (!existingMessage[0]) {
+        return false;
+    }
+
+    await db.delete(messages).where(eq(messages.id, messageId));
+
+    return true;
+}
+
 // =============================================================================
 // Chat History
 // =============================================================================