| import { and, desc, eq, inArray, ne } from "drizzle-orm"; |
| import { NextRequest, NextResponse } from "next/server"; |
| import { z } from "zod"; |
| import { getDb } from "@/db"; |
| import { conversationMembers, conversations, messages, notifications, users } from "@/db/schema"; |
| import { ApiError, apiResponseError, readJsonObject, requireSameOrigin, requireUser } from "@/lib/api"; |
|
|
| const messageSchema = z.object({ |
| conversationId: z.string().uuid().optional(), |
| recipientId: z.string().uuid().optional(), |
| body: z.string().trim().min(1).max(4000), |
| }).refine((value) => value.conversationId || value.recipientId, "conversationId or recipientId is required"); |
|
|
| export async function GET(request: NextRequest) { |
| try { |
| const user = await requireUser(request); |
| const db = getDb(); |
| const memberships = await db.select({ conversationId: conversationMembers.conversationId }).from(conversationMembers).where(eq(conversationMembers.userId, user.id)); |
| const ids = memberships.map((row) => row.conversationId); |
| if (!ids.length) return NextResponse.json({ conversations: [] }); |
| const conversationRows = await db.select().from(conversations).where(inArray(conversations.id, ids)).orderBy(desc(conversations.updatedAt)); |
| const messageRows = await db.select().from(messages).where(inArray(messages.conversationId, ids)).orderBy(desc(messages.createdAt)).limit(80); |
| const memberRows = await db.select({ |
| conversationId: conversationMembers.conversationId, |
| user: { id: users.id, name: users.name, username: users.username, headline: users.headline, avatarUrl: users.avatarUrl }, |
| }).from(conversationMembers).innerJoin(users, eq(users.id, conversationMembers.userId)).where(inArray(conversationMembers.conversationId, ids)); |
| return NextResponse.json({ |
| conversations: conversationRows.map((conversation) => ({ |
| ...conversation, |
| members: memberRows.filter((row) => row.conversationId === conversation.id).map((row) => row.user), |
| messages: messageRows.filter((message) => message.conversationId === conversation.id).reverse(), |
| })), |
| }); |
| } catch (error) { |
| return apiResponseError(error); |
| } |
| } |
|
|
| export async function POST(request: NextRequest) { |
| try { |
| requireSameOrigin(request); |
| const user = await requireUser(request); |
| const payload = messageSchema.parse(await readJsonObject(request)); |
| const db = getDb(); |
| let conversationId = payload.conversationId; |
| let notifyUserId = payload.recipientId; |
|
|
| if (conversationId) { |
| const [membership] = await db.select().from(conversationMembers) |
| .where(and(eq(conversationMembers.conversationId, conversationId), eq(conversationMembers.userId, user.id))) |
| .limit(1); |
| if (!membership) throw new ApiError(403, "Conversation is unavailable.", "conversation_forbidden"); |
| } else if (payload.recipientId) { |
| if (payload.recipientId === user.id) throw new ApiError(400, "Choose another member.", "validation_error"); |
| const [recipient] = await db.select().from(users).where(eq(users.id, payload.recipientId)).limit(1); |
| if (!recipient) throw new ApiError(404, "Recipient not found.", "not_found"); |
| const [conversation] = await db.insert(conversations).values({ subject: "" }).returning(); |
| conversationId = conversation.id; |
| await db.insert(conversationMembers).values([ |
| { conversationId, userId: user.id }, |
| { conversationId, userId: payload.recipientId }, |
| ]); |
| } |
|
|
| if (!conversationId) throw new ApiError(400, "Conversation is required.", "validation_error"); |
| const [message] = await db.insert(messages).values({ conversationId, senderId: user.id, body: payload.body }).returning(); |
| await db.update(conversations).set({ updatedAt: new Date() }).where(eq(conversations.id, conversationId)); |
| if (!notifyUserId) { |
| const [other] = await db.select().from(conversationMembers).where(and(eq(conversationMembers.conversationId, conversationId), ne(conversationMembers.userId, user.id))).limit(1); |
| notifyUserId = other?.userId; |
| } |
| if (notifyUserId && notifyUserId !== user.id) { |
| await db.insert(notifications).values({ |
| userId: notifyUserId, |
| actorId: user.id, |
| type: "message", |
| title: `${user.name} sent you a message`, |
| body: payload.body.slice(0, 160), |
| href: "/messages", |
| }); |
| } |
| return NextResponse.json({ message }, { status: 201 }); |
| } catch (error) { |
| return apiResponseError(error); |
| } |
| } |
|
|
