query local db file

Author: ScriptRaccoon

netlify.toml

@@ -1,3 +1,6 @@
 [build]
 	command = "pnpm run build"
-	publish = "build"
+	publish = "build"
+
+[functions]
+	included_files = ["databases/catdat/catdat.db"]

package.json

@@ -28,10 +28,12 @@
 		"@sveltejs/adapter-netlify": "^6.0.4",
 		"@sveltejs/kit": "^2.57.1",
 		"@sveltejs/vite-plugin-svelte": "^7.0.0",
+		"@types/better-sqlite3": "^7.6.13",
 		"@types/katex": "^0.16.8",
 		"@types/markdown-it": "^14.1.2",
 		"@types/node": "^25.5.0",
 		"@types/nodemailer": "^8.0.0",
+		"better-sqlite3": "^12.9.0",
 		"chokidar": "^5.0.0",
 		"dotenv": "^17.3.1",
 		"husky": "^9.1.7",

pnpm-lock.yaml

@@ -1,3 +1,5 @@
+onlyBuiltDependencies:
+    - better-sqlite3
 overrides:
     cookie@<0.7.0: '>=0.7.0'
     vite@>=8.0.0 <=8.0.4: '>=8.0.5'

pnpm-workspace.yaml

@@ -3,15 +3,15 @@ import { query } from '$lib/server/db.catdat'
 
 type AtomicImplication = { assumptions: string[]; conclusion: string }
 
