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

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

src/actions/shop.ts

@@ -1,13 +1,14 @@
 "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, WebsiteShopArticles } from "@/lib/db";
 import { clientIp, rateLimit } from "@/lib/rate-limit";
 import { creditsPerUnit } from "@/lib/services/paypal";
 import { rcon } from "@/lib/services/rcon";
-import { sendCurrency } from "@/lib/services/send-currency";
+import { currencyDb, sendCurrency } from "@/lib/services/send-currency";
 
 /**
  * Credits charged for a package row. AtomCMS stores `costs` in cents (USD display);
@@ -86,19 +87,20 @@ export async function buyShopArticle(formData: FormData): Promise<void> {
 			if (!/^\d+$/.test(rawId)) {
 				outcome = "invalid";
 			} else {
-				const article = await prisma.websiteShopArticles.findUnique({
-					where: { id: BigInt(rawId) },
-					select: {
-						id: true,
-						name: true,
-						costs: true,
-						credits: true,
-						duckets: true,
-						diamonds: true,
-						badges: true,
-						giveRank: true,
-					},
-				});
+				const [article] = await db
+					.select({
+						id: WebsiteShopArticles.id,
+						name: WebsiteShopArticles.name,
+						costs: WebsiteShopArticles.costs,
+						credits: WebsiteShopArticles.credits,
+						duckets: WebsiteShopArticles.duckets,
+						diamonds: WebsiteShopArticles.diamonds,
+						badges: WebsiteShopArticles.badges,
+						giveRank: WebsiteShopArticles.giveRank,
+					})
+					.from(WebsiteShopArticles)
+					.where(eq(WebsiteShopArticles.id, BigInt(rawId)))
+					.limit(1);
 
 				if (!article) {
 					outcome = "invalid";
@@ -106,21 +108,22 @@ export async function buyShopArticle(formData: FormData): Promise<void> {
 					packageName = article.name;
 					const price = creditPriceFromCosts(article.costs);
 
-					const buyer = await prisma.user.findUnique({
-						where: { id: userId },
-						select: { credits: true, rank: true },
-					});
+					const [buyer] = await db
+						.select({ credits: User.credits, rank: User.rank })
+						.from(User)
+						.where(eq(User.id, userId))
+						.limit(1);
 					if (!buyer || buyer.credits < price) {
 						outcome = "credits";
 					} else {
 						const badgeCodes = parseBadgeCodes(article.badges);
 
-						await prisma.$transaction(async (tx) => {
+						await db.transaction(async (tx) => {
 							if (price > 0) {
-								await tx.user.update({
-									where: { id: userId },
-									data: { credits: { decrement: price } },
-								});
+								await tx
+									.update(User)
+									.set({ credits: sql`${User.credits} - ${price}` })
+									.where(eq(User.id, userId));
 							}
 
 							if (
@@ -128,44 +131,52 @@ export async function buyShopArticle(formData: FormData): Promise<void> {
 								article.giveRank > 0 &&
 								article.giveRank > buyer.rank
 							) {
-								await tx.user.update({
-									where: { id: userId },
-									data: { rank: article.giveRank },
-								});
+								await tx
+									.update(User)
+									.set({ rank: article.giveRank })
+									.where(eq(User.id, userId));
 							}
 
 							for (const code of badgeCodes) {
-								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,
 									});
 								}
 							}
 						});
 
 						await sendCurrency(
-							{ rcon, db: prisma },
+							{ rcon, db: currencyDb },
 							userId,
 							"credits",
 							article.credits,
 						);
 						await sendCurrency(
-							{ rcon, db: prisma },
+							{ rcon, db: currencyDb },
 							userId,
 							"duckets",
 							article.duckets,
 						);
 						await sendCurrency(
-							{ rcon, db: prisma },
+							{ rcon, db: currencyDb },
 							userId,
 							"diamonds",
 							article.diamonds,