feat(*): Migrate from MongoDB to unified Supabase PostgreSQL architecture

src/lib/components/pokedex/PokedexEntryCatchRecord.svelte

@@ -5,15 +5,27 @@
 	import { createEventDispatcher } from 'svelte';
 
 	export let pokedexEntry: PokedexEntry;
-	export let catchRecord: CatchRecord;
+	export let catchRecord: CatchRecord | null;
 	export let showOrigins: boolean;
 	export let showForms: boolean;
 	export let showShiny: boolean;
 
+	// Create a working copy for editing
+	$: workingCatchRecord = catchRecord || {
+		_id: '',
+		userId: '',
+		pokedexEntryId: pokedexEntry._id,
+		haveToEvolve: false,
+		caught: false,
+		inHome: false,
+		hasGigantamaxed: false,
+		personalNotes: ''
+	};
+
 	const dispatch = createEventDispatcher();
 
 	function updateCatchRecord() {
-		dispatch('updateCatch', { pokedexEntry, catchRecord });
+		dispatch('updateCatch', { pokedexEntry, catchRecord: workingCatchRecord });
 	}
 </script>
 
@@ -75,7 +87,7 @@
 					<span class="block font-bold mr-2">Caught:</span>
 					<input
 						type="checkbox"
-						bind:checked={catchRecord.caught}
+						bind:checked={workingCatchRecord.caught}
 						class="checkbox checkbox-primary border-black"
 						on:change={updateCatchRecord}
 					/>
@@ -88,7 +100,7 @@
 					<span class="block font-bold mr-2">Needs to evolve:</span>
 					<input
 						type="checkbox"
-						bind:checked={catchRecord.haveToEvolve}
+						bind:checked={workingCatchRecord.haveToEvolve}
 						class="checkbox checkbox-primary border-black"
 						on:change={updateCatchRecord}
 					/>
@@ -101,7 +113,7 @@
 					<span class="block font-bold mr-2">In home:</span>
 					<input
 						type="checkbox"
-						bind:checked={catchRecord.inHome}
+						bind:checked={workingCatchRecord.inHome}
 						class="checkbox checkbox-primary border-black"
 						on:change={updateCatchRecord}
 					/>
@@ -115,7 +127,7 @@
 						<span class="block font-bold mr-2">Has Gigantamaxed:</span>
 						<input
 							type="checkbox"
-							bind:checked={catchRecord.hasGigantamaxed}
+							bind:checked={workingCatchRecord.hasGigantamaxed}
 							class="checkbox checkbox-primary border-black"
 							on:change={updateCatchRecord}
 						/>
@@ -124,12 +136,12 @@
 			</div>
 		{/if}
 		<p>
-			<label class="block font-bold mb-1" for={`personalNotesInput-${catchRecord._id}`}
+			<label class="block font-bold mb-1" for={`personalNotesInput-${catchRecord?._id || pokedexEntry._id}`}
 				>Notes:</label
 			>
 			<textarea
-				bind:value={catchRecord.personalNotes}
-				id={`personalNotesInput-${catchRecord._id}`}
+				bind:value={workingCatchRecord.personalNotes}
+				id={`personalNotesInput-${catchRecord?._id || pokedexEntry._id}`}
 				class="form-textarea w-full p-2 border rounded"
 				on:change={updateCatchRecord}
 			></textarea>

src/lib/components/pokedex/PokedexViewBoxes.svelte

@@ -19,18 +19,18 @@
 	export let markBoxAsNotInHome = (boxNumber: number) => {};
 	export let createCatchRecords = () => {};
 
-	function cellBackgroundColourClass(catchRecord: CatchRecord) {
-		if (catchRecord.caught) {
+	function cellBackgroundColourClass(catchRecord: CatchRecord | null) {
+		if (catchRecord?.caught) {
 			return 'bg-green-100/50';
-		} else if (catchRecord.haveToEvolve) {
+		} else if (catchRecord?.haveToEvolve) {
 			return 'bg-yellow-100/50';
 		} else {
 			return '';
 		}
 	}
 
-	function cellBackgroundColourStyle(pokedexEntry: PokedexEntry, catchRecord: CatchRecord) {
-		if (catchRecord.caught || catchRecord.haveToEvolve) {
+	function cellBackgroundColourStyle(pokedexEntry: PokedexEntry, catchRecord: CatchRecord | null) {
+		if (catchRecord?.caught || catchRecord?.haveToEvolve) {
 			return '';
 		} else {
 			if (pokedexEntry[currentPlacement].column % 2 === 0) {
@@ -76,7 +76,7 @@
 										>
 											<Tooltip>
 												<div slot="hover-target">
-													{#if catchRecord.inHome}
+													{#if catchRecord?.inHome}
 														<span
 															class="absolute -top-5 -right-4 z-2 p-1 text-secondary text-lg font-extrabold"
 															>&#10003;</span
@@ -97,9 +97,9 @@
 													</div>
 													<div>{pokedexEntry.pokedexNumber.toString().padStart(3, '0')}</div>
 													<div>
-														Caught: {catchRecord.caught ? 'Yes' : 'No'} <br />
-														Needs to Evolve: {catchRecord.haveToEvolve ? 'Yes' : 'No'} <br />
-														In Home: {catchRecord.inHome ? 'Yes' : 'No'}
+														Caught: {catchRecord?.caught ? 'Yes' : 'No'} <br />
+														Needs to Evolve: {catchRecord?.haveToEvolve ? 'Yes' : 'No'} <br />
+														In Home: {catchRecord?.inHome ? 'Yes' : 'No'}
 													</div>
 												</div>
 											</Tooltip>

src/lib/models/CombinedData.ts

@@ -3,5 +3,5 @@ import { type CatchRecord } from './CatchRecord';
 
 export interface CombinedData {
 	pokedexEntry: PokedexEntry;
-	catchRecord: CatchRecord;
+	catchRecord: CatchRecord | null;
 }

src/lib/repositories/CatchRecordRepository.ts

@@ -1,38 +1,136 @@
-import CatchRecordModel, { type CatchRecord } from '$lib/models/CatchRecord';
+import type { CatchRecord } from '$lib/models/CatchRecord';
+import type { SupabaseClient } from '@supabase/supabase-js';
 
 class CatchRecordRepository {
+	constructor(private supabase: SupabaseClient, private userId: string) {}
+
+	// Transform Supabase snake_case to frontend camelCase
+	private transformCatchRecord(record: any): CatchRecord {
+		return {
+			_id: record.id,
+			userId: record.user_id,
+			pokedexEntryId: record.pokedex_entry_id.toString(),
+			haveToEvolve: record.have_to_evolve,
+			caught: record.caught,
+			inHome: record.in_home,
+			hasGigantamaxed: record.has_gigantamaxed,
+			personalNotes: record.personal_notes
+		};
+	}
+
+	// Transform frontend camelCase to Supabase snake_case
+	private transformToDatabase(data: Partial<CatchRecord>): any {
+		const dbData: any = {};
+		if (data.pokedexEntryId !== undefined && data.pokedexEntryId !== null) {
+			dbData.pokedex_entry_id = Number(data.pokedexEntryId);
+		}
+		if (data.haveToEvolve !== undefined) dbData.have_to_evolve = data.haveToEvolve;
+		if (data.caught !== undefined) dbData.caught = data.caught;
+		if (data.inHome !== undefined) dbData.in_home = data.inHome;
+		if (data.hasGigantamaxed !== undefined) dbData.has_gigantamaxed = data.hasGigantamaxed;
+		if (data.personalNotes !== undefined) dbData.personal_notes = data.personalNotes;
+		
+		return dbData;
+	}
+
 	async findById(id: string): Promise<CatchRecord | null> {
-		return CatchRecordModel.findById(id).exec();
+		const { data, error } = await this.supabase
+			.from('catch_records')
+			.select('*')
+			.eq('id', id)
+			.eq('user_id', this.userId)
+			.single();
+
+		if (error || !data) return null;
+		return this.transformCatchRecord(data);
 	}
 
 	async findAll(): Promise<CatchRecord[]> {
-		return CatchRecordModel.find().exec();
+		const { data, error } = await this.supabase
+			.from('catch_records')
+			.select('*')
+			.eq('user_id', this.userId);
+
+		if (error || !data) return [];
+		return data.map(record => this.transformCatchRecord(record));
 	}
 
 	async findByUserId(userId: string): Promise<CatchRecord[]> {
-		return CatchRecordModel.find({ userId }).exec();
+		return this.findAll(); // Already filtered by user in constructor
 	}
 
 	async create(data: Partial<CatchRecord>): Promise<CatchRecord> {
-		return CatchRecordModel.create(data);
+		const dbData = {
+			user_id: this.userId,
+			...this.transformToDatabase(data)
+		};
+
+		const { data: result, error } = await this.supabase
+			.from('catch_records')
+			.insert(dbData)
+			.select()
+			.single();
+
+		if (error) {
+			console.error('Supabase error creating catch record:', error);
+			throw new Error(`Failed to create catch record: ${error.message}`);
+		}
+		
+		if (!result) {
+			throw new Error('Failed to create catch record: No result returned');
+		}
+		
+		return this.transformCatchRecord(result);
 	}
 
 	async update(id: string, data: Partial<CatchRecord>): Promise<CatchRecord | null> {
-		return CatchRecordModel.findByIdAndUpdate(id, data, { new: true }).exec();
+		const dbData = this.transformToDatabase(data);
+
+		const { data: result, error } = await this.supabase
+			.from('catch_records')
+			.update(dbData)
+			.eq('id', id)
+			.eq('user_id', this.userId)
+			.select()
+			.single();
+
+		if (error || !result) return null;
+		return this.transformCatchRecord(result);
 	}
 
 	async delete(id: string): Promise<void> {
-		await CatchRecordModel.findByIdAndDelete(id).exec();
+		await this.supabase
+			.from('catch_records')
+			.delete()
+			.eq('id', id)
+			.eq('user_id', this.userId);
 	}
 
 	async upsert(data: Partial<CatchRecord>): Promise<CatchRecord | null> {
 		if (data._id) {
-			// Update existing record
-			return CatchRecordModel.findByIdAndUpdate(data._id, data, { new: true }).exec();
-		} else {
-			// Create new record
-			return CatchRecordModel.create(data);
+			return this.update(data._id, data);
+		} else if (data.pokedexEntryId) {
+			// Try to find existing record for this user and pokemon
+			const existing = await this.findByUserAndPokemon(this.userId, data.pokedexEntryId);
+			if (existing) {
+				return this.update(existing._id, data);
+			} else {
+				return this.create(data);
+			}
 		}
+		return this.create(data);
+	}
+
+	async findByUserAndPokemon(userId: string, pokedexEntryId: string): Promise<CatchRecord | null> {
+		const { data, error } = await this.supabase
+			.from('catch_records')
+			.select('*')
+			.eq('user_id', userId)
+			.eq('pokedex_entry_id', pokedexEntryId)
+			.single();
+
+		if (error || !data) return null;
+		return this.transformCatchRecord(data);
 	}
 }
 

src/lib/repositories/CombinedDataRepository.ts

@@ -1,79 +1,110 @@
-import PokedexEntryModel, { type PokedexEntry } from '$lib/models/PokedexEntry';
-import CatchRecordModel, { type CatchRecord } from '$lib/models/CatchRecord';
+import { type PokedexEntry } from '$lib/models/PokedexEntry';
+import { type CatchRecord } from '$lib/models/CatchRecord';
 import { type CombinedData } from '$lib/models/CombinedData';
+import type { SupabaseClient } from '@supabase/supabase-js';
 
 class CombinedDataRepository {
+	constructor(private supabase: SupabaseClient, private userId: string) {}
+
+	// Transform Supabase data to match frontend expectations
+	private transformPokedexEntry(entry: any): PokedexEntry {
+		return {
+			_id: entry.id.toString(),
+			pokedexNumber: entry.pokedex_number,
+			pokemon: entry.pokemon,
+			form: entry.form,
+			canGigantamax: entry.can_gigantamax,
+			regionToCatchIn: entry.region_to_catch_in,
+			gamesToCatchIn: entry.games_to_catch_in || [],
+			regionToEvolveIn: entry.region_to_evolve_in,
+			evolutionInformation: entry.evolution_information,
+			catchInformation: entry.catch_information || [],
+			boxPlacementForms: {
+				box: entry.box_placement_forms_box,
+				row: entry.box_placement_forms_row,
+				column: entry.box_placement_forms_column
+			},
+			boxPlacement: {
+				box: entry.box_placement_box,
+				row: entry.box_placement_row,
+				column: entry.box_placement_column
+			}
+		};
+	}
+
+	private transformCatchRecord(record: any): CatchRecord {
+		return {
+			_id: record.id,
+			userId: record.user_id,
+			pokedexEntryId: record.pokedex_entry_id.toString(),
+			haveToEvolve: record.have_to_evolve,
+			caught: record.caught,
+			inHome: record.in_home,
+			hasGigantamaxed: record.has_gigantamaxed,
+			personalNotes: record.personal_notes
+		};
+	}
+
 	async findAllCombinedData(
 		userId: string,
 		enableForms: boolean = true,
 		region: string = '',
 		game: string = ''
 	): Promise<CombinedData[]> {
-		const pipeline: any[] = [
-			{
-				$lookup: {
-					from: 'catchrecords',
-					let: { entryId: '$_id' },
-					pipeline: [
-						{
-							$match: {
-								$expr: {
-									$and: [
-										{ $eq: ['$pokedexEntryId', '$$entryId'] },
-										{ $eq: ['$userId', userId] }
-									]
-								}
-							}
-						}
-					],
-					as: 'catchRecord'
-				}
-			},
-			{
-				$unwind: {
-					path: '$catchRecord',
-					preserveNullAndEmptyArrays: true
-				}
-			},
-			{
-				$sort: {
-					'boxPlacementForms.box': 1,
-					'boxPlacementForms.row': 1,
-					'boxPlacementForms.column': 1
-				}
-			}
-		];
+		let query = this.supabase
+			.from('pokedex_entries')
+			.select(`
+				*,
+				catch_records(*)
+			`);
 
+		// Apply filters
 		if (!enableForms) {
-			pipeline.unshift({
-				$match: {
-					'boxPlacement.box': { $ne: null }
-				}
-			});
+			query = query.not('box_placement_box', 'is', null);
 		}
 
-		if (region.length > 0) {
-			pipeline.unshift({
-				$match: {
-					regionToCatchIn: region
-				}
-			});
+		if (region) {
+			query = query.eq('region_to_catch_in', region);
 		}
 
-		if (game.length > 0) {
-			pipeline.unshift({
-				$match: {
-					gamesToCatchIn: { $in: [game] }
-				}
-			});
+		if (game) {
+			query = query.contains('games_to_catch_in', [game]);
 		}
 
-		const combinedData: CombinedData[] = await PokedexEntryModel.aggregate(pipeline).exec();
+		// Order by box placement
+		if (enableForms) {
+			query = query.order('box_placement_forms_box', { ascending: true })
+				.order('box_placement_forms_row', { ascending: true })
+				.order('box_placement_forms_column', { ascending: true });
+		} else {
+			query = query.order('box_placement_box', { ascending: true })
+				.order('box_placement_row', { ascending: true })
+				.order('box_placement_column', { ascending: true });
+		}
 
-		return combinedData.map((data) => ({
-			pokedexEntry: data as PokedexEntry,
-			catchRecord: data.catchRecord as CatchRecord
-		}));
+		const { data, error } = await query;
+
+		if (error) {
+			console.error('Error finding combined data:', error);
+			return [];
+		}
+
+		// Transform the data and filter catch records by user
+		return (data || []).map(entry => {
+			const userCatchRecord = Array.isArray(entry.catch_records) 
+				? entry.catch_records.find((record: any) => record.user_id === userId)
+				: null;
+
+			const transformedEntry = this.transformPokedexEntry(entry);
+			const transformedCatchRecord = userCatchRecord 
+				? this.transformCatchRecord(userCatchRecord)
+				: null;
+
+			return {
+				pokedexEntry: transformedEntry,
+				catchRecord: transformedCatchRecord
+			};
+		});
 	}
 
 	async findCombinedData(
@@ -84,140 +115,98 @@ class CombinedDataRepository {
 		region: string = '',
 		game: string = ''
 	): Promise<CombinedData[]> {
-		const skip = (page - 1) * limit;
-		const pipeline: any[] = [
-			{
-				$lookup: {
-					from: 'catchrecords',
-					let: { entryId: '$_id' },
-					pipeline: [
-						{
-							$match: {
-								$expr: {
-									$and: [
-										{ $eq: ['$pokedexEntryId', '$$entryId'] },
-										{ $eq: ['$userId', userId] }
-									]
-								}
-							}
-						}
-					],
-					as: 'catchRecord'
-				}
-			},
-			{
-				$unwind: {
-					path: '$catchRecord',
-					preserveNullAndEmptyArrays: true
-				}
-			},
-			{
-				$sort: {
-					'boxPlacementForms.box': 1,
-					'boxPlacementForms.row': 1,
-					'boxPlacementForms.column': 1
-				}
-			},
-			{ $skip: skip },
-			{ $limit: limit }
-		];
+		const from = (page - 1) * limit;
+		const to = from + limit - 1;
 
+		let query = this.supabase
+			.from('pokedex_entries')
+			.select(`
+				*,
+				catch_records(*)
+			`)
+			.range(from, to);
+
+		// Apply filters
 		if (!enableForms) {
-			pipeline.unshift({
-				$match: {
-					'boxPlacement.box': { $ne: null }
-				}
-			});
+			query = query.not('box_placement_box', 'is', null);
 		}
 
-		if (region.length > 0) {
-			pipeline.unshift({
-				$match: {
-					regionToCatchIn: region
-				}
-			});
+		if (region) {
+			query = query.eq('region_to_catch_in', region);
 		}
 
-		if (game.length > 0) {
-			pipeline.unshift({
-				$match: {
-					gamesToCatchIn: { $in: [game] }
-				}
-			});
+		if (game) {
+			query = query.contains('games_to_catch_in', [game]);
 		}
 
-		const combinedData: CombinedData[] = await PokedexEntryModel.aggregate(pipeline).exec();
+		// Order by box placement
+		if (enableForms) {
+			query = query.order('box_placement_forms_box', { ascending: true })
+				.order('box_placement_forms_row', { ascending: true })
+				.order('box_placement_forms_column', { ascending: true });
+		} else {
+			query = query.order('box_placement_box', { ascending: true })
+				.order('box_placement_row', { ascending: true })
+				.order('box_placement_column', { ascending: true });
+		}
 
-		return combinedData.map((data) => ({
-			pokedexEntry: data as PokedexEntry,
-			catchRecord: data.catchRecord as CatchRecord
-		}));
+		const { data, error } = await query;
+
+		if (error) {
+			console.error('Error finding paginated combined data:', error);
+			return [];
+		}
+
+		// Transform the data and filter catch records by user
+		return (data || []).map(entry => {
+			const userCatchRecord = Array.isArray(entry.catch_records) 
+				? entry.catch_records.find((record: any) => record.user_id === userId)
+				: null;
+
+			const transformedEntry = this.transformPokedexEntry(entry);
+			const transformedCatchRecord = userCatchRecord 
+				? this.transformCatchRecord(userCatchRecord)
+				: null;
+
+			return {
+				pokedexEntry: transformedEntry,
+				catchRecord: transformedCatchRecord
+			};
+		});
 	}
 
-	async countCombinedData(userId: string, enableForms: boolean, region: string, game: string): Promise<number> {
-		const pipeline: any[] = [
-			{
-				$lookup: {
-					from: 'catchrecords',
-					let: { entryId: '$_id' },
-					pipeline: [
-						{
-							$match: {
-								$expr: {
-									$and: [
-										{ $eq: ['$pokedexEntryId', '$$entryId'] },
-										{ $eq: ['$userId', userId] }
-									]
-								}
-							}
-						}
-					],
-					as: 'catchRecord'
-				}
-			},
-			{
-				$unwind: {
-					path: '$catchRecord',
-					preserveNullAndEmptyArrays: true
-				}
-			},
-			{
-				$count: 'total'
-			}
-		];
+	async countCombinedData(
+		userId: string,
+		enableForms: boolean,
+		region: string,
+		game: string
+	): Promise<number> {
+		let query = this.supabase
+			.from('pokedex_entries')
+			.select('id', { count: 'exact', head: true });
 
+		// Apply same filters as in findCombinedData
 		if (!enableForms) {
-			pipeline.unshift({
-				$match: {
-					'boxPlacement.box': { $ne: null }
-				}
-			});
+			query = query.not('box_placement_box', 'is', null);
 		}
 
-		if (region.length > 0) {
-			pipeline.unshift({
-				$match: {
-					regionToCatchIn: region
-				}
-			});
+		if (region) {
+			query = query.eq('region_to_catch_in', region);
 		}
 
-		if (game.length > 0) {
-			pipeline.unshift({
-				$match: {
-					gamesToCatchIn: { $in: [game] }
-				}
-			});
+		if (game) {
+			query = query.contains('games_to_catch_in', [game]);
 		}
 
-		try {
-			const result = await PokedexEntryModel.aggregate(pipeline).exec();
-			return result.length > 0 ? result[0].total : 0;
-		} catch (error) {
-			console.error('Error counting documents:', error);
-			throw error;
+		const { count, error } = await query;
+
+		if (error) {
+			console.error('Error counting combined data:', error);
+			return 0;
 		}
+
+		return count || 0;
 	}
 }
 
-export default CombinedDataRepository;
+export default CombinedDataRepository;

src/lib/repositories/PokedexEntryRepository.ts

@@ -1,24 +1,108 @@
-import PokedexEntryModel, { type PokedexEntry } from '$lib/models/PokedexEntry';
+import { type PokedexEntry } from '$lib/models/PokedexEntry';
+import type { SupabaseClient } from '@supabase/supabase-js';
 
 class PokedexEntryRepository {
+	constructor(private supabase: SupabaseClient) {}
+
+	// Transform Supabase data to match frontend expectations
+	private transformPokedexEntry(entry: any): PokedexEntry {
+		return {
+			_id: entry.id.toString(),
+			pokedexNumber: entry.pokedex_number,
+			pokemon: entry.pokemon,
+			form: entry.form,
+			canGigantamax: entry.can_gigantamax,
+			regionToCatchIn: entry.region_to_catch_in,
+			gamesToCatchIn: entry.games_to_catch_in || [],
+			regionToEvolveIn: entry.region_to_evolve_in,
+			evolutionInformation: entry.evolution_information,
+			catchInformation: entry.catch_information || [],
+			boxPlacementForms: {
+				box: entry.box_placement_forms_box,
+				row: entry.box_placement_forms_row,
+				column: entry.box_placement_forms_column
+			},
+			boxPlacement: {
+				box: entry.box_placement_box,
+				row: entry.box_placement_row,
+				column: entry.box_placement_column
+			}
+		};
+	}
+
 	async findById(id: string): Promise<PokedexEntry | null> {
-		return PokedexEntryModel.findById(id).exec();
+		const { data, error } = await this.supabase
+			.from('pokedex_entries')
+			.select('*')
+			.eq('id', id)
+			.single();
+
+		if (error || !data) return null;
+		return this.transformPokedexEntry(data);
 	}
 
 	async findAll(): Promise<PokedexEntry[]> {
-		return PokedexEntryModel.find().exec();
+		const { data, error } = await this.supabase
+			.from('pokedex_entries')
+			.select('*')
+			.order('pokedex_number', { ascending: true });
+
+		if (error || !data) return [];
+		return data.map(entry => this.transformPokedexEntry(entry));
 	}
 
 	async create(data: Partial<PokedexEntry>): Promise<PokedexEntry> {
-		return PokedexEntryModel.create(data);
+		// Transform camelCase to snake_case for database
+		const dbData: any = {};
+		if (data.pokedexNumber !== undefined) dbData.pokedex_number = data.pokedexNumber;
+		if (data.pokemon !== undefined) dbData.pokemon = data.pokemon;
+		if (data.form !== undefined) dbData.form = data.form;
+		if (data.canGigantamax !== undefined) dbData.can_gigantamax = data.canGigantamax;
+		if (data.regionToCatchIn !== undefined) dbData.region_to_catch_in = data.regionToCatchIn;
+		if (data.gamesToCatchIn !== undefined) dbData.games_to_catch_in = data.gamesToCatchIn;
+		if (data.regionToEvolveIn !== undefined) dbData.region_to_evolve_in = data.regionToEvolveIn;
+		if (data.evolutionInformation !== undefined) dbData.evolution_information = data.evolutionInformation;
+		if (data.catchInformation !== undefined) dbData.catch_information = data.catchInformation;
+		if (data.boxPlacementForms?.box !== undefined) dbData.box_placement_forms_box = data.boxPlacementForms.box;
+		if (data.boxPlacementForms?.row !== undefined) dbData.box_placement_forms_row = data.boxPlacementForms.row;
+		if (data.boxPlacementForms?.column !== undefined) dbData.box_placement_forms_column = data.boxPlacementForms.column;
+		if (data.boxPlacement?.box !== undefined) dbData.box_placement_box = data.boxPlacement.box;
+		if (data.boxPlacement?.row !== undefined) dbData.box_placement_row = data.boxPlacement.row;
+		if (data.boxPlacement?.column !== undefined) dbData.box_placement_column = data.boxPlacement.column;
+
+		const { data: result, error } = await this.supabase
+			.from('pokedex_entries')
+			.insert(dbData)
+			.select()
+			.single();
+
+		if (error || !result) throw new Error('Failed to create pokedex entry');
+		return this.transformPokedexEntry(result);
 	}
 
 	async update(id: string, data: Partial<PokedexEntry>): Promise<PokedexEntry | null> {
-		return PokedexEntryModel.findByIdAndUpdate(id, data, { new: true }).exec();
+		// Transform camelCase to snake_case for database
+		const dbData: any = {};
+		if (data.pokedexNumber !== undefined) dbData.pokedex_number = data.pokedexNumber;
+		if (data.pokemon !== undefined) dbData.pokemon = data.pokemon;
+		// ... add other fields as needed
+
+		const { data: result, error } = await this.supabase
+			.from('pokedex_entries')
+			.update(dbData)
+			.eq('id', id)
+			.select()
+			.single();
+
+		if (error || !result) return null;
+		return this.transformPokedexEntry(result);
 	}
 
 	async delete(id: string): Promise<void> {
-		await PokedexEntryModel.findByIdAndDelete(id).exec();
+		await this.supabase
+			.from('pokedex_entries')
+			.delete()
+			.eq('id', id);
 	}
 }
 

src/prompt-sw.ts

@@ -20,7 +20,11 @@ self.addEventListener('message', (event) => {
 precache([{ url: '/', revision: null }]);
 
 // self.__WB_MANIFEST is default injection point
-precacheAndRoute(self.__WB_MANIFEST);
+// Handle the case where __WB_MANIFEST might be undefined in development
+const manifest = self.__WB_MANIFEST || [];
+if (Array.isArray(manifest)) {
+	precacheAndRoute(manifest);
+}
 
 // clean old assets
 cleanupOutdatedCaches();

src/routes/api/catch-records/+server.ts

@@ -1,32 +1,24 @@
-import { json, error } from '@sveltejs/kit';
-import { dbConnect, dbDisconnect } from '$lib/utils/db';
+import { json } from '@sveltejs/kit';
 import { type CatchRecord } from '$lib/models/CatchRecord';
 import CatchRecordRepository from '$lib/repositories/CatchRecordRepository';
 import { requireAuth } from '$lib/utils/auth';
 import type { RequestEvent } from '@sveltejs/kit';
 
 export const GET = async (event: RequestEvent) => {
-	let catchData = null as CatchRecord[] | null;
-
 	try {
 		const userId = await requireAuth(event);
-		await dbConnect();
-		const repo = new CatchRecordRepository();
-		catchData = await repo.findByUserId(userId);
+		const repo = new CatchRecordRepository(event.locals.supabase, userId);
+		const catchData = await repo.findByUserId(userId);
 		// order by pokedexEntryId property, ascending
-		catchData = catchData.sort((a, b) => a.pokedexEntryId - b.pokedexEntryId);
+		const sortedData = catchData.sort((a, b) => Number(a.pokedexEntryId) - Number(b.pokedexEntryId));
+		return json(sortedData);
 	} catch (error) {
 		console.error(error);
 		if (error.status) {
-			// Re-throw SvelteKit errors (like 401)
 			throw error;
 		}
 		return json({ error: 'Internal Server Error' }, { status: 500 });
-	} finally {
-		dbDisconnect();
 	}
-
-	return json(catchData);
 };
 
 export const PUT = async (event: RequestEvent) => {
@@ -37,8 +29,7 @@ export const PUT = async (event: RequestEvent) => {
 		// Ensure the userId is set to the authenticated user
 		data.userId = userId;
 		
-		await dbConnect();
-		const repo = new CatchRecordRepository();
+		const repo = new CatchRecordRepository(event.locals.supabase, userId);
 		const upsertedRecord = await repo.upsert(data);
 		return json(upsertedRecord);
 	} catch (err) {
@@ -47,8 +38,6 @@ export const PUT = async (event: RequestEvent) => {
 			throw err;
 		}
 		return json({ error: 'Internal Server Error' }, { status: 500 });
-	} finally {
-		await dbDisconnect();
 	}
 };
 
@@ -56,8 +45,7 @@ export const POST = async (event: RequestEvent) => {
 	try {
 		const userId = await requireAuth(event);
 		const records: Partial<CatchRecord>[] = await event.request.json();
-		await dbConnect();
-		const repo = new CatchRecordRepository();
+		const repo = new CatchRecordRepository(event.locals.supabase, userId);
 
 		const insertedRecords = [];
 		for (const record of records) {
@@ -74,7 +62,5 @@ export const POST = async (event: RequestEvent) => {
 			throw err;
 		}
 		return json({ error: 'Internal Server Error' }, { status: 500 });
-	} finally {
-		await dbDisconnect();
 	}
 };

src/routes/api/combined-data/+server.ts

@@ -1,5 +1,4 @@
 import { json } from '@sveltejs/kit';
-import { dbConnect, dbDisconnect } from '$lib/utils/db';
 import CombinedDataRepository from '$lib/repositories/CombinedDataRepository';
 import { requireAuth } from '$lib/utils/auth';
 import type { RequestEvent } from '@sveltejs/kit';
@@ -9,13 +8,12 @@ export const GET = async (event: RequestEvent) => {
 	const page = parseInt(url.searchParams.get('page') || '1', 10);
 	const limit = parseInt(url.searchParams.get('limit') || '20', 10);
 	const enableForms = url.searchParams.get('enableForms') === 'true';
-	const region = url.searchParams.get('region');
-	const game = url.searchParams.get('game');
+	const region = url.searchParams.get('region') || '';
+	const game = url.searchParams.get('game') || '';
 
 	try {
 		const userId = await requireAuth(event);
-		await dbConnect();
-		const repo = new CombinedDataRepository();
+		const repo = new CombinedDataRepository(event.locals.supabase, userId);
 		const combinedData = await repo.findCombinedData(userId, page, limit, enableForms, region, game);
 
 		// Return empty array instead of 404 for better UX
@@ -33,7 +31,5 @@ export const GET = async (event: RequestEvent) => {
 			throw error;
 		}
 		return json({ error: 'Internal Server Error' }, { status: 500 });
-	} finally {
-		dbDisconnect();
 	}
 };

src/routes/api/combined-data/all/+server.ts

@@ -1,5 +1,4 @@
 import { json } from '@sveltejs/kit';
-import { dbConnect, dbDisconnect } from '$lib/utils/db';
 import CombinedDataRepository from '$lib/repositories/CombinedDataRepository';
 import { requireAuth } from '$lib/utils/auth';
 import type { RequestEvent } from '@sveltejs/kit';
@@ -7,13 +6,12 @@ import type { RequestEvent } from '@sveltejs/kit';
 export const GET = async (event: RequestEvent) => {
 	const { url } = event;
 	const enableForms = url.searchParams.get('enableForms') === 'true';
-	const region = url.searchParams.get('region');
-	const game = url.searchParams.get('game');
+	const region = url.searchParams.get('region') || '';
+	const game = url.searchParams.get('game') || '';
 
 	try {
 		const userId = await requireAuth(event);
-		await dbConnect();
-		const repo = new CombinedDataRepository();
+		const repo = new CombinedDataRepository(event.locals.supabase, userId);
 		const combinedData = await repo.findAllCombinedData(userId, enableForms, region, game);
 
 		// Return empty array instead of 404 for better UX
@@ -24,7 +22,5 @@ export const GET = async (event: RequestEvent) => {
 			throw error;
 		}
 		return json({ error: 'Internal Server Error' }, { status: 500 });
-	} finally {
-		dbDisconnect();
 	}
 };

src/routes/api/pokedexentries/+server.ts

@@ -1,26 +1,14 @@
 import { json } from '@sveltejs/kit';
-import { dbConnect, dbDisconnect } from '$lib/utils/db';
-import { type PokedexEntry } from '$lib/models/PokedexEntry';
 import PokedexEntryRepository from '$lib/repositories/PokedexEntryRepository';
+import type { RequestHandler } from './$types';
 
-export const GET = async () => {
-	return json(await fetchPokeDexEntriesFromDatabase());
-};
-
-async function fetchPokeDexEntriesFromDatabase() {
-	let pokemonData = null as PokedexEntry[] | null;
-
+export const GET: RequestHandler = async (event) => {
 	try {
-		await dbConnect();
-		const repo = new PokedexEntryRepository();
-		pokemonData = await repo.findAll();
-		// order by pokedexNumber property, ascending
-		pokemonData = pokemonData.sort((a, b) => a.pokedexNumber - b.pokedexNumber);
+		const repo = new PokedexEntryRepository(event.locals.supabase);
+		const pokemonData = await repo.findAll();
+		return json(pokemonData);
 	} catch (error) {
-		console.error(error);
-	} finally {
-		dbDisconnect();
+		console.error('Error fetching pokedex entries:', error);
+		return json({ error: 'Failed to fetch pokedex entries' }, { status: 500 });
 	}
-
-	return pokemonData;
-}
+};

src/routes/mydex/+page.svelte

@@ -25,7 +25,7 @@
 	let drawerOpen = false;
 	let viewAsBoxes = false;
 	let currentPlacement = 'boxPlacementForms';
-	let boxNumbers = Array<any>;
+	let boxNumbers: number[] = [];
 
 	const unsubscribe = user.subscribe((value) => {
 		localUser = value;
@@ -109,8 +109,20 @@
 	) {
 		let catchRecordsToUpdate = combinedData
 			.filter(({ pokedexEntry }) => pokedexEntry[currentPlacement].box === boxNumber)
-			.map(({ catchRecord }) => {
-				let updatedRecord = { ...catchRecord };
+			.map(({ pokedexEntry, catchRecord }) => {
+				// Create default record if null
+				const baseRecord = catchRecord || {
+					_id: '',
+					userId: localUser?.id || '',
+					pokedexEntryId: pokedexEntry._id,
+					haveToEvolve: false,
+					caught: false,
+					inHome: false,
+					hasGigantamaxed: false,
+					personalNotes: ''
+				};
+				
+				let updatedRecord = { ...baseRecord };
 				if (inHome !== null) {
 					updatedRecord = {
 						...updatedRecord,