Merge pull request #2 from contember/fixes

fix: fire-and-forget query execution + bugfixes

Author: matej21

bun.lock

@@ -24,6 +24,17 @@ export default {
 			bundleCEF: true,
 			defaultRenderer: 'cef',
 			icon: 'assets/icon.png',
+			chromiumFlags: {
+				'disable-gpu': false,
+				'disable-gpu-compositing': false,
+				'disable-gpu-sandbox': false,
+				'enable-software-rasterizer': false,
+				'force-software-rasterizer': false,
+				'disable-accelerated-2d-canvas': false,
+				'disable-accelerated-video-decode': false,
+				'disable-accelerated-video-encode': false,
+				'disable-gpu-memory-buffer-video-frames': false,
+			},
 		},
 		win: {
 			bundleCEF: false,

electrobun.config.ts

@@ -45,7 +45,7 @@
 		"@sqlite.org/sqlite-wasm": "^3.51.2-build6",
 		"@tanstack/solid-virtual": "^3.13.6",
 		"codemirror": "^6.0.1",
-		"electrobun": "1.14.4",
+		"electrobun": "1.16.0",
 		"lucide-solid": "^0.575.0",
 		"simple-icons": "^16.10.0"
 	},

package.json

@@ -204,7 +204,15 @@ emitToFrontend = (channel: string, payload: unknown) => {
 }
 
 // Wire up BE→FE notifications after window creation
-connectionManager.onStatusChanged((event) => {
+connectionManager.onSessionDead((event) => {
+	sessionManager.handleSessionDead(event.sessionId)
+	emitToFrontend!('session.changed', {
+		connectionId: event.connectionId,
+		sessions: sessionManager.listSessions(event.connectionId),
+	})
+})
+
+connectionManager.onStatusChanged(async (event) => {
 	emitToFrontend!('connections.statusChanged', {
 		connectionId: event.connectionId,
 		state: event.state,
@@ -224,16 +232,17 @@ connectionManager.onStatusChanged((event) => {
 
 	// Restore sessions after successful reconnect
 	if (event.state === 'connected') {
-		sessionManager.handleConnectionRestored(event.connectionId).then((restored) => {
+		try {
+			const restored = await sessionManager.handleConnectionRestored(event.connectionId)
 			if (restored.length > 0) {
 				emitToFrontend!('session.changed', {
 					connectionId: event.connectionId,
 					sessions: restored,
 				})
 			}
-		}).catch((err) => {
+		} catch (err) {
 			console.warn('Session restoration failed:', err instanceof Error ? err.message : err)
-		})
+		}
 	}
 })
 

src/backend-desktop/index.ts

@@ -15,8 +15,8 @@ export interface DatabaseDriver extends SqlDialect {
 	getSessionIds(): string[]
 
 	// Query execution
-	execute(sql: string, params?: unknown[], sessionId?: string): Promise<QueryResult>
-	cancel(sessionId?: string): Promise<void>
+	execute(sql: string, params?: unknown[], sessionId?: string, poolQueryKey?: symbol): Promise<QueryResult>
+	cancel(sessionId?: string, poolQueryKey?: symbol): Promise<void>
 
 	// Streaming iteration — yields batches of rows from a query
 	iterate(
@@ -46,4 +46,6 @@ export interface DatabaseDriver extends SqlDialect {
 	commit(sessionId?: string): Promise<void>
 	rollback(sessionId?: string): Promise<void>
 	inTransaction(sessionId?: string): boolean
+	isTxAborted(sessionId?: string): boolean
+	isIterating(sessionId?: string): boolean
 }

src/backend-shared/db/driver.ts

@@ -0,0 +1,23 @@
+import type { DatabaseDriver } from './driver'
+
+/**
+ * Run a callback within an ephemeral (auto-created, auto-released) session.
+ * Handles reserve → try/fn → cancel → release lifecycle.
+ */
+export async function withEphemeralSession<T>(
+	driver: DatabaseDriver,
+	fn: (sessionId: string) => Promise<T>,
+): Promise<T> {
+	const sessionId = `__ephemeral_${crypto.randomUUID()}`
+	await driver.reserveSession(sessionId)
+	try {
+		return await fn(sessionId)
+	} finally {
+		try {
+			await driver.cancel(sessionId)
+		} catch { /* best effort */ }
+		try {
+			await driver.releaseSession(sessionId)
+		} catch { /* best effort */ }
+	}
+}

src/backend-shared/db/ephemeral-session.ts

@@ -5,7 +5,8 @@ import { AuthenticationError, ConnectionError, ConstraintError, DatabaseError, Q
 /** Map a PostgreSQL error to a domain error. PostgreSQL errors carry a `code` property (SQLSTATE). */
 export function mapPostgresError(err: unknown): DatabaseError {
 	const message = err instanceof Error ? err.message : String(err)
-	const pgCode = (err as any)?.code as string | undefined
+	// Bun SQL stores SQLSTATE in errno, postgres.js uses code
+	const pgCode = ((err as any)?.errno ?? (err as any)?.code) as string | undefined
 
 	// Connection errors
 	if (/ECONNREFUSED|connection refused/i.test(message)) {

src/backend-shared/db/error-mapping.ts

@@ -93,8 +93,18 @@ export class LoggingDriver implements DatabaseDriver {
 	ping(): Promise<void> {
 		return this.inner.ping()
 	}
-	loadSchema(sessionId?: string): Promise<SchemaData> {
-		return this.inner.loadSchema(sessionId)
+	async loadSchema(sessionId?: string): Promise<SchemaData> {
+		console.debug('[SQL] loadSchema started' + (sessionId ? ` (session: ${sessionId})` : ''))
+		const start = performance.now()
+		try {
+			const result = await this.inner.loadSchema(sessionId)
+			const tables = Object.values(result.tables).reduce((sum, t) => sum + t.length, 0)
+			console.debug(`[SQL] loadSchema completed — ${result.schemas.length} schemas, ${tables} tables (${Math.round(performance.now() - start)}ms)`)
+			return result
+		} catch (err) {
+			console.debug(`[SQL ERROR] loadSchema failed (${Math.round(performance.now() - start)}ms)`, err)
+			throw err
+		}
 	}
 	beginTransaction(sessionId?: string): Promise<void> {
 		return this.inner.beginTransaction(sessionId)
@@ -108,6 +118,12 @@ export class LoggingDriver implements DatabaseDriver {
 	inTransaction(sessionId?: string): boolean {
 		return this.inner.inTransaction(sessionId)
 	}
+	isTxAborted(sessionId?: string): boolean {
+		return this.inner.isTxAborted(sessionId)
+	}
+	isIterating(sessionId?: string): boolean {
+		return this.inner.isIterating(sessionId)
+	}
 	getDriverType(): 'postgresql' | 'sqlite' | 'mysql' {
 		return (this.inner as any).getDriverType()
 	}

src/backend-shared/db/logging-driver.ts

@@ -0,0 +1,62 @@
+import { stripLiteralsAndComments } from '@dotaz/shared/sql'
+import type { ReservedSQL } from 'bun'
+
+/** Minimal interface for transaction state tracking. */
+interface TxTrackable {
+	txActive: boolean
+	txAborted?: boolean
+}
+
+/** Detect raw transaction-control statements and sync txActive/txAborted flags. */
+export function syncTxActive(session: TxTrackable, sql: string): void {
+	const upper = stripLiteralsAndComments(sql).trim().toUpperCase()
+	if (/^(BEGIN|START\s+TRANSACTION)\b/.test(upper)) {
+		session.txActive = true
+		if ('txAborted' in session) session.txAborted = false
+	} else if (/^(COMMIT|END)\b/.test(upper)) {
+		session.txActive = false
+		if ('txAborted' in session) session.txAborted = false
+	} else if (/^ROLLBACK\b/.test(upper) && !/^ROLLBACK\s+TO\b/.test(upper)) {
+		session.txActive = false
+		if ('txAborted' in session) session.txAborted = false
+	}
+}
+
+/** Detect connection-level errors (TCP drop, reset, etc.) as opposed to protocol errors. */
+export function isConnectionLevelError(err: unknown): boolean {
+	const code = (err as any)?.code
+	if (typeof code === 'string' && /^(ECONNRESET|ECONNREFUSED|EPIPE|ETIMEDOUT|ENOTCONN)$/.test(code)) {
+		return true
+	}
+	// fallback for errors without .code (Bun-specific, string messages, etc.)
+	const message = err instanceof Error ? err.message : String(err)
+	return /ECONNRESET|ECONNREFUSED|EPIPE|ETIMEDOUT|connection (terminated|ended|closed|lost|reset)|socket.*(closed|hang up|end)|write after end|broken pipe|network/i
+		.test(message)
+}
+
+/**
+ * Safely release a reserved connection back to the pool.
+ * Optionally rolls back, then runs the reset function (e.g. DISCARD ALL or RESET CONNECTION),
+ * releases the connection, or closes it if reset/release fails.
+ */
+export async function safeReleaseConnection(
+	conn: ReservedSQL,
+	resetFn: (conn: ReservedSQL) => Promise<void>,
+	options?: { rollback?: boolean },
+): Promise<void> {
+	if (options?.rollback) {
+		try {
+			await conn.unsafe('ROLLBACK')
+		} catch { /* ignore — no tx is fine */ }
+	}
+	try {
+		await resetFn(conn)
+		try {
+			conn.release()
+		} catch { /* broken connection */ }
+	} catch {
+		try {
+			conn.close({ timeout: 0 })
+		} catch { /* already dead */ }
+	}
+}