@lix-js/sdk 0.5.0 → 0.6.0-preview.0

package/src/database/schema.ts

@@ -1,165 +0,0 @@
-import type {
-	ChangeView,
-	InternalChangeTable,
-} from "../change/schema-definition.js";
-import {
-	LixChangeSetElementSchema,
-	LixChangeSetSchema,
-} from "../change-set/schema-definition.js";
-import {
-	LixCommitSchema,
-	LixCommitEdgeSchema,
-} from "../commit/schema-definition.js";
-import {
-	LixVersionDescriptorSchema,
-	type LixActiveVersion,
-} from "../version/schema-definition.js";
-import { type InternalSnapshotTable } from "../snapshot/schema.js";
-import { LixStoredSchemaSchema } from "../stored-schema/schema-definition.js";
-import type {
-	FromLixSchemaDefinition,
-	LixGenerated,
-} from "../schema-definition/definition.js";
-import {
-	LixKeyValueSchema,
-	type LixKeyValue,
-} from "../key-value/schema-definition.js";
-import type {
-	StateView,
-	StateByVersionView,
-	StateWithTombstonesView,
-} from "../state/index.js";
-import type { StateHistoryView } from "../state-history/schema.js";
-import { LixDirectoryDescriptorSchema } from "../filesystem/directory/schema-definition.js";
-import { LixFileDescriptorSchema } from "../filesystem/file/schema-definition.js";
-import type {
-	EntityStateByVersionView,
-	EntityStateHistoryView,
-	EntityStateView,
-} from "../engine/entity-views/types.js";
-import { LixLogSchema } from "../log/schema-definition.js";
-import {
-	LixAccountSchema,
-	LixActiveAccountSchema,
-} from "../account/schema-definition.js";
-import { LixChangeAuthorSchema } from "../change-author/schema-definition.js";
-import { LixLabelSchema } from "../label/schema-definition.js";
-import { LixEntityLabelSchema } from "../entity/label/schema-definition.js";
-import { LixEntityConversationSchema } from "../entity/conversation/schema-definition.js";
-import {
-	LixConversationSchema,
-	LixConversationMessageSchema,
-	type LixConversationMessage,
-} from "../conversation/schema-definition.js";
-import { LixChangeProposalSchema } from "../change-proposal/schema-definition.js";
-import type { EntityViews } from "../engine/entity-views/entity-view-builder.js";
-import type { ToKysely } from "../engine/entity-views/types.js";
-import type { InternalStateAllUntrackedTable } from "../state/untracked/schema.js";
-import type { InternalFileDataCacheTable } from "../filesystem/file/cache/schema.js";
-import type { InternalFileLixcolCacheTable } from "../filesystem/file/cache/lixcol-schema.js";
-import type { InternalFilePathCacheTable } from "../filesystem/file/cache/path-cache-schema.js";
-import type { InternalTransactionStateTable } from "../state/transaction/schema.js";
-import type { InternalStateVTable } from "../state/vtable/vtable.js";
-
-export const LixDatabaseSchemaJsonColumns = {
-	snapshot: ["content"],
-	change_set: ["metadata"],
-} as const;
-
-export type LixInternalDatabaseSchema = LixDatabaseSchema & {
-	lix_internal_transaction_state: InternalTransactionStateTable;
-	lix_internal_change: InternalChangeTable;
-	lix_internal_snapshot: InternalSnapshotTable;
-	lix_internal_state_all_untracked: InternalStateAllUntrackedTable;
-	lix_internal_state_vtable: InternalStateVTable;
-	lix_internal_file_data_cache: InternalFileDataCacheTable;
-	lix_internal_file_lixcol_cache: InternalFileLixcolCacheTable;
-	lix_internal_file_path_cache: InternalFilePathCacheTable;
-	lix_internal_state_writer: InternalStateWriterTable;
-};
-
-export type InternalStateWriterTable = {
-	file_id: string;
-	version_id: string;
-	entity_id: string;
-	schema_key: string;
-	writer_key: string | null;
-};
-
-type DirectoryDescriptorView = ToKysely<
-	EntityStateView<
-		FromLixSchemaDefinition<typeof LixDirectoryDescriptorSchema> & {
-			path: LixGenerated<string>;
-		}
-	>
->;
-type DirectoryDescriptorByVersionView = ToKysely<
-	EntityStateByVersionView<
-		FromLixSchemaDefinition<typeof LixDirectoryDescriptorSchema> & {
-			path: LixGenerated<string>;
-		}
-	>
->;
-type DirectoryDescriptorHistoryView = ToKysely<
-	EntityStateHistoryView<
-		FromLixSchemaDefinition<typeof LixDirectoryDescriptorSchema> & {
-			path: LixGenerated<string>;
-		}
-	>
->;
-
-export type LixDatabaseSchema = {
-	active_account: EntityViews<
-		typeof LixActiveAccountSchema,
-		"active_account"
-	>["active_account"];
-	active_version: ToKysely<LixActiveVersion>;
-
-	state: StateView;
-	state_by_version: StateByVersionView;
-	state_with_tombstones: StateWithTombstonesView;
-	state_history: StateHistoryView;
-
-	change: ChangeView;
-	directory: DirectoryDescriptorView;
-	directory_by_version: DirectoryDescriptorByVersionView;
-	directory_history: DirectoryDescriptorHistoryView;
-} & EntityViews<
-	typeof LixKeyValueSchema,
-	"key_value",
-	{ value: LixKeyValue["value"] }
-> &
-	EntityViews<typeof LixAccountSchema, "account"> &
-	EntityViews<typeof LixChangeSetSchema, "change_set"> &
-	EntityViews<typeof LixChangeSetElementSchema, "change_set_element"> &
-	EntityViews<typeof LixChangeAuthorSchema, "change_author"> &
-	EntityViews<
-		typeof LixFileDescriptorSchema,
-		"file",
-		{
-			data: Uint8Array;
-			path: LixGenerated<string>;
-			directory_id: LixGenerated<string | null>;
-			name: LixGenerated<string>;
-			extension: LixGenerated<string | null>;
-		}
-	> &
-	EntityViews<typeof LixLabelSchema, "label"> &
-	EntityViews<typeof LixEntityLabelSchema, "entity_label"> &
-	EntityViews<typeof LixEntityConversationSchema, "entity_conversation"> &
-	EntityViews<typeof LixStoredSchemaSchema, "stored_schema", { value: any }> &
-	EntityViews<typeof LixLogSchema, "log"> &
-	EntityViews<typeof LixConversationSchema, "conversation"> &
-	EntityViews<
-		typeof LixConversationMessageSchema,
-		"conversation_message",
-		{ body: LixConversationMessage["body"] }
-	> &
-	EntityViews<typeof LixChangeProposalSchema, "change_proposal"> &
-	EntityViews<
-		typeof LixVersionDescriptorSchema,
-		"version",
-		{ commit_id: LixGenerated<string>; working_commit_id: LixGenerated<string> }
-	> &
-	EntityViews<typeof LixCommitSchema, "commit"> &
-	EntityViews<typeof LixCommitEdgeSchema, "commit_edge">;

