JS-spezifische Module und Dateien entfernt, Multiplattform-Targets korrigiert

Signed-off-by: Stefan Mogeritsch <stefan.mo.co@gmail.com>

frontend/core/local-db/build.gradle.kts

@@ -11,15 +11,6 @@ plugins {
 kotlin {
   jvm()
 
-  js(IR) {
-    binaries.library()
-    browser {
-      testTask {
-        enabled = false
-      }
-    }
-  }
-
   wasmJs {
     binaries.library()
     browser {
@@ -41,19 +32,10 @@ kotlin {
       implementation(libs.sqldelight.driver.sqlite)
     }
 
-    jsMain.dependencies {
-      implementation(libs.sqldelight.driver.web)
-      implementation(npm("@sqlite.org/sqlite-wasm", libs.versions.sqliteWasm.get()))
-    }
-
     jvmTest.dependencies {
       implementation(libs.kotlin.test)
     }
 
-    jsTest.dependencies {
-      implementation(libs.kotlin.test)
-    }
-
     wasmJsMain.dependencies {
       implementation(libs.kotlin.stdlib.wasm.js)
       implementation(libs.sqldelight.driver.web)

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

@@ -1,87 +0,0 @@
-package at.mocode.frontend.core.localdb
-
-import app.cash.sqldelight.db.SqlCursor
-import app.cash.sqldelight.db.SqlDriver
-import app.cash.sqldelight.driver.worker.WebWorkerDriver
-import org.w3c.dom.Worker
-
-@Suppress("EXPECT_ACTUAL_CLASSIFIERS_ARE_IN_BETA_WARNING")
-actual class DatabaseDriverFactory {
-  actual suspend fun createDriver(): SqlDriver {
-    // Wir nutzen eine Helper-Funktion, um den Worker zu erstellen.
-    val worker = createWorker()
-    val driver = WebWorkerDriver(worker)
-
-    try {
-      val version = getVersion(driver)
-      val schemaVersion = AppDatabase.Schema.version
-
-      console.log("Database version check: Current=$version, Schema=$schemaVersion")
-
-      if (version == 0L) {
-        console.log("Creating Database Schema...")
-        try {
-          AppDatabase.Schema.create(driver).await()
-          setVersion(driver, schemaVersion)
-          console.log("Database Schema created and version set to $schemaVersion")
-        } catch (e: Throwable) {
-          // If tables already exist but a version was 0 (e.g., previous broken run), we might get here.
-          val msg = e.message ?: ""
-          if (msg.contains("already exists", ignoreCase = true)) {
-            console.warn("Tables already exist but version was 0. Assuming DB is initialized. Setting version to $schemaVersion.")
-            setVersion(driver, schemaVersion)
-          } else {
-            throw e
-          }
-        }
-      } else if (version < schemaVersion) {
-        console.log("Migrating Database Schema from $version to $schemaVersion...")
-        AppDatabase.Schema.migrate(driver, version, schemaVersion).await()
-        setVersion(driver, schemaVersion)
-        console.log("Database Schema migrated")
-      } else {
-        console.log("Database Schema is up to date.")
-      }
-    } catch (e: Throwable) {
-      console.error("Error initializing database schema:", e)
-      throw e
-    }
-
-    return driver
-  }
-
-  private suspend fun getVersion(driver: SqlDriver): Long {
-    // Workaround for QueryResult issues:
-    // We capture the cursor in a local variable and return the Boolean result from next().
-    // Then we read from the captured cursor.
-
-    var cursorRef: SqlCursor? = null
-
-    // executeQuery returns QueryResult<Boolean> because mapper returns QueryResult<Boolean>
-    val hasNext = driver.executeQuery(
-      identifier = null,
-      sql = "PRAGMA user_version;",
-      mapper = { cursor ->
-        cursorRef = cursor
-        cursor.next()
-      },
-      parameters = 0
-    ).await()
-
-    return if (hasNext) {
-      cursorRef?.getLong(0) ?: 0L
-    } else {
-      0L
-    }
-  }
-
-  private suspend fun setVersion(driver: SqlDriver, version: Long) {
-    driver.execute(null, "PRAGMA user_version = $version;", 0).await()
-  }
-}
-
-// Helper function to create the worker
-private fun createWorker(): Worker {
-  // Try the relative path again, as an absolute path might fail depending on base href
-  return js("new Worker('sqlite.worker.js')")
-}

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

@@ -1,146 +0,0 @@
-'use strict';
-
-// --- State ---
-let db = null;
-let isReady = false;
-let initError = null;
-const messageQueue = [];
-
-// --- Message Handler ---
-self.onmessage = (event) => {
-    if (!isReady) {
-      if (initError) {
-        postMessage({id: event.data?.id, error: `Worker not initialized: ${initError}`});
-      } else {
-        messageQueue.push(event);
-      }
-      return;
-    }
-    processMessage(event);
-};
-
-self.onerror = (event) => {
-  console.error('[sqlite.worker] Uncaught error:', event.message, `${event.filename}:${event.lineno}`);
-};
-
-// --- Message Processor ---
-function processMessage(event) {
-    const data = event.data;
-  if (!data) return;
-
-  let result;
-    try {
-      result = executeAction(data);
-    } catch (err) {
-      console.error('[sqlite.worker] Error processing message:', err);
-      postMessage({id: data.id, error: err?.message ?? String(err)});
-      return;
-    }
-  postMessage({id: data.id, ...result});
-}
-
-function executeAction(data) {
-  switch (data.action) {
-        case 'exec': {
-          if (!data.sql) {
-            postMessage({id: data.id, error: 'exec: Missing sql string'});
-            return null;
-          }
-          const rows = [];
-          db.exec({
-            sql: data.sql,
-            bind: data.params ?? [],
-            rowMode: 'array',
-            callback: (row) => rows.push(row),
-          });
-          return {results: {values: rows}};
-        }
-        case 'begin_transaction':
-          db.exec('BEGIN TRANSACTION;');
-          return {results: []};
-        case 'end_transaction':
-          db.exec('END TRANSACTION;');
-          return {results: []};
-        case 'rollback_transaction':
-          db.exec('ROLLBACK TRANSACTION;');
-          return {results: []};
-        default:
-          postMessage({id: data.id, error: `Unsupported action: ${data.action}`});
-          return null;
-    }
-}
-
-// --- Initialization ---
-async function init() {
-  // Load sqlite3.js via importScripts (avoids Webpack bundling issues)
-  const loadResult = tryImportScripts();
-  if (loadResult !== null) {
-    handleInitError(loadResult);
-    return;
-  }
-
-  if (typeof self.sqlite3InitModule !== 'function') {
-    handleInitError('sqlite3InitModule not found after importScripts – sqlite3.js may be corrupt or wrong version.');
-    return;
-  }
-
-  // Fetch WASM binary manually so we control the URL and can detect failures early
-  let wasmBinary;
-  try {
-    const wasmResponse = await fetch('sqlite3.wasm');
-    if (!wasmResponse.ok) {
-      handleInitError(`Failed to fetch sqlite3.wasm: ${wasmResponse.status} ${wasmResponse.statusText}`);
-      return;
-    }
-    wasmBinary = await wasmResponse.arrayBuffer();
-  } catch (e) {
-    handleInitError(`Failed to fetch sqlite3.wasm: ${e.message}`);
-    return;
-  }
-
-  try {
-    const sqlite3 = await self.sqlite3InitModule({
-      print: console.log,
-      printErr: console.error,
-      wasmBinary,
-    });
-
-    const dbName = 'app.db';
-    if ('opfs' in sqlite3) {
-      console.log(`[sqlite.worker] Using persistent OPFS database: ${dbName}`);
-      db = new sqlite3.oo1.OpfsDb(dbName);
-    } else {
-      console.warn('[sqlite.worker] OPFS not available – falling back to in-memory database');
-      db = new sqlite3.oo1.DB(dbName);
-    }
-
-    // Flush buffered messages
-    isReady = true;
-    console.log(`[sqlite.worker] Ready. Flushing ${messageQueue.length} buffered message(s).`);
-    while (messageQueue.length > 0) {
-      processMessage(messageQueue.shift());
-    }
-  } catch (e) {
-    handleInitError(e?.message ?? String(e));
-  }
-}
-
-function tryImportScripts() {
-  try {
-    importScripts('sqlite3.js');
-    return null;
-    } catch (e) {
-    return `importScripts('sqlite3.js') failed – is the file served at root? ${e.message}`;
-  }
-}
-
-function handleInitError(message) {
-  initError = message;
-  console.error('[sqlite.worker] Initialization failed:', message);
-  while (messageQueue.length > 0) {
-        const queued = messageQueue.shift();
-        postMessage({id: queued.data?.id, error: `Worker initialization failed: ${initError}`});
-    }
-}
-
-init();

frontend/core/local-db/src/wasmJsMain/kotlin/at/mocode/frontend/core/localdb/DatabaseDriverFactory.wasmJs.kt

@@ -6,15 +6,8 @@ import app.cash.sqldelight.db.SqlDriver
 actual class DatabaseDriverFactory {
   actual suspend fun createDriver(): SqlDriver {
     // Provisorische Implementierung für den Build-Erfolg
-    // In einer echten Umgebung müsste hier der WebWorkerDriver konfiguriert werden,
-    // sobald die org.w3c.dom Abhängigkeiten korrekt aufgelöst werden können.
+    // WebWorkerDriver für WasmJs erfordert org.w3c.dom (DOM-Library),
+    // welche in diesem Projekt für WasmJs noch nicht vollständig konfiguriert ist.
     throw UnsupportedOperationException("Database on Wasm is not yet fully implemented due to missing org.w3c.dom")
   }
-
-  private suspend fun getVersion(driver: SqlDriver): Long {
-    return 0L
-  }
-
-  private suspend fun setVersion(driver: SqlDriver, version: Long) {
-  }
 }