refactor(db): migrate app pages and APIs from Prisma facade to Drizzle

Co-authored-by: Cursor <[email protected]>

src/app/(site)/events/[slugOrId]/page.tsx

@@ -1,11 +1,20 @@
+import { and, asc, count, eq, inArray } from "drizzle-orm";
 import Image from "next/image";
 import Link from "next/link";
 import { notFound } from "next/navigation";
 import { getTranslations } from "next-intl/server";
 import { ContentCard, EmptyState } from "@/components/public/ui";
 import { auth } from "@/lib/auth";
+import {
+	db,
+	User,
+	WebsiteEvent,
+	WebsiteEventPrize,
+	WebsiteEventRegistration,
+	WebsiteEventType,
+	WebsiteEventWinner,
+} from "@/lib/db";
 import { formatDate } from "@/lib/format-date";
-import { prisma } from "@/lib/prisma";
 import { EventRegisterButton } from "./event-register-button";
 
 export const dynamic = "force-dynamic";
@@ -30,47 +39,95 @@ export default async function EventDetailPage({
 	const session = await auth();
 	const userId = Number(session?.user?.id);
 
-	const event = await prisma.websiteEvent
-		.findUnique({
-			where: { id: eventId },
-			include: {
-				type: true,
-				prizes: { orderBy: { position: "asc" } },
-				winners: { orderBy: { position: "asc" } },
-				_count: { select: { registrations: true } },
-			},
+	const [eventRow] = await db
+		.select({
+			id: WebsiteEvent.id,
+			title: WebsiteEvent.title,
+			description: WebsiteEvent.description,
+			status: WebsiteEvent.status,
+			image: WebsiteEvent.image,
+			startsAt: WebsiteEvent.startsAt,
+			endsAt: WebsiteEvent.endsAt,
+			maxPlayers: WebsiteEvent.maxPlayers,
+			typeId: WebsiteEvent.typeId,
+			typeName: WebsiteEventType.name,
+			typeColor: WebsiteEventType.color,
+			typeSlug: WebsiteEventType.slug,
 		})
-		.catch(() => null);
+		.from(WebsiteEvent)
+		.innerJoin(WebsiteEventType, eq(WebsiteEvent.typeId, WebsiteEventType.id))
+		.where(eq(WebsiteEvent.id, eventId))
+		.limit(1)
+		.catch(() => []);
 
 	if (
-		!event ||
-		(event.status !== "published" && event.status !== "completed")
+		!eventRow ||
+		(eventRow.status !== "published" && eventRow.status !== "completed")
 	) {
 		notFound();
 	}
 
+	const [prizes, winners, regCountRows] = await Promise.all([
+		db
+			.select()
+			.from(WebsiteEventPrize)
+			.where(eq(WebsiteEventPrize.eventId, eventRow.id))
+			.orderBy(asc(WebsiteEventPrize.position))
+			.catch(() => []),
+		db
+			.select()
+			.from(WebsiteEventWinner)
+			.where(eq(WebsiteEventWinner.eventId, eventRow.id))
+			.orderBy(asc(WebsiteEventWinner.position))
+			.catch(() => []),
+		db
+			.select({ value: count() })
+			.from(WebsiteEventRegistration)
+			.where(eq(WebsiteEventRegistration.eventId, eventRow.id))
+			.catch(() => [{ value: 0 }]),
+	]);
+
+	const event = {
+		...eventRow,
+		type: {
+			name: eventRow.typeName,
+			color: eventRow.typeColor,
+			slug: eventRow.typeSlug,
+		},
+		prizes,
+		winners,
+		_count: { registrations: Number(regCountRows[0]?.value ?? 0) },
+	};
+
 	const alreadyRegistered =
 		Number.isInteger(userId) && userId > 0
 			? Boolean(
-					await prisma.websiteEventRegistration
-						.findUnique({
-							where: { eventId_userId: { eventId: event.id, userId } },
-						})
-						.catch(() => null),
+					(
+						await db
+							.select({ id: WebsiteEventRegistration.id })
+							.from(WebsiteEventRegistration)
+							.where(
+								and(
+									eq(WebsiteEventRegistration.eventId, event.id),
+									eq(WebsiteEventRegistration.userId, userId),
+								),
+							)
+							.limit(1)
+							.catch(() => [])
+					)[0],
 				)
 			: false;
 
 	const winnerIds = event.winners.map((w) => w.userId);
-	const winners =
+	const winnerUsers =
 		winnerIds.length > 0
-			? await prisma.user
-					.findMany({
-						where: { id: { in: winnerIds } },
-						select: { id: true, username: true },
-					})
+			? await db
+					.select({ id: User.id, username: User.username })
+					.from(User)
+					.where(inArray(User.id, winnerIds))
 					.catch(() => [])
 			: [];
-	const winnerName = new Map(winners.map((u) => [u.id, u.username]));
+	const winnerName = new Map(winnerUsers.map((u) => [u.id, u.username]));
 
 	const isFull =
 		event.maxPlayers != null && event._count.registrations >= event.maxPlayers;