new db schema works perfectly first try frfr

scripts/seed.ts

@@ -1,4 +1,5 @@
 import { drizzle } from 'drizzle-orm/libsql';
+import { eq } from 'drizzle-orm';
 import { createClient } from '@libsql/client';
 import * as schema from '../src/lib/server/db/schema.js';
 import { parse } from 'csv-parse/sync';
@@ -15,160 +16,145 @@ if (!process.env.DATABASE_URL) throw new Error('DATABASE_URL is not set');
 const client = createClient({ url: process.env.DATABASE_URL });
 const db = drizzle(client, { schema });
 
-function readCSV(filename: string): Record<string, string>[] {
+function readCSV(filename: string): Record<string, any>[] {
 	const content = readFileSync(join(dataDir, filename), 'utf-8');
-	return parse(content, { columns: true, skip_empty_lines: true });
+	return parse(content, {
+		columns: true,
+		skip_empty_lines: true,
+		cast: true
+	});
 }
 
 async function seed() {
 	console.log('Resetting database...');
 
+	// Disable foreign keys globally during setup to prevent structural mismatches
 	await client.execute('PRAGMA foreign_keys = OFF');
 
-	await db.delete(schema.eventAttributions);
-	await db.delete(schema.ledgerScores);
-	await db.delete(schema.ledger);
-	await db.delete(schema.events);
-	await db.delete(schema.players);
-	await db.delete(schema.scorers);
+	await db.delete(schema.scoreLedger);
+	await db.delete(schema.mainLedger);
+	await db.delete(schema.registeredPlayers);
+	await db.delete(schema.registeredEvents);
+	await db.delete(schema.eventTypes);
 	await db.delete(schema.scoringPresets);
+	await db.delete(schema.players);
 	await db.delete(schema.divisions);
 	await db.delete(schema.teams);
 
 	await client.execute('DELETE FROM sqlite_sequence');
 
-	console.log('Database reset complete.');
+	console.log('Database reset complete. Seeding...');
 
-	console.log('Seeding teams...');
+	// --- 1. Teams ---
 	const teamsCSV = readCSV('teams.csv');
 	for (const row of teamsCSV) {
-		const result = await db
-			.insert(schema.teams)
-			.values({ name: row.name, color: row.color })
-			.returning();
-		console.log(`  Inserted team: ${result[0].name} (id: ${result[0].id})`);
+		await db.insert(schema.teams).values({ name: row.team_name, color: row.color });
 	}
 
-	console.log('Seeding divisions...');
+	// --- 2. Divisions ---
 	const divisionsCSV = readCSV('divisions.csv');
 	for (const row of divisionsCSV) {
-		const result = await db.insert(schema.divisions).values({ name: row.name }).returning();
-		console.log(`  Inserted division: ${result[0].name} (id: ${result[0].id})`);
+		await db.insert(schema.divisions).values({ name: row.div_name });
 	}
 
-	console.log('Seeding scoring presets...');
+	// --- 3. Scoring Presets ---
 	const scoringPresetsCSV = readCSV('scoringPresets.csv');
 	for (const row of scoringPresetsCSV) {
-		const result = await db
-			.insert(schema.scoringPresets)
-			.values({
-				presetID: parseInt(row.presetID),
-				placement: parseInt(row.placement),
-				points: parseInt(row.points)
-			})
-			.returning();
-		console.log(
-			`  Inserted preset: ${result[0].presetID} placement ${result[0].placement} = ${result[0].points}pts`
-		);
+		await db.insert(schema.scoringPresets).values({
+			presetID: row.preset,
+			placement: row.placement,
+			points: row.points
+		});
 	}
 
-	console.log('Seeding scorers...');
-	const scorersCSV = readCSV('scorers.csv');
-	for (const row of scorersCSV) {
-		const result = await db
-			.insert(schema.scorers)
-			.values({
-				firstName: row.firstName,
-				lastName: row.lastName,
-				email: row.email,
-				password: row.password,
-				displayName: row.displayName,
-				role: row.role
-			})
-			.returning();
-		console.log(`  Inserted scorer: ${result[0].displayName}`);
-	}
-
-	console.log('Seeding players...');
-	const teams = await db.select().from(schema.teams);
-	const divisions = await db.select().from(schema.divisions);
-	const teamMap = new Map(teams.map((t) => [t.name, t.id]));
-	const divisionMap = new Map(divisions.map((d) => [d.name, d.id]));
+	// Maps for dynamic relational lookups
+	const dbTeams = await db.select().from(schema.teams);
+	const dbDivisions = await db.select().from(schema.divisions);
+	const teamMap = new Map(dbTeams.map((t) => [t.name, t.id]));
+	const divisionMap = new Map(dbDivisions.map((d) => [d.name, d.id]));
 
+	// --- 4. Players ---
 	const playersCSV = readCSV('players.csv');
 	for (const row of playersCSV) {
 		const teamId = teamMap.get(row.team);
 		const divisionId = divisionMap.get(row.division);
 		if (!teamId) throw new Error(`Team "${row.team}" not found`);
-		if (!divisionId) throw new Error(`Division "${row.division}" not found`);
 
-		const result = await db
-			.insert(schema.players)
-			.values({
-				firstName: row.firstName,
-				lastName: row.lastName,
-				team: teamId,
-				division: divisionId
-			})
-			.returning();
-		console.log(`  Inserted player: ${result[0].firstName} ${result[0].lastName}`);
+		await db.insert(schema.players).values({
+			firstName: row.firstName,
+			lastName: row.lastName,
+			team: teamId,
+			division: divisionId || null
+		});
 	}
 
-	console.log('Seeding events...');
-	const scoringPresets = await db.select().from(schema.scoringPresets);
-	const presetMap = new Map(scoringPresets.map((p) => [p.presetID, p.presetID]));
-	const divisionMapForEvents = new Map(divisions.map((d) => [d.name, d.id]));
+	// --- 5. Event Types ---
+	const eventTypesCSV = readCSV('eventTypes.csv');
+	for (const row of eventTypesCSV) {
+		await db.insert(schema.eventTypes).values({
+			name: row.event_name,
+			preset: row.preset
+		});
+	}
 
-	const eventsCSV = readCSV('events.csv');
-	for (const row of eventsCSV) {
-		const preset = parseInt(row.preset);
-		const divisionId = divisionMapForEvents.get(row.division);
+	const dbEventTypes = await db.select().from(schema.eventTypes);
+	const eventTypeMap = new Map(dbEventTypes.map((et) => [et.name, et.id]));
+
+	// --- 6. Registered Events ---
+	// Change the Map key type to a string (the event name)
+	const eventNameMap = new Map<string, number>();
+	const registeredEventsCSV = readCSV('registeredEvents.csv');
+
+	for (const row of registeredEventsCSV) {
+		const eventTypeId = eventTypeMap.get(row.event_type);
+		const divisionId = divisionMap.get(row.division);
+
+		if (!eventTypeId) throw new Error(`Event Type "${row.event_type}" not found`);
 		if (!divisionId) throw new Error(`Division "${row.division}" not found`);
 
-		const result = await db
-			.insert(schema.events)
+		const [inserted] = await db
+			.insert(schema.registeredEvents)
 			.values({
-				name: row.name,
-				preset,
+				eventType: eventTypeId,
 				division: divisionId,
-				order: parseInt(row.order),
-				state: parseInt(row.state)
+				state: row.event_state || 0,
+				timeCompleted: row.time_completed || null
 			})
 			.returning();
-		console.log(`  Inserted event: ${result[0].name}`);
+
+		// Map the textual event name (e.g., "100m Sprint") to the generated DB ID
+		eventNameMap.set(row.event_type, inserted.id);
 	}
 
-	console.log('Seeding event attributions...');
-	const events = await db.select().from(schema.events);
-	const players = await db.select().from(schema.players);
-	const eventMap = new Map(events.map((e) => [e.name, e.id]));
-	const playerMap = new Map(players.map((p) => [`${p.firstName} ${p.lastName}`, p.id]));
+	// --- 7. Registered Players ---
+	const dbPlayers = await db.select().from(schema.players);
+	const playerMap = new Map(dbPlayers.map((p) => [`${p.firstName} ${p.lastName}`, p.id]));
+	const registeredPlayersCSV = readCSV('registeredPlayers.csv');
 
-	const eventAttributionsCSV = readCSV('eventAttributions.csv');
-	for (const row of eventAttributionsCSV) {
-		const eventId = eventMap.get(row.eventID);
-		const playerId = playerMap.get(row.playerID);
+	for (const row of registeredPlayersCSV) {
+		const playerId = playerMap.get(row.player_registered);
+		// Look up using the string event name now
+		const actualEventId = eventNameMap.get(row.event_registered);
 
-		if (!eventId) throw new Error(`Event "${row.eventID}" not found`);
-		if (!playerId) throw new Error(`Player "${row.playerID}" not found`);
+		if (!playerId) throw new Error(`Player "${row.player_registered}" not found`);
+		if (!actualEventId)
+			throw new Error(`Registered Event named "${row.event_registered}" not found`);
 
-		const result = await db
-			.insert(schema.eventAttributions)
-			.values({
-				eventID: eventId,
-				playerID: playerId
-			})
-			.returning();
-		console.log(`  Inserted attribution: event=${row.eventID}, player=${row.playerID}`);
+		await db.insert(schema.registeredPlayers).values({
+			playerID: playerId,
+			registeredEventID: actualEventId,
+			placement: row.player_placement || 0
+		});
 	}
 
-	console.log('\nSeeding complete!');
-	console.log('Ledger and ledgerScores tables are empty (reset).');
+	// Re-enable Foreign Key constraints now that the data is built cleanly
+	await client.execute('PRAGMA foreign_keys = ON');
 
+	console.log('\n✅ Seeding complete!');
 	await client.close();
 }
 
 seed().catch((err) => {
-	console.error('Seed failed:', err);
+	console.error('❌ Seed failed:', err);
 	process.exit(1);
 });