SQLocalKysely clean-up

src/kysely/client.ts

@@ -9,72 +9,65 @@ import {
 	SqliteIntrospector,
 	SqliteQueryCompiler,
 } from 'kysely';
-import { convertRowsToObjects } from '../lib/convert-rows-to-objects.js';
 
 export class SQLocalKysely extends SQLocal {
-	private executor = async <T>(
-		query: CompiledQuery
-	): Promise<QueryResult<T>> => {
-		const { rows, columns } = await this.exec(
-			query.sql,
-			query.parameters as unknown[],
-			'all'
-		);
-		return {
-			rows: convertRowsToObjects(rows, columns) as T[],
-		};
-	};
-
 	dialect: Dialect = {
 		createAdapter: () => new SqliteAdapter(),
-		createDriver: () => new SQLocalKyselyDriver(this, this.executor),
+		createDriver: () => new SQLocalKyselyDriver(this),
 		createIntrospector: (db) => new SqliteIntrospector(db),
 		createQueryCompiler: () => new SqliteQueryCompiler(),
 	};
 }
 
 class SQLocalKyselyDriver implements Driver {
 	private client: SQLocalKysely;
-	private executor: SQLocalKysely['executor'];
 
-	constructor(client: SQLocalKysely, executor: SQLocalKysely['executor']) {
+	constructor(client: SQLocalKysely) {
 		this.client = client;
-		this.executor = executor;
 	}
 
+	async init(): Promise<void> {}
+
 	async acquireConnection(): Promise<SQLocalKyselyConnection> {
-		return new SQLocalKyselyConnection(this.executor);
+		return new SQLocalKyselyConnection(this.client);
 	}
 
-	async beginTransaction(connection: DatabaseConnection): Promise<void> {
+	async releaseConnection(): Promise<void> {}
+
+	async beginTransaction(connection: SQLocalKyselyConnection): Promise<void> {
 		await connection.executeQuery(CompiledQuery.raw('BEGIN'));
 	}
 
-	async commitTransaction(connection: DatabaseConnection): Promise<void> {
+	async commitTransaction(connection: SQLocalKyselyConnection): Promise<void> {
 		await connection.executeQuery(CompiledQuery.raw('COMMIT'));
 	}
 
-	async rollbackTransaction(connection: DatabaseConnection): Promise<void> {
+	async rollbackTransaction(
+		connection: SQLocalKyselyConnection
+	): Promise<void> {
 		await connection.executeQuery(CompiledQuery.raw('ROLLBACK'));
 	}
 
 	async destroy(): Promise<void> {
 		await this.client.destroy();
 	}
-
-	async init(): Promise<void> {}
-	async releaseConnection(): Promise<void> {}
 }
 
 class SQLocalKyselyConnection implements DatabaseConnection {
-	private executor: SQLocalKysely['executor'];
+	private client: SQLocalKysely;
 
-	constructor(executor: SQLocalKysely['executor']) {
-		this.executor = executor;
+	constructor(client: SQLocalKysely) {
+		this.client = client;
 	}
 
-	async executeQuery<T>(query: CompiledQuery): Promise<QueryResult<T>> {
-		return await this.executor<T>(query);
+	async executeQuery<Result>(
+		query: CompiledQuery
+	): Promise<QueryResult<Result>> {
+		const rows = await this.client.sql(query.sql, ...query.parameters);
+
+		return {
+			rows: rows as Result[],
+		};
 	}
 
 	async *streamQuery(): AsyncGenerator<never, void, unknown> {

test/kysely/migrations.test.ts

@@ -1,9 +1,10 @@
-import { describe, expect, it } from 'vitest';
+import { afterEach, describe, expect, it } from 'vitest';
 import { SQLocalKysely } from '../../src/kysely';
 import { Kysely, Migrator } from 'kysely';
 
 describe('kysely migrations', () => {
-	const { dialect } = new SQLocalKysely('kysely-migrations-test.sqlite3');
+	const databasePath = 'kysely-migrations-test.sqlite3';
+	const { dialect } = new SQLocalKysely(databasePath);
 	const db = new Kysely({ dialect });
 
 	const migrator = new Migrator({
@@ -27,6 +28,11 @@ describe('kysely migrations', () => {
 		return table?.columns.map((column) => column.name);
 	};
 
+	afterEach(async () => {
+		const opfs = await navigator.storage.getDirectory();
+		await opfs.removeEntry(databasePath);
+	});
+
 	it('should migrate the database', async () => {
 		expect(await getTableNames()).toEqual([]);