refactor(db): migrate staff and app actions from Prisma facade to Drizzle

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

src/actions/draw-badge.ts

@@ -1,9 +1,10 @@
 "use server";
 
+import { and, eq, max, sql } from "drizzle-orm";
 import { revalidatePath } from "next/cache";
 import { redirect } from "next/navigation";
 import { auth } from "@/lib/auth";
-import { prisma } from "@/lib/prisma";
+import { db, User, UsersBadges, WebsiteDrawbadges } from "@/lib/db";
 import { clientIp, rateLimit } from "@/lib/rate-limit";
 import { rcon } from "@/lib/services/rcon";
 import { siteSettings } from "@/lib/services/site-settings";
@@ -63,10 +64,15 @@ export async function buyBadge(formData: FormData): Promise<void> {
 		if (!(await rateLimit(`draw-badge-buy:${userId}`, 5, 60_000)).ok) {
 			outcome = "ratelimit";
 		} else {
-			const badge = await prisma.websiteDrawbadges.findUnique({
-				where: { id: BigInt(rawId) },
-				select: { id: true, badgePath: true, published: true },
-			});
+			const [badge] = await db
+				.select({
+					id: WebsiteDrawbadges.id,
+					badgePath: WebsiteDrawbadges.badgePath,
+					published: WebsiteDrawbadges.published,
+				})
+				.from(WebsiteDrawbadges)
+				.where(eq(WebsiteDrawbadges.id, BigInt(rawId)))
+				.limit(1);
 
 			if (!badge?.published) {
 				outcome = "invalid";
@@ -78,34 +84,43 @@ export async function buyBadge(formData: FormData): Promise<void> {
 					const price = await resolvePrice();
 
 					// Re-read the buyer's live credit balance and verify it covers the cost.
-					const buyer = await prisma.user.findUnique({
-						where: { id: userId },
-						select: { credits: true },
-					});
+					const [buyer] = await db
+						.select({ credits: User.credits })
+						.from(User)
+						.where(eq(User.id, userId))
+						.limit(1);
 					if (!buyer || buyer.credits < price) {
 						outcome = "credits";
 					} else {
 						// Atomically deduct credits and persist the badge so a failure
 						// between the two operations cannot orphan the user.
 						if (price > 0) {
-							await prisma.$transaction(async (tx) => {
-								await tx.user.update({
-									where: { id: userId },
-									data: { credits: { decrement: price } },
-								});
+							await db.transaction(async (tx) => {
+								await tx
+									.update(User)
+									.set({ credits: sql`${User.credits} - ${price}` })
+									.where(eq(User.id, userId));
 
-								const existing = await tx.usersBadges.findFirst({
-									where: { userId, badgeCode: code },
-									select: { id: true },
-								});
+								const [existing] = await tx
+									.select({ id: UsersBadges.id })
+									.from(UsersBadges)
+									.where(
+										and(
+											eq(UsersBadges.userId, userId),
+											eq(UsersBadges.badgeCode, code),
+										),
+									)
+									.limit(1);
 								if (!existing) {
-									const max = await tx.usersBadges.aggregate({
-										where: { userId },
-										_max: { slotId: true },
-									});
-									const slotId = (max._max.slotId ?? 0) + 1;
-									await tx.usersBadges.create({
-										data: { userId, slotId, badgeCode: code },
+									const [agg] = await tx
+										.select({ maxSlot: max(UsersBadges.slotId) })
+										.from(UsersBadges)
+										.where(eq(UsersBadges.userId, userId));
+									const slotId = (agg?.maxSlot ?? 0) + 1;
+									await tx.insert(UsersBadges).values({
+										userId,
+										slotId,
+										badgeCode: code,
 									});
 								}
 							});