package/src/database/sqlite/content-from-database.ts

@@ -1,12 +0,0 @@
-import type { SqliteWasmDatabase } from "./create-in-memory-database.js";
-
-/**
- * Exports the content of a database as a Uint8Array.
- *
- * @example
- *   const db = createInMemoryDatabase({ readOnly: false });
- *   const content = contentFromDatabase(db);
- */
-export const contentFromDatabase = (db: SqliteWasmDatabase): Uint8Array => {
-	return db.sqlite3.capi.sqlite3_js_db_export(db);
-};

package/src/database/sqlite/create-in-memory-database.ts

@@ -1,61 +0,0 @@
-import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
-import type { Database, Sqlite3Static } from "@sqlite.org/sqlite-wasm";
-import { wasmBinary } from "./sqlite-wasm-binary.js";
-
-// https://github.com/opral/lix-sdk/issues/231
-// @ts-expect-error -  globalThis
-globalThis.sqlite3ApiConfig = {
-	warn: (message: string, details: any) => {
-		if (message === "Ignoring inability to install OPFS sqlite3_vfs:") {
-			// filter out
-			return;
-		}
-		console.log(message + " " + details);
-	},
-};
-
-export type SqliteWasmDatabase = Database & {
-	/**
-	 * The sqlite3 module used to create the database.
-	 *
-	 * Use this API to access the sqlite3 module directly.
-	 */
-	sqlite3: Sqlite3Static;
-};
-
-let sqlite3: Sqlite3Static;
-
-/**
- * Boots a WebAssembly SQLite database that operates entirely in memory.
- *
- * The first call lazily initialises the SQLite WASM module and caches it so
- * subsequent invocations reuse the same runtime. Pass `readOnly: true` to
- * obtain a database instance that prevents writes.
- *
- * @example
- *   const db = await createInMemoryDatabase({ readOnly: false });
- */
-export const createInMemoryDatabase = async ({
-	readOnly = false,
-}: {
-	readOnly?: boolean;
-}): Promise<SqliteWasmDatabase> => {
-	if (sqlite3 === undefined) {
-		// avoiding a top level await by initializing the module here
-		sqlite3 = await sqlite3InitModule({
-			// @ts-expect-error
-			wasmBinary: wasmBinary,
-			// https://github.com/opral/inlang-sdk/issues/170#issuecomment-2334768193
-			locateFile: () => "sqlite3.wasm",
-		});
-	}
-	const flags = [
-		readOnly ? "r" : "cw", // read and write
-		"", // non verbose
-	].join("");
-
-	const db = new sqlite3.oo1.DB(":memory:", flags);
-	// @ts-expect-error - assigning new type
-	db.sqlite3 = sqlite3;
-	return db as SqliteWasmDatabase;
-};

