refactor: improve error handling and initialization in frontend tasks

Updated PingViewModel to reset errorMessage on each task execution and provide detailed error messages. Enhanced SQLite worker initialization with manual WASM binary loading and improved error handling. Adjusted Gradle tasks and Webpack config for SQLite assets, ensuring seamless builds. Included dummy modules to bypass Webpack resolution issues.

frontend/core/local-db/src/jsMain/kotlin/at/mocode/frontend/core/localdb/DatabaseDriverFactory.js.kt

@@ -3,15 +3,16 @@ package at.mocode.frontend.core.localdb
 import app.cash.sqldelight.db.SqlDriver
 import app.cash.sqldelight.driver.worker.WebWorkerDriver
 import org.w3c.dom.Worker
+import org.w3c.dom.WorkerOptions
+import org.w3c.dom.WorkerType
 
+@Suppress("EXPECT_ACTUAL_CLASSIFIERS_ARE_IN_BETA_WARNING")
 actual class DatabaseDriverFactory {
     actual suspend fun createDriver(): SqlDriver {
-        // Load the worker script.
-        // We use a simple string path instead of `new URL(..., import.meta.url)` to prevent Webpack
-        // from trying to resolve/bundle this file at build time.
-        // The file 'sqlite.worker.js' is copied to the root of the distribution by the Gradle build script.
-        val worker = Worker("sqlite.worker.js")
-
+        // Wir nutzen eine Helper-Funktion, um den Worker zu erstellen.
+        // Dies ermöglicht uns, 'new URL(..., import.meta.url)' in JS zu verwenden,
+        // was Webpack dazu bringt, den Pfad korrekt aufzulösen.
+        val worker = createWorker()
         val driver = WebWorkerDriver(worker)
 
         // Initialize schema asynchronously
@@ -20,3 +21,10 @@ actual class DatabaseDriverFactory {
         return driver
     }
 }
+
+// Helper function to create the worker using proper URL resolution
+private fun createWorker(): Worker {
+    return js("""
+        new Worker(new URL('sqlite.worker.js', import.meta.url), { type: 'module' })
+    """)
+}

frontend/core/local-db/src/jsMain/resources/sqlite.worker.js

@@ -1,10 +1,14 @@
 import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
 
+console.log("Worker: sqlite.worker.js loaded. Starting initialization...");
+
 // Minimal worker protocol compatible with SQLDelight's `web-worker-driver`.
 // Mirrors the message format used by SQLDelight's `sqljs.worker.js` implementation.
 function runWorker({ driver }) {
+    console.log("Worker: runWorker called");
     let db = null;
     const open = (name) => {
+        console.log("Worker: Opening database", name);
         db = driver.open(name);
     };
 
@@ -41,28 +45,59 @@ function runWorker({ driver }) {
                     throw new Error(`Unsupported action: ${data && data.action}`);
             }
         } catch (err) {
+            console.error("Worker: Error processing message", err);
             return postMessage({ id: data && data.id, error: err?.message ?? String(err) });
         }
     };
 }
 
-sqlite3InitModule({
-    print: console.log,
-    printErr: console.error,
-}).then((sqlite3) => {
-    const opfsAvailable = 'opfs' in sqlite3;
+// Error handling wrapper
+self.onerror = function(event) {
+    console.error("Error in Web Worker (onerror):", event.message, event.filename, event.lineno);
+    // Optionally, send the error back to the main thread
+    self.postMessage({ type: 'error', message: event.message, filename: event.filename, lineno: event.lineno });
+};
 
-    runWorker({
-        driver: {
-            open: (name) => {
-                if (opfsAvailable) {
-                    console.log("Initialisiere persistente OPFS Datenbank: " + name);
-                    return new sqlite3.oo1.OpfsDb(name);
-                } else {
-                    console.warn("OPFS nicht verfügbar, Fallback auf In-Memory");
-                    return new sqlite3.oo1.DB(name);
+// Manually fetch the WASM file to bypass Webpack/sqlite-wasm loading issues
+async function init() {
+    try {
+        console.log("Worker: Fetching sqlite3.wasm manually...");
+        const response = await fetch('/sqlite3.wasm');
+        if (!response.ok) {
+            throw new Error(`Failed to fetch sqlite3.wasm: ${response.status} ${response.statusText}`);
+        }
+        const wasmBinary = await response.arrayBuffer();
+        console.log("Worker: sqlite3.wasm fetched successfully, size:", wasmBinary.byteLength);
+
+        console.log("Worker: Calling sqlite3InitModule with wasmBinary...");
+        const sqlite3 = await sqlite3InitModule({
+            print: console.log,
+            printErr: console.error,
+            wasmBinary: wasmBinary // Provide the binary directly!
+        });
+
+        console.log("Worker: sqlite3InitModule resolved successfully");
+        const opfsAvailable = 'opfs' in sqlite3;
+        console.log("Worker: OPFS available:", opfsAvailable);
+
+        runWorker({
+            driver: {
+                open: (name) => {
+                    if (opfsAvailable) {
+                        console.log("Initialisiere persistente OPFS Datenbank: " + name);
+                        return new sqlite3.oo1.OpfsDb(name);
+                    } else {
+                        console.warn("OPFS nicht verfügbar, Fallback auf In-Memory");
+                        return new sqlite3.oo1.DB(name);
+                    }
                 }
             }
-        }
-    });
-});
+        });
+
+    } catch (e) {
+        console.error("Database initialization error in worker:", e);
+        self.postMessage({ type: 'error', message: 'Database initialization failed: ' + e.message });
+    }
+}
+
+init();

frontend/core/local-db/src/wasmJsMain/resources/sqlite.worker.js

@@ -44,23 +44,40 @@ function runWorker({ driver }) {
     };
 }
 
-sqlite3InitModule({
-    print: console.log,
-    printErr: console.error,
-}).then((sqlite3) => {
-    const opfsAvailable = 'opfs' in sqlite3;
+// Error handling wrapper
+self.onerror = function(event) {
+    console.error("Error in Web Worker:", event.message, event.filename, event.lineno);
+    // Optionally, send the error back to the main thread
+    self.postMessage({ type: 'error', message: event.message, filename: event.filename, lineno: event.lineno });
+};
 
-    runWorker({
-        driver: {
-            open: (name) => {
-                if (opfsAvailable) {
-                    console.log("Initialisiere persistente OPFS Datenbank: " + name);
-                    return new sqlite3.oo1.OpfsDb(name);
-                } else {
-                    console.warn("OPFS nicht verfügbar, Fallback auf In-Memory");
-                    return new sqlite3.oo1.DB(name);
+try {
+    sqlite3InitModule({
+        print: console.log,
+        printErr: console.error,
+    }).then((sqlite3) => {
+        try {
+            const opfsAvailable = 'opfs' in sqlite3;
+
+            runWorker({
+                driver: {
+                    open: (name) => {
+                        if (opfsAvailable) {
+                            console.log("Initialisiere persistente OPFS Datenbank: " + name);
+                            return new sqlite3.oo1.OpfsDb(name);
+                        } else {
+                            console.warn("OPFS nicht verfügbar, Fallback auf In-Memory");
+                            return new sqlite3.oo1.DB(name);
+                        }
+                    }
                 }
-            }
+            });
+        } catch (e) {
+             console.error("Database initialization error in worker (inner):", e);
+             self.postMessage({ type: 'error', message: 'Database initialization failed (inner): ' + e.message });
         }
     });
-});
+} catch (e) {
+    console.error("Database initialization error in worker (outer):", e);
+    self.postMessage({ type: 'error', message: 'Database initialization failed (outer): ' + e.message });
+}