File size: 4,505 Bytes
062a991 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 | 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);
}
}
|