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

Co-authored-by: Cursor <[email protected]>
This commit is contained in:
SimoandCursor committed 2026-07-31 21:35:05 +02:00
1 parent 9854719cfd
commit ed9c23c702
85 files changed
+2612 -1832

No files matched your search

+126 -78
View File
@@ -1,9 +1,16 @@
"use server";
import { and, eq, or } 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,
MessengerFriendrequests,
MessengerFriendships,
MessengerOffline,
User,
} from "@/lib/db";
import { clientIp, rateLimit } from "@/lib/rate-limit";
type FriendOutcome =
@@ -76,10 +83,15 @@ export async function acceptFriend(formData: FormData): Promise<void> {
outcome = "invalid";
} else {
// The request must exist AND be addressed to the session user.
const request = await prisma.messengerFriendrequests.findUnique({
where: { id: requestId },
select: { id: true, userFromId: true, userToId: true },
});
const [request] = await db
.select({
id: MessengerFriendrequests.id,
userFromId: MessengerFriendrequests.userFromId,
userToId: MessengerFriendrequests.userToId,
})
.from(MessengerFriendrequests)
.where(eq(MessengerFriendrequests.id, requestId))
.limit(1);
if (!request) {
outcome = "not_found";
} else if (request.userToId !== meId) {
@@ -92,44 +104,55 @@ export async function acceptFriend(formData: FormData): Promise<void> {
friendId === meId
) {
// Malformed/self request — clear it and treat as not found.
await prisma.messengerFriendrequests.delete({
where: { id: requestId },
});
await db
.delete(MessengerFriendrequests)
.where(eq(MessengerFriendrequests.id, requestId));
outcome = "not_found";
} else {
const friendsSince = Math.floor(Date.now() / 1000);
await prisma.$transaction(async (tx) => {
await db.transaction(async (tx) => {
// Don't double-insert if a friendship already exists in either direction.
const existing = await tx.messengerFriendships.findFirst({
where: {
OR: [
{ userOneId: meId, userTwoId: friendId },
{ userOneId: friendId, userTwoId: meId },
],
},
select: { id: true },
});
const [existing] = await tx
.select({ id: MessengerFriendships.id })
.from(MessengerFriendships)
.where(
or(
and(
eq(MessengerFriendships.userOneId, meId),
eq(MessengerFriendships.userTwoId, friendId),
),
and(
eq(MessengerFriendships.userOneId, friendId),
eq(MessengerFriendships.userTwoId, meId),
),
),
)
.limit(1);
if (!existing) {
await tx.messengerFriendships.createMany({
data: [
{ userOneId: meId, userTwoId: friendId, friendsSince },
{ userOneId: friendId, userTwoId: meId, friendsSince },
],
});
await tx.insert(MessengerFriendships).values([
{ userOneId: meId, userTwoId: friendId, friendsSince },
{ userOneId: friendId, userTwoId: meId, friendsSince },
]);
}
// Clear this request and any reverse pending request between the pair.
await tx.messengerFriendrequests.deleteMany({
where: {
OR: [
{ id: requestId },
{ userFromId: meId, userToId: friendId },
{ userFromId: friendId, userToId: meId },
],
},
});
await tx
.delete(MessengerFriendrequests)
.where(
or(
eq(MessengerFriendrequests.id, requestId),
and(
eq(MessengerFriendrequests.userFromId, meId),
eq(MessengerFriendrequests.userToId, friendId),
),
and(
eq(MessengerFriendrequests.userFromId, friendId),
eq(MessengerFriendrequests.userToId, meId),
),
),
);
});
outcome = "accepted";
@@ -180,18 +203,22 @@ export async function declineFriendRequest(formData: FormData): Promise<void> {
if (!Number.isInteger(requestId) || requestId <= 0) {
outcome = "invalid";
} else {
const request = await prisma.messengerFriendrequests.findUnique({
where: { id: requestId },
select: { id: true, userToId: true },
});
const [request] = await db
.select({
id: MessengerFriendrequests.id,
userToId: MessengerFriendrequests.userToId,
})
.from(MessengerFriendrequests)
.where(eq(MessengerFriendrequests.id, requestId))
.limit(1);
if (!request) {
outcome = "not_found";
} else if (request.userToId !== meId) {
outcome = "unauthorized";
} else {
await prisma.messengerFriendrequests.delete({
where: { id: requestId },
});
await db
.delete(MessengerFriendrequests)
.where(eq(MessengerFriendrequests.id, requestId));
outcome = "declined";
}
}
@@ -239,26 +266,41 @@ export async function removeFriendship(formData: FormData): Promise<void> {
if (!Number.isInteger(friendId) || friendId <= 0 || friendId === meId) {
outcome = "invalid";
} else {
const deleted = await prisma.$transaction(async (tx) => {
const result = await tx.messengerFriendships.deleteMany({
where: {
OR: [
{ userOneId: meId, userTwoId: friendId },
{ userOneId: friendId, userTwoId: meId },
],
},
});
const deleted = await db.transaction(async (tx) => {
const result = await tx
.delete(MessengerFriendships)
.where(
or(
and(
eq(MessengerFriendships.userOneId, meId),
eq(MessengerFriendships.userTwoId, friendId),
),
and(
eq(MessengerFriendships.userOneId, friendId),
eq(MessengerFriendships.userTwoId, meId),
),
),
);
await tx.messengerFriendrequests.deleteMany({
where: {
OR: [
{ userFromId: meId, userToId: friendId },
{ userFromId: friendId, userToId: meId },
],
},
});
await tx
.delete(MessengerFriendrequests)
.where(
or(
and(
eq(MessengerFriendrequests.userFromId, meId),
eq(MessengerFriendrequests.userToId, friendId),
),
and(
eq(MessengerFriendrequests.userFromId, friendId),
eq(MessengerFriendrequests.userToId, meId),
),
),
);
return result.count;
return Number(
(result as unknown as [{ affectedRows: number }])[0]
?.affectedRows ?? 0,
);
});
outcome = deleted > 0 ? "removed" : "not_found";
@@ -310,33 +352,39 @@ export async function sendOfflineMessage(formData: FormData): Promise<void> {
} else if (!message) {
outcome = "empty";
} else {
const friendship = await prisma.messengerFriendships.findFirst({
where: {
OR: [
{ userOneId: meId, userTwoId: friendId },
{ userOneId: friendId, userTwoId: meId },
],
},
select: { id: true },
});
const [friendship] = await db
.select({ id: MessengerFriendships.id })
.from(MessengerFriendships)
.where(
or(
and(
eq(MessengerFriendships.userOneId, meId),
eq(MessengerFriendships.userTwoId, friendId),
),
and(
eq(MessengerFriendships.userOneId, friendId),
eq(MessengerFriendships.userTwoId, meId),
),
),
)
.limit(1);
if (!friendship) {
outcome = "not_friend";
} else {
const recipient = await prisma.user.findUnique({
where: { id: friendId },
select: { id: true },
});
const [recipient] = await db
.select({ id: User.id })
.from(User)
.where(eq(User.id, friendId))
.limit(1);
if (!recipient) {
outcome = "invalid";
} else {
await prisma.messengerOffline.create({
data: {
userId: friendId,
userFromId: meId,
message,
sendedOn: Math.floor(Date.now() / 1000),
},
await db.insert(MessengerOffline).values({
userId: friendId,
userFromId: meId,
message,
sendedOn: Math.floor(Date.now() / 1000),
});
outcome = "sent";
}