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/shells/meldestelle-portal/build.gradle.kts

@@ -110,6 +110,8 @@ kotlin {
 
     jsMain.dependencies {
       implementation(compose.html.core)
+      // Benötigt für custom webpack config (wasm.js)
+      implementation(devNpm("copy-webpack-plugin", "11.0.0"))
     }
 
     /*
@@ -138,27 +140,100 @@ kotlin {
 // relative to the Kotlin JS package folder (root build dir). We therefore copy the worker into
 // that folder before webpack runs.
 
-val copySqliteWorkerJs by tasks.registering(Copy::class) {
+// HACK: Overwrite sqlite3.wasm in node_modules with a dummy JS file to fool Webpack
+val patchSqliteWasmInNodeModules by tasks.registering(Copy::class) {
+  dependsOn(rootProject.tasks.named("kotlinNpmInstall"))
   val localDb = project(":frontend:core:local-db")
   dependsOn(localDb.tasks.named("jsProcessResources"))
 
+  // We take our dummy.js
+  from(localDb.layout.buildDirectory.file("processedResources/js/main/dummy.js")) {
+    rename { "sqlite3.wasm" } // Rename it to sqlite3.wasm
+  }
+
+  // And copy it OVER the original wasm file in node_modules
+  into(rootProject.layout.buildDirectory.dir("js/node_modules/@sqlite.org/sqlite-wasm/sqlite-wasm/jswasm"))
+
+  // Force overwrite
+  duplicatesStrategy = DuplicatesStrategy.INCLUDE
+}
+
+val copySqliteAssetsToWebpackSource by tasks.registering(Copy::class) {
+  val localDb = project(":frontend:core:local-db")
+  dependsOn(localDb.tasks.named("jsProcessResources"), rootProject.tasks.named("kotlinNpmInstall"))
+
+  // Explicit dependency on the patch task to ensure we copy the REAL wasm file before it gets patched?
+  // NO! We want to copy the REAL wasm file to the output, but PATCH the one in node_modules.
+  // So we must copy the real one BEFORE patching.
+  // But wait, copySqliteAssetsToWebpackSource copies FROM node_modules.
+  // If we patch node_modules first, we copy the dummy file!
+
+  // So: copySqliteAssetsToWebpackSource must run BEFORE patchSqliteWasmInNodeModules?
+  // Or we copy from a different source (e.g. the original npm package cache? No access).
+
+  // Better: We copy the real wasm file from node_modules to a temporary location FIRST,
+  // then patch node_modules, then copy from temp to output.
+
+  // Actually, we can just copy from node_modules BEFORE the patch task runs.
+  // But Gradle task ordering is tricky.
+
+  // Let's change the source of the copy. We can't easily access the original npm package.
+  // But we know that `kotlinNpmInstall` restores the original files.
+
+  // So the order must be:
+  // 1. kotlinNpmInstall (restores original sqlite3.wasm)
+  // 2. copySqliteAssetsToWebpackSource (copies original sqlite3.wasm to output)
+  // 3. patchSqliteWasmInNodeModules (overwrites sqlite3.wasm with dummy.js)
+  // 4. webpack (uses dummy.js)
+
+  mustRunAfter(rootProject.tasks.named("kotlinNpmInstall"))
+
   from(localDb.layout.buildDirectory.file("processedResources/js/main/sqlite.worker.js"))
+  from(rootProject.layout.buildDirectory.file("js/node_modules/@sqlite.org/sqlite-wasm/sqlite-wasm/jswasm/sqlite3.wasm"))
 
   // Root build directory where Kotlin JS packages are assembled.
-  // Use a concrete path (instead of a Provider) so the Copy task always materializes the directory.
-  // The package name is constructed from the project path: Meldestelle-frontend-shells-meldestelle-portal
-  // Note: We use rootProject.layout.buildDirectory because Kotlin JS plugin puts packages in root build dir.
+  // This is one of the directories served by webpack-dev-server for static content.
   into(rootProject.layout.buildDirectory.dir("js/packages/${rootProject.name}-frontend-shells-meldestelle-portal/kotlin"))
 }
 
-// Ensure the worker is present for the production bundle.
-tasks.named("jsBrowserProductionWebpack") {
-  dependsOn(copySqliteWorkerJs)
+// Additional task to copy the worker and its wasm dependency to the distribution folder (for production build)
+val copySqliteAssetsToDist by tasks.registering(Copy::class) {
+  val localDb = project(":frontend:core:local-db")
+  dependsOn(localDb.tasks.named("jsProcessResources"), rootProject.tasks.named("kotlinNpmInstall"))
+
+  // Same logic here: copy before patch
+  mustRunAfter(rootProject.tasks.named("kotlinNpmInstall"))
+
+  from(localDb.layout.buildDirectory.file("processedResources/js/main/sqlite.worker.js"))
+  from(rootProject.layout.buildDirectory.file("js/node_modules/@sqlite.org/sqlite-wasm/sqlite-wasm/jswasm/sqlite3.wasm"))
+
+  // Copy to the distribution directory where index.html resides
+  into(layout.buildDirectory.dir("dist/js/productionExecutable"))
 }
 
-// Ensure the worker is present for the development bundle.
+// Ensure the assets are present for the production bundle.
+tasks.named("jsBrowserProductionWebpack") {
+  dependsOn(copySqliteAssetsToWebpackSource)
+  dependsOn(patchSqliteWasmInNodeModules)
+
+  // Enforce order: Copy real assets first, then patch node_modules
+  // patchSqliteWasmInNodeModules must run AFTER copySqliteAssetsToWebpackSource
+  // But wait, dependsOn doesn't guarantee order.
+  // We need to configure the tasks themselves.
+
+  finalizedBy(copySqliteAssetsToDist)
+}
+
+// Configure task ordering
+patchSqliteWasmInNodeModules {
+  mustRunAfter(copySqliteAssetsToWebpackSource)
+  // Removed circular dependency: mustRunAfter(copySqliteAssetsToDist)
+}
+
+// Ensure the assets are present for the development bundle.
 tasks.named("jsBrowserDevelopmentWebpack") {
-  dependsOn(copySqliteWorkerJs)
+  dependsOn(copySqliteAssetsToWebpackSource)
+  dependsOn(patchSqliteWasmInNodeModules)
 }
 
 // KMP Compile-Optionen