-export async function check_consistency(
+export function check_consistency(
 	satisfied_properties: Set<string>,
 	unsatisfied_properties: Set<string>,
-): Promise<{ consistent: boolean } | null> {
+): { consistent: boolean } | null {
 	for (const p of satisfied_properties) {
 		if (unsatisfied_properties.has(p)) return { consistent: false }
 	}
 
-	const implications = await get_atomic_implications()
+	const implications = get_atomic_implications()
 	if (!implications) return null
 
 	return check_consistency_worker(
@@ -50,8 +50,8 @@ function check_consistency_worker(
 	return { consistent: true }
 }
 
-async function get_atomic_implications(): Promise<AtomicImplication[] | null> {
-	const { rows: implications, err } = await query<{
+function get_atomic_implications(): AtomicImplication[] | null {
+	const { rows: implications, err } = query<{
 		assumptions: string
 		conclusions: string
 		is_equivalence: number
@@ -88,18 +88,18 @@ async function get_atomic_implications(): Promise<AtomicImplication[] | null> {
 	return atomic_implications
 }
 
-export async function get_missing_combinations() {
-	const implications = await get_atomic_implications()
+export function get_missing_combinations() {
+	const implications = get_atomic_implications()
 	if (!implications) return null
 
-	const { rows: properties, err } = await query<{
+	const { rows: properties, err } = query<{
 		id: string
 		dual_property_id: string | null
 	}>(sql`SELECT id, dual_property_id FROM category_properties ORDER BY lower(id)`)
 
 	if (err) return null
 
-	const { rows: existing, err: err_existing } = await query<{
+	const { rows: existing, err: err_existing } = query<{
 		p: string
 		q: string
 	}>(sql`

src/lib/server/consistency.ts

@@ -1,43 +1,48 @@
-import { createClient, type LibsqlError } from '@libsql/client'
 import type { Arrayed } from '$lib/commons/types'
-import { CATDAT_DB_AUTH_TOKEN, CATDAT_DB_URL } from '$env/static/private'
+import Database, { SqliteError } from 'better-sqlite3'
+import { join } from 'node:path'
 
-const db = createClient({
-	url: CATDAT_DB_URL,
-	authToken: CATDAT_DB_AUTH_TOKEN,
-})
+const db_path = join(process.cwd(), 'databases', 'catdat', 'catdat.db')
 
-db.execute('PRAGMA foreign_keys = ON')
+const db = new Database(db_path, { readonly: true })
+
+db.exec('PRAGMA foreign_keys = ON')
 
 /**
- * Small wrapper around db.execute to handle errors,
+ * Small wrapper around db.prepare.all to handle errors,
  * use sql templates, and specify the type of the result.
  */
-export async function query<T>(stmt: { sql: string; values: any[] }) {
+export function query<T>(stmt: { sql: string; values: any[] }) {
 	try {
-		const { rows } = await db.execute(stmt.sql, stmt.values)
+		const rows = db.prepare(stmt.sql).all(...stmt.values)
 		return { rows: rows as T[], err: null }
 	} catch (err) {
 		console.error(err)
-		return { rows: null, err: err as LibsqlError }
+		return { rows: null, err: err as SqliteError }
 	}
 }
 
 /**
- * Small wrapper around db.batch to handle errors
+ * Small wrapper around db.transaction to handle errors
  * use sql templates, and specify the type of the result.
  */
-export async function batch<T extends any[]>(queries: { sql: string; values: any[] }[]) {
+export function batch<T extends any[]>(queries: { sql: string; values: any[] }[]) {
 	try {
-		const results = await db.batch(
-			queries.map((query) => ({
-				sql: query.sql,
-				args: query.values,
-			})),
-		)
-		return { results: results.map(({ rows }) => rows) as Arrayed<T>, err: null }
+		const run_batch = db.transaction(() => {
+			const results = []
+
+			for (const query of queries) {
+				const result = db.prepare(query.sql).all(...query.values)
+				results.push(result)
+			}
+
+			return results
+		})
+
+		const results = run_batch() as Arrayed<T>
+		return { results, err: null }
 	} catch (err) {
 		console.error(err)
-		return { results: null, err: err as LibsqlError }
+		return { rows: null, err: err as SqliteError }
 	}
 }

src/lib/server/db.catdat.ts

@@ -11,15 +11,15 @@ type NamedObject = {
 	name: string
 }
 
-export async function search_handler(event: RequestEvent, type: 'category' | 'functor') {
+export function search_handler(event: RequestEvent, type: 'category' | 'functor') {
 	const satisfied_query = event.url.searchParams.get('satisfied')
 	const unsatisfied_query = event.url.searchParams.get('unsatisfied')
 
 	if (!satisfied_query && !unsatisfied_query) {
 		error(400, 'No properties selected')
 	}
 
-	const { rows: all_properties_objects, err: err_all } = await query<{
+	const { rows: all_properties_objects, err: err_all } = query<{
 		id: string
 		dual_property_id: string | null
 	}>(get_property_query(type))
@@ -71,7 +71,7 @@ export async function search_handler(event: RequestEvent, type: 'category' | 'fu
 
 	// TODO: implement this for functors as well
 	if (type === 'category') {
-		const check = await check_consistency(
+		const check = check_consistency(
 			new Set(satisfied_properties),
 			new Set(unsatisfied_properties),
 		)
@@ -106,7 +106,7 @@ export async function search_handler(event: RequestEvent, type: 'category' | 'fu
 		type,
 	)
 
-	const { rows: found_objects, err } = await query<NamedObject>({
+	const { rows: found_objects, err } = query<NamedObject>({
 		sql: search_query,
 		values: [
 			...all_selected_properties,

src/lib/server/search.ts

@@ -4,7 +4,7 @@ import { error } from '@sveltejs/kit'
 import sql from 'sql-template-tag'
 
 export const load = async () => {
-	const { results, err } = await batch<[CategoryShort, TagObject]>([
+	const { results, err } = batch<[CategoryShort, TagObject]>([
 		sql`SELECT id, name FROM categories ORDER BY lower(name)`,
 		sql`SELECT tag FROM tags ORDER BY position`,
 	])

src/routes/categories/+page.server.ts

@@ -5,15 +5,15 @@ import sql from 'sql-template-tag'
 import type { EntryGenerator } from './$types'
 
 export const entries: EntryGenerator = async () => {
-	const { rows, err } = await query<TagObject>(sql`SELECT tag FROM tags`)
+	const { rows, err } = query<TagObject>(sql`SELECT tag FROM tags`)
 	if (err) throw new Error('Database error: Failed to load tags')
 	return rows
 }
 
 export const load = async (event) => {
 	const tag = event.params.tag
 
-	const { rows: categories, err } = await query<CategoryShort>(sql`
+	const { rows: categories, err } = query<CategoryShort>(sql`
 		SELECT c.id, c.name FROM categories c
 		LEFT JOIN category_tag_assignments t ON c.id = t.category_id
 		WHERE t.tag = ${tag}

src/routes/categories/[tag]/+page.server.ts

@@ -4,7 +4,7 @@ import { query } from '$lib/server/db.catdat'
 import { error } from '@sveltejs/kit'
 
 export const load = async () => {
-	const { rows: categories, err } = await query<CategoryShort>(sql`
+	const { rows: categories, err } = query<CategoryShort>(sql`
 		SELECT id, name FROM categories ORDER BY lower(name)
 	`)