package/src/database/sqlite/environment-dialect.test.ts

@@ -1,84 +0,0 @@
-import { afterEach, describe, expect, test, vi } from "vitest";
-import { EnvironmentDriver } from "./environment-dialect.js";
-import { CompiledQuery } from "kysely";
-
-describe("EnvironmentConnection", () => {
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	test("includes rewrittenSql in error message", async () => {
-		const backend = {
-			call: vi.fn(async () => {
-				const error = new Error("SQLITE error");
-				(error as any).originalSql = "SELECT failing";
-				(error as any).parameters = ["internal-param"];
-				(error as any).rewrittenSql = "SELECT rewritten";
-				throw error;
-			}),
-			close: vi.fn(),
-		};
-		const driver = new EnvironmentDriver({ backend } as any);
-		const connection = await driver.acquireConnection();
-
-		await expect(
-			connection.executeQuery(CompiledQuery.raw("SELECT original"))
-		).rejects.toThrow(
-			/internal query \(failed\)[\s\S]*sql: SELECT failing[\s\S]*parameters:[\s\S]*1\. "internal-param"[\s\S]*rewrittenSql: SELECT rewritten/
-		);
-	});
-
-	test("renders user query failure without internal block", async () => {
-		const backend = {
-			call: vi.fn(async () => {
-				const error = new Error("boom");
-				throw error;
-			}),
-			close: vi.fn(),
-		};
-		const driver = new EnvironmentDriver({ backend } as any);
-		const connection = await driver.acquireConnection();
-
-		await connection.executeQuery(CompiledQuery.raw("SELECT submitted")).then(
-			() => {
-				throw new Error("expected failure");
-			},
-			(error) => {
-				const message = String(error);
-				expect(message).toMatch(/user query[\s\S]*status: failed/);
-				expect(message).not.toMatch(/internal query/);
-			}
-		);
-	});
-
-	test("renders internal query block when engine runs derived SQL", async () => {
-		const backend = {
-			call: vi.fn(async () => {
-				const error = new Error("combo failure");
-				(error as any).originalSql = "SELECT failing";
-				(error as any).parameters = ["internal"];
-				throw error;
-			}),
-			close: vi.fn(),
-		};
-		const driver = new EnvironmentDriver({ backend } as any);
-		const connection = await driver.acquireConnection();
-
-		await connection
-			.executeQuery(CompiledQuery.raw("SELECT user", ["user-param"]))
-			.then(
-				() => {
-					throw new Error("expected failure");
-				},
-				(error) => {
-					const message = String(error);
-					expect(message).toMatch(
-						/user query[\s\S]*sql: SELECT user[\s\S]*parameters:[\s\S]*1\. "user-param"/
-					);
-					expect(message).toMatch(/internal query \(failed\)/);
-					expect(message).toMatch(/sql: SELECT failing/);
-					expect(message).toMatch(/parameters:[\s\S]*1\. "internal"/);
-				}
-			);
-	});
-});

package/src/database/sqlite/environment-dialect.ts

