feat: Introduce new modules for class, inventory, leveling, and quests with expanded schema, refactor user service, and add verification scripts.

This commit is contained in:
syntaxbullet
2025-12-07 23:03:33 +01:00
parent be471f348d
commit 29c0a4752d
21 changed files with 1228 additions and 163 deletions

View File

@@ -1,18 +1,201 @@
import { DrizzleClient } from "@lib/DrizzleClient";
import { users } from "@/db/schema";
import { eq } from "drizzle-orm";
import { users, transactions, cooldowns } from "@/db/schema";
import { eq, sql, and, gt } from "drizzle-orm";
import { DrizzleClient } from "@/lib/DrizzleClient";
import { userService } from "@/modules/user/user.service";
export async function getUserBalance(userId: string) {
const user = await DrizzleClient.query.users.findFirst({ where: eq(users.userId, userId) });
return user?.balance ?? 0;
}
const DAILY_REWARD_AMOUNT = 100n;
const STREAK_BONUS = 10n;
const DAILY_COOLDOWN = 24 * 60 * 60 * 1000; // 24 hours in ms
export async function setUserBalance(userId: string, balance: number) {
await DrizzleClient.update(users).set({ balance }).where(eq(users.userId, userId));
}
export const economyService = {
transfer: async (fromUserId: string, toUserId: string, amount: bigint, tx?: any) => {
if (amount <= 0n) {
throw new Error("Amount must be positive");
}
export async function addUserBalance(userId: string, amount: number) {
const user = await DrizzleClient.query.users.findFirst({ where: eq(users.userId, userId) });
if (!user) return;
await DrizzleClient.update(users).set({ balance: user.balance + amount }).where(eq(users.userId, userId));
}
if (fromUserId === toUserId) {
throw new Error("Cannot transfer to self");
}
const execute = async (txFn: any) => {
// Check sender balance
const sender = await txFn.query.users.findFirst({
where: eq(users.id, BigInt(fromUserId)),
});
if (!sender) {
throw new Error("Sender not found");
}
if ((sender.balance ?? 0n) < amount) {
throw new Error("Insufficient funds");
}
// Deduct from sender
await txFn.update(users)
.set({
balance: sql`${users.balance} - ${amount}`,
})
.where(eq(users.id, BigInt(fromUserId)));
// Add to receiver
await txFn.update(users)
.set({
balance: sql`${users.balance} + ${amount}`,
})
.where(eq(users.id, BigInt(toUserId)));
// Create transaction records
// 1. Debit for sender
await txFn.insert(transactions).values({
userId: BigInt(fromUserId),
amount: -amount,
type: 'TRANSFER_OUT',
description: `Transfer to ${toUserId}`,
});
// 2. Credit for receiver
await txFn.insert(transactions).values({
userId: BigInt(toUserId),
amount: amount,
type: 'TRANSFER_IN',
description: `Transfer from ${fromUserId}`,
});
return { success: true, amount };
};
if (tx) {
return await execute(tx);
} else {
return await DrizzleClient.transaction(async (t) => {
return await execute(t);
});
}
},
claimDaily: async (userId: string, tx?: any) => {
const execute = async (txFn: any) => {
const now = new Date();
const startOfDay = new Date(now);
startOfDay.setHours(0, 0, 0, 0);
// Check cooldown
const cooldown = await txFn.query.cooldowns.findFirst({
where: and(
eq(cooldowns.userId, BigInt(userId)),
eq(cooldowns.actionKey, 'daily')
),
});
if (cooldown && cooldown.readyAt > now) {
throw new Error(`Daily already claimed. Ready at ${cooldown.readyAt}`);
}
// Get user for streak logic
const user = await txFn.query.users.findFirst({
where: eq(users.id, BigInt(userId)),
});
if (!user) {
throw new Error("User not found");
}
let streak = (user.dailyStreak || 0) + 1;
// If previous cooldown exists and expired more than 24h ago (meaning >48h since last claim), reset streak
if (cooldown) {
const timeSinceReady = now.getTime() - cooldown.readyAt.getTime();
if (timeSinceReady > 24 * 60 * 60 * 1000) {
streak = 1;
}
} else {
streak = 1;
}
const bonus = BigInt(streak) * STREAK_BONUS;
const totalReward = DAILY_REWARD_AMOUNT + bonus;
// Update User w/ Economy Service (reuse modifyUserBalance if we split it out, but here manual is fine for atomic combined streak update)
// Actually, we can just update directly here as we are already refining specific fields like streak.
await txFn.update(users)
.set({
balance: sql`${users.balance} + ${totalReward}`,
dailyStreak: streak,
xp: sql`${users.xp} + 10`, // Small XP reward for daily
})
.where(eq(users.id, BigInt(userId)));
// Set new cooldown (now + 24h)
const nextReadyAt = new Date(now.getTime() + DAILY_COOLDOWN);
await txFn.insert(cooldowns)
.values({
userId: BigInt(userId),
actionKey: 'daily',
readyAt: nextReadyAt,
})
.onConflictDoUpdate({
target: [cooldowns.userId, cooldowns.actionKey],
set: { readyAt: nextReadyAt },
});
// Log Transaction
await txFn.insert(transactions).values({
userId: BigInt(userId),
amount: totalReward,
type: 'DAILY_REWARD',
description: `Daily reward (Streak: ${streak})`,
});
return { claimed: true, amount: totalReward, streak, nextReadyAt };
};
if (tx) {
return await execute(tx);
} else {
return await DrizzleClient.transaction(async (t) => {
return await execute(t);
});
}
},
modifyUserBalance: async (id: string, amount: bigint, type: string, description: string, tx?: any) => {
const execute = async (txFn: any) => {
if (amount < 0n) {
// Check sufficient funds if removing
const user = await txFn.query.users.findFirst({
where: eq(users.id, BigInt(id))
});
if (!user || (user.balance ?? 0n) < -amount) {
throw new Error("Insufficient funds");
}
}
const [user] = await txFn.update(users)
.set({
balance: sql`${users.balance} + ${amount}`,
})
.where(eq(users.id, BigInt(id)))
.returning();
await txFn.insert(transactions).values({
userId: BigInt(id),
amount: amount,
type: type,
description: description,
});
return user;
};
if (tx) {
return await execute(tx);
} else {
return await DrizzleClient.transaction(async (t) => {
return await execute(t);
});
}
},
};