refactor: inject the database into every servicemain

Groceries, projects, references and routines become classes holding the
Drizzle handle, wired once in services/index.ts alongside categories. Tests
build their own instance on an in-memory database. Drops the unused
projects.loadAll and projects.rename.

1 files changed, 47 insertions, 51 deletions

diff --git a/src/lib/server/services/references.ts b/src/lib/server/services/references.ts
index accf1ba..60dcc01 100644
--- a/src/lib/server/services/references.ts
+++ b/src/lib/server/services/references.ts
@@ -1,4 +1,3 @@
-import { db as defaultDb } from '$lib/server/db';
 import { references } from '$lib/server/db/schema';
 import { eq, ne, and, desc, asc } from 'drizzle-orm';
 import type { AppDatabase } from '$lib/server/db/types';
@@ -11,58 +10,55 @@ export const referenceOrder = [
 	asc(references.id),
 ];
 
-export async function loadForGrocery(
-	groceryId: number,
-	db = defaultDb,
-): Promise<Reference[]> {
-	return db
-		.select()
-		.from(references)
-		.where(eq(references.groceryId, groceryId))
-		.orderBy(...referenceOrder);
-}
+export class ReferencesService {
+	constructor(private readonly db: AppDatabase) {}
 
-/**
- * Marks `id` as the primary ref of its grocery, clearing any sibling primary
- * so at most one ref per grocery is promoted.
- */
-export async function promote(id: number, db = defaultDb): Promise<void> {
-	const [target] = await db
-		.select()
-		.from(references)
-		.where(eq(references.id, id));
-	if (!target) throw new Error('Reference not found');
+	async loadForGrocery(groceryId: number): Promise<Reference[]> {
+		return this.db
+			.select()
+			.from(references)
+			.where(eq(references.groceryId, groceryId))
+			.orderBy(...referenceOrder);
+	}
 
-	await db
-		.update(references)
-		.set({ isPrimary: true })
-		.where(eq(references.id, id));
-	await db
-		.update(references)
-		.set({ isPrimary: false })
-		.where(
-			and(eq(references.groceryId, target.groceryId), ne(references.id, id)),
-		);
-}
+	/**
+	 * Marks `id` as the primary ref of its grocery, clearing any sibling primary
+	 * so at most one ref per grocery is promoted.
+	 */
+	async promote(id: number): Promise<void> {
+		const [target] = await this.db
+			.select()
+			.from(references)
+			.where(eq(references.id, id));
+		if (!target) throw new Error('Reference not found');
 
-export async function add(
-	groceryId: number,
-	reference: string,
-	price: number | null,
-	unit: string | null,
-	qualityScore: number | null,
-	db = defaultDb,
-): Promise<Reference> {
-	const [inserted] = await db
-		.insert(references)
-		.values({ groceryId, reference, price, unit, qualityScore })
-		.returning();
-	return inserted;
-}
+		await this.db
+			.update(references)
+			.set({ isPrimary: true })
+			.where(eq(references.id, id));
+		await this.db
+			.update(references)
+			.set({ isPrimary: false })
+			.where(
+				and(eq(references.groceryId, target.groceryId), ne(references.id, id)),
+			);
+	}
+
+	async add(
+		groceryId: number,
+		reference: string,
+		price: number | null,
+		unit: string | null,
+		qualityScore: number | null,
+	): Promise<Reference> {
+		const [inserted] = await this.db
+			.insert(references)
+			.values({ groceryId, reference, price, unit, qualityScore })
+			.returning();
+		return inserted;
+	}
 
-export async function deleteReference(
-	id: number,
-	db = defaultDb,
-): Promise<void> {
-	await db.delete(references).where(eq(references.id, id));
+	async deleteReference(id: number): Promise<void> {
+		await this.db.delete(references).where(eq(references.id, id));
+	}
 }