@@ -1,227 +0,0 @@
-import {
-	CompiledQuery,
-	SqliteAdapter,
-	SqliteIntrospector,
-	SqliteQueryCompiler,
-} from "kysely";
-import type { DatabaseConnection, Driver, QueryResult, Dialect } from "kysely";
-import type { LixEnvironment } from "../../environment/api.js";
-
-type LixEnvironmentDriverConfig = {
-	backend: LixEnvironment;
-};
-
-class EnvironmentConnection implements DatabaseConnection {
-	#backend: LixEnvironment;
-	// Track nested transaction depth for savepoint emulation
-	_txDepth = 0;
-	_spNames: string[] = [];
-	constructor(backend: LixEnvironment) {
-		this.#backend = backend;
-	}
-
-	async executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>> {
-		const { sql, parameters } = compiledQuery;
-		let res: any;
-		try {
-			res = await this.#backend.call("lix_execute_sync", {
-				sql,
-				parameters: (parameters ?? []) as unknown[],
-			});
-		} catch (err: any) {
-			const previewParam = (v: unknown) => {
-				try {
-					if (v instanceof Uint8Array) return `Uint8Array(len=${v.byteLength})`;
-					if (typeof v === "string") return JSON.stringify(v);
-					if (v && typeof v === "object") return JSON.stringify(v);
-					return String(v);
-				} catch {
-					return String(v);
-				}
-			};
-			const submittedSql = sql;
-			const originalSql =
-				typeof err?.originalSql === "string" && err.originalSql
-					? err.originalSql
-					: undefined;
-			const displaySql = originalSql ?? submittedSql;
-			const rewrittenSql =
-				typeof err?.rewrittenSql === "string" && err.rewrittenSql
-					? err.rewrittenSql
-					: undefined;
-			const parameterValues = Array.isArray(err?.parameters)
-				? err.parameters
-				: (parameters ?? []);
-			// Example formatted error for quick reference:
-			//
-			// executeQuery Error
-			//
-			//   - cause: "version_id is required for state mutation"
-			//   - sql:   insert into "file" ("id","path","data") values (?, ?, ?)
-			//   - params:
-			//       1: "WghuxhzbSR0XM7wdw5Pdd"
-			//       2: "/x.md"
-			//       3: Uint8Array(len=0)
-			const formatParams = (
-				target: string[],
-				values: readonly unknown[],
-				indent: string
-			) => {
-				if (values.length === 0) {
-					target.push(`${indent}(none)`);
-					return;
-				}
-				values.forEach((p, i) => {
-					target.push(`${indent}${i + 1}. ${previewParam(p)}`);
-				});
-			};
-
-			const lines: string[] = [];
-			lines.push("executeQuery Error");
-			lines.push(`- cause: "${String(err?.message ?? err)}"`);
-			lines.push("");
-			lines.push("user query");
-			lines.push(`  - sql: ${submittedSql}`);
-			lines.push("  - parameters:");
-			formatParams(lines, parameters ?? [], "      ");
-			if (displaySql === submittedSql) {
-				lines.push("  - status: failed");
-				if (rewrittenSql && rewrittenSql !== displaySql) {
-					lines.push(`  - rewrittenSql: ${rewrittenSql}`);
-				}
-			} else {
-				lines.push("");
-				lines.push("internal query (failed)");
-				lines.push(`  - sql: ${displaySql}`);
-				lines.push("  - parameters:");
-				formatParams(lines, parameterValues, "      ");
-				if (rewrittenSql) {
-					lines.push(`  - rewrittenSql: ${rewrittenSql}`);
-				}
-			}
-			const wrapped = new Error(lines.join("\n"), { cause: err });
-			throw wrapped;
-		}
-		// Map to Kysely QueryResult shape (no affected rows/insert id available)
-		return {
-			rows: (res?.rows ?? []) as O[],
-		} as QueryResult<O>;
-	}
-
-	// eslint-disable-next-line require-yield
-	async *streamQuery() {
-		throw new Error("not supported for engine driver yet");
-	}
-}
-
-export class EnvironmentDriver implements Driver {
-	readonly #config: LixEnvironmentDriverConfig;
-
-	// Global transaction coordination for a single engine.
-	// Ensures only one top‑level transaction owner at a time.
-	#owner?: EnvironmentConnection;
-	#depth = 0; // total nesting depth for owner
-	#waiters: Array<() => void> = [];
-
-	constructor(config: LixEnvironmentDriverConfig) {
-		this.#config = config;
-	}
-
-	async init(): Promise<void> {
-		// no-op
-	}
-
-	async acquireConnection(): Promise<DatabaseConnection> {
-		// Return a lightweight connection wrapper per acquire to isolate
-		// transaction state (savepoints) across concurrent transactions.
-		return new EnvironmentConnection(this.#config.backend);
-	}
-
-	async beginTransaction(connection: DatabaseConnection): Promise<void> {
-		const conn = connection as unknown as EnvironmentConnection;
-
-		// Wait our turn if another connection owns the top‑level transaction
-		while (this.#depth > 0 && this.#owner !== conn) {
-			await new Promise<void>((resolve) => this.#waiters.push(resolve));
-		}
-
-		if (this.#depth === 0) {
-			// Acquire ownership and start top‑level txn
-			this.#owner = conn;
-			this.#depth = 1;
-			conn._txDepth = 1;
-			await connection.executeQuery(CompiledQuery.raw("begin"));
-		} else {
-			// Nested transaction owned by same connection → savepoint
-			this.#depth++;
-			conn._txDepth++;
-			const spName = `lix_sp_${this.#depth}`;
-			conn._spNames.push(spName);
-			await connection.executeQuery(CompiledQuery.raw(`savepoint ${spName}`));
-		}
-	}
-
-	async commitTransaction(connection: DatabaseConnection): Promise<void> {
-		const conn = connection as unknown as EnvironmentConnection;
-		if (this.#owner !== conn) {
-			throw new Error("commit from non-owner connection");
-		}
-
-		if (conn._txDepth > 1) {
-			const spName = conn._spNames.pop()!;
-			await connection.executeQuery(
-				CompiledQuery.raw(`release savepoint ${spName}`)
-			);
-			conn._txDepth--;
-			this.#depth--;
-		} else {
-			await connection.executeQuery(CompiledQuery.raw("commit"));
-			conn._txDepth = 0;
-			this.#depth = 0;
-			this.#owner = undefined;
-			const w = this.#waiters.shift();
-			if (w) w();
-		}
-	}
-
-	async rollbackTransaction(connection: DatabaseConnection): Promise<void> {
-		const conn = connection as unknown as EnvironmentConnection;
-		if (this.#owner !== conn) {
-			throw new Error("rollback from non-owner connection");
-		}
-		if (conn._txDepth > 1) {
-			const spName = conn._spNames.pop()!;
-			await connection.executeQuery(
-				CompiledQuery.raw(`rollback to savepoint ${spName}`)
-			);
-			conn._txDepth--;
-			this.#depth--;
-		} else {
-			await connection.executeQuery(CompiledQuery.raw("rollback"));
-			conn._txDepth = 0;
-			this.#depth = 0;
-			this.#owner = undefined;
-			const w = this.#waiters.shift();
-			if (w) w();
-		}
-	}
-
-	async releaseConnection(): Promise<void> {
-		// no-op
-	}
-
-	async destroy(): Promise<void> {
-		await this.#config.backend.close();
-	}
-}
-
-export function createEnvironmentDialect(args: {
-	environment: LixEnvironment;
-}): Dialect {
-	return {
-		createAdapter: () => new SqliteAdapter(),
-		createDriver: () => new EnvironmentDriver({ backend: args.environment }),
-		createIntrospector: (db: any) => new SqliteIntrospector(db),
-		createQueryCompiler: () => new SqliteQueryCompiler(),
-	};
-}

package/src/database/sqlite/import-database.ts

@@ -1,43 +0,0 @@
-import type { SqliteWasmDatabase } from "./create-in-memory-database.js";
-
-/**
- * Loads serialized SQLite bytes into an in-memory database.
- *
- * The content is copied into the provided database and made available under
- * the configured schema. By default the database becomes writable, but you can
- * force read-only mode through the `readOnly` option.
- *
- * @example
- *   importDatabase({ db, content: new Uint8Array(bytes) });
- */
-export const importDatabase = ({
-	db,
-	content,
-	schema = "main",
-	readOnly = false,
-}: {
-	db: SqliteWasmDatabase;
-	content: Uint8Array;
-	schema?: string;
-	readOnly?: boolean;
-}): SqliteWasmDatabase => {
-	const deserializeFlag = readOnly
-		? db.sqlite3.capi.SQLITE_DESERIALIZE_READONLY
-		: db.sqlite3.capi.SQLITE_DESERIALIZE_FREEONCLOSE |
-			db.sqlite3.capi.SQLITE_DESERIALIZE_RESIZEABLE;
-
-	const contentPointer = db.sqlite3.wasm.allocFromTypedArray(content);
-	const deserializeReturnCode = db.sqlite3.capi.sqlite3_deserialize(
-		db.pointer!,
-		schema,
-		contentPointer,
-		content.byteLength, // db size
-		content.byteLength, // content size
-		deserializeFlag
-	);
-
-	// check if the deserialization was successfull
-	db.checkRc(deserializeReturnCode);
-
-	return db;
-};

package/src/database/sqlite/index.ts

@@ -1,7 +0,0 @@
-export { contentFromDatabase } from "./content-from-database.js";
-export { createInMemoryDatabase } from "./create-in-memory-database.js";
-export { importDatabase } from "./import-database.js";
-export { loadDatabaseInMemory } from "./load-database-in-memory.js";
-export type { SqliteWasmDatabase } from "./create-in-memory-database.js";
-export { createLixDialect as createEngineDialect } from "./lix-dialect.js";
-export { createEnvironmentDialect } from "./environment-dialect.js";

package/src/database/sqlite/kysely-driver/connection-mutex.ts

@@ -1,23 +0,0 @@
-export class ConnectionMutex {
-	#promise?: Promise<void>;
-	#resolve?: () => void;
-
-	async lock(): Promise<void> {
-		while (this.#promise) {
-			await this.#promise;
-		}
-
-		this.#promise = new Promise((resolve) => {
-			this.#resolve = resolve;
-		});
-	}
-
-	unlock(): void {
-		const resolve = this.#resolve;
-
-		this.#promise = undefined;
-		this.#resolve = undefined;
-
-		resolve?.();
-	}
-}

package/src/database/sqlite/kysely-driver/index.ts

@@ -1,4 +0,0 @@
-export { SqliteWasmConnection } from "./sqlite-wasm-connection.js";
-export type { SqliteWasmDialectConfig } from "./sqlite-wasm-dialect-config.js";
-export { SqliteWasmDriver } from "./sqlite-wasm-driver.js";
-export { ConnectionMutex } from "./connection-mutex.js";

package/src/database/sqlite/kysely-driver/sqlite-wasm-connection.ts

@@ -1,58 +0,0 @@
-import type { CompiledQuery, DatabaseConnection, QueryResult } from "kysely";
-import type { SqliteWasmDatabase } from "../create-in-memory-database.js";
-
-export class SqliteWasmConnection implements DatabaseConnection {
-	readonly #db: SqliteWasmDatabase;
-
-	constructor(db: SqliteWasmDatabase) {
-		this.#db = db;
-	}
-
-	executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>> {
-		const { sql, parameters } = compiledQuery;
-
-		const statementData = {
-			rows: [],
-			columns: [],
-		};
-
-		// we cant know what kind of query we are dealing with at that state - unless we switch to perpared statments
-		// for now we collect all information required
-		// save the changes before (total changes seems to be fast and worth the twoe extra round trips inspiration from https://github.com/WiseLibs/better-sqlite3/blob/254b8e93d78b1b03c9a2c777f4d304a0ea1530c6/src/objects/statement.lzz#L159)
-		const totalChangesBefore = this.#db.changes(true);
-
-		// execute the statement
-		const rows = this.#db.exec({
-			sql: sql,
-			bind: parameters as any,
-			returnValue: "resultRows",
-			rowMode: "object",
-			columnNames: statementData.columns,
-		});
-
-		const lastInsertId = this.#db.sqlite3.capi.sqlite3_last_insert_rowid(
-			this.#db
-		);
-
-		// check if we had changes in the db at all - if so - collect the number of changes
-		const changes =
-			totalChangesBefore === this.#db.changes(true) ? 0 : this.#db.changes();
-
-		// console.log('sql: ' + sql);
-		// console.log('result: ', rows);
-		// We don't have knowledge about rather its update/delete/or select - so we return the results
-		// @ts-expect-error - TODO for @martin-lysk - typescript complains
-		return Promise.resolve({
-			numAffectedRows: changes,
-			insertId: lastInsertId,
-
-			// queries with result
-			rows: rows as O[],
-		});
-	}
-
-	// eslint-disable-next-line require-yield
-	async *streamQuery(): AsyncGenerator<never, void, unknown> {
-		throw new Error("not supported for wasm driver yet");
-	}
-}