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

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);
 	}
 }