beeeeg update

src/routes/projects/catch-em-all/+page.server.ts

@@ -1,6 +1,12 @@
 import { db } from '$lib/server/db';
-import { game, pokemonGameEntry, userEntry, userGame } from '$lib/server/db/schema';
-import { eq, inArray } from 'drizzle-orm';
+import {
+	games,
+	pokemonGameEntries,
+	userEntries,
+	userGames,
+	catchEmAllSettings
+} from '$lib/server/db/schema';
+import { and, eq, inArray } from 'drizzle-orm';
 import type { Actions, PageServerLoad } from './$types';
 import { availabilityValues } from '$lib/availability';
 import { fail } from '@sveltejs/kit';
@@ -11,7 +17,7 @@ export const load: PageServerLoad = async ({ locals }) => {
 		with: {
 			entry: true
 		},
-		orderBy: (pokemon) => pokemon.number
+		orderBy: { number: 'asc' }
 	});
 	const pokemon = pokemonRows.map(({ entry, ...rest }) => ({
 		...rest,
@@ -21,27 +27,39 @@ export const load: PageServerLoad = async ({ locals }) => {
 		})
 	}));
 
-	const games = await db.query.game.findMany({
-		orderBy: (game) => [game.generation, game.id]
+	const gameRows = await db.query.games.findMany({
+		orderBy: { generation: 'asc', id: 'asc' }
 	});
 
 	let caughtIds: number[] = [];
 	let selectedGameIds: number[] = [];
+	let gamesConfigured = false;
 	if (locals.user) {
+		const [settings] = await db
+			.select()
+			.from(catchEmAllSettings)
+			.where(eq(catchEmAllSettings.userId, locals.user.id));
+		gamesConfigured = !!settings;
 		const caughtRows = await db
-			.select({ id: userEntry.pokemonGameEntryId })
-			.from(userEntry)
-			.where(eq(userEntry.userId, locals.user.id));
+			.select({ id: userEntries.pokemonGameEntryId })
+			.from(userEntries)
+			.where(eq(userEntries.userId, locals.user.id));
 		caughtIds = caughtRows.map((r) => r.id);
 
 		const gameRows = await db
-			.select({ id: userGame.gameId })
-			.from(userGame)
-			.where(eq(userGame.userId, locals.user.id));
+			.select({ id: userGames.gameId })
+			.from(userGames)
+			.where(eq(userGames.userId, locals.user.id));
 		selectedGameIds = gameRows.map((r) => r.id);
 	}
 
-	return { pokemon, games, caughtIds, selectedGameIds };
+	return {
+		pokemon,
+		games: gameRows,
+		caughtIds,
+		selectedGameIds,
+		gamesConfigured: gamesConfigured || selectedGameIds.length > 0
+	};
 };
 
 export const actions = {
@@ -50,58 +68,71 @@ export const actions = {
 
 		const data = await request.formData();
 		const entryId = Number(data.get('entryId'));
-		if (!Number.isInteger(entryId) || entryId <= 0) return fail(400, { message: 'Invalid entry' });
+		if (!Number.isSafeInteger(entryId) || entryId <= 0 || entryId > 2147483647)
+			return fail(400, { message: 'Invalid entry' });
 
 		// only catchable entries can be toggled — the client disables these
 		// checkboxes but we can't trust that
 		const [entry] = await db
-			.select({ availability: pokemonGameEntry.availability })
-			.from(pokemonGameEntry)
-			.where(eq(pokemonGameEntry.id, entryId));
+			.select({ availability: pokemonGameEntries.availability })
+			.from(pokemonGameEntries)
+			.where(eq(pokemonGameEntries.id, entryId));
 		if (!entry) return fail(404, { message: 'Unknown entry' });
 		if (entry.availability !== 'catchable') {
-			return fail(400, { message: 'This pokemon is not catchable in this game' });
+			return fail(400, { message: 'This entry does not have confirmed encounter data' });
 		}
 
+		if (data.has('caught') && data.get('caught') !== 'on')
+			return fail(400, { message: 'Invalid caught state' });
 		const caught = data.get('caught') === 'on';
 
 		if (caught) {
 			await db
-				.insert(userEntry)
+				.insert(userEntries)
 				.values({ pokemonGameEntryId: entryId, userId: locals.user.id })
 				.onConflictDoNothing();
 		} else {
 			await db
-				.delete(userEntry)
+				.delete(userEntries)
 				.where(
-					and(eq(userEntry.pokemonGameEntryId, entryId), eq(userEntry.userId, locals.user.id))
+					and(eq(userEntries.pokemonGameEntryId, entryId), eq(userEntries.userId, locals.user.id))
 				);
 		}
+		return { saved: true };
 	},
 
 	setGames: async ({ request, locals }) => {
 		if (!locals.user) return fail(401, { message: 'Log in to set rules' });
 
 		const data = await request.formData();
-		const gameIds = data
-			.getAll('gameIds')
-			.map(Number)
-			.filter((id) => Number.isInteger(id) && id > 0);
+		const submittedIds = data.getAll('gameIds').map(Number);
+		if (
+			submittedIds.length > 200 ||
+			submittedIds.some((id) => !Number.isSafeInteger(id) || id <= 0)
+		) {
+			return fail(400, { message: 'Invalid game selection' });
+		}
+		const gameIds = [...new Set(submittedIds)];
 
 		if (gameIds.length > 0) {
 			const validGames = await db
-				.select({ id: game.id })
-				.from(game)
-				.where(inArray(game.id, gameIds));
+				.select({ id: games.id })
+				.from(games)
+				.where(inArray(games.id, gameIds));
 			if (validGames.length !== gameIds.length) return fail(400, { message: 'Unknown game' });
 		}
 
 		const userId = locals.user.id;
 		await db.transaction(async (tx) => {
-			await tx.delete(userGame).where(eq(userGame.userId, userId));
+			await tx
+				.insert(catchEmAllSettings)
+				.values({ userId })
+				.onConflictDoUpdate({ target: catchEmAllSettings.userId, set: { userId } });
+			await tx.delete(userGames).where(eq(userGames.userId, userId));
 			if (gameIds.length > 0) {
-				await tx.insert(userGame).values(gameIds.map((gameId) => ({ userId, gameId })));
+				await tx.insert(userGames).values(gameIds.map((gameId) => ({ userId, gameId })));
 			}
 		});
+		return { saved: true };
 	}
 } satisfies Actions;