refactor: Improve database connection handling and error checking

- In `AndroidSafeRepo`, introduce a private `noteQueries` getter that throws an `SQLiteException` if the database holder is null, ensuring safer access.
- In `MainViewModel`:
    - Refactor `checkDbConnection` into a suspend function `hasDbConnection` that returns a boolean, improving control flow.
    - `launchNotes` is now a single coroutine launch that first checks `hasDbConnection` before proceeding.
    - Ensure UI navigation to the splash screen on database errors happens on the main dispatcher.
- In `JvmCipherUtils`, use the more specific `java.sql.SQLException` for exception handling instead of the fully qualified name.

Author: softartdev

core/data/db-sqldelight/src/androidMain/kotlin/com/softartdev/notedelight/repository/AndroidSafeRepo.kt

@@ -1,6 +1,7 @@
 package com.softartdev.notedelight.repository
 
 import android.content.Context
+import android.database.sqlite.SQLiteException
 import android.text.SpannableStringBuilder
 import app.cash.sqldelight.db.QueryResult
 import app.cash.sqldelight.db.SqlCursor
@@ -11,6 +12,7 @@ import com.softartdev.notedelight.db.NoteDAO
 import com.softartdev.notedelight.db.SqlDelightDbHolder
 import com.softartdev.notedelight.db.SqlDelightNoteDAO
 import com.softartdev.notedelight.model.PlatformSQLiteState
+import com.softartdev.notedelight.shared.db.NoteQueries
 import com.softartdev.notedelight.util.CoroutineDispatchers
 
 class AndroidSafeRepo(
@@ -29,11 +31,14 @@ class AndroidSafeRepo(
         }
 
     override val noteDAO: NoteDAO
-        get() = SqlDelightNoteDAO({ databaseHolder!!.noteQueries }, coroutineDispatchers)
+        get() = SqlDelightNoteDAO(::noteQueries, coroutineDispatchers)
 
     override val dbPath: String
         get() = context.getDatabasePath(DB_NAME).absolutePath
 
+    private val noteQueries : NoteQueries
+        get() = databaseHolder?.noteQueries ?: throw SQLiteException("dnHolder is null")
+
     override suspend fun buildDbIfNeed(passphrase: CharSequence): SqlDelightDbHolder {
         var instance = databaseHolder
         if (instance == null) {

core/data/db-sqldelight/src/jvmMain/kotlin/com/softartdev/notedelight/db/JvmCipherUtils.kt

@@ -10,6 +10,7 @@ import java.nio.charset.StandardCharsets
 import java.sql.Connection
 import java.sql.DriverManager
 import java.sql.ResultSet
+import java.sql.SQLException
 import java.sql.Statement
 
 object JvmCipherUtils {
@@ -28,7 +29,7 @@ object JvmCipherUtils {
             try {
                 DriverManager.registerDriver(driver)
                 logger.d { "SQLite JDBC driver (sqlite-jdbc-crypt) registered successfully" }
-            } catch (e: java.sql.SQLException) {
+            } catch (e: SQLException) {
                 if (e.message?.contains("already registered") == true) {
                     logger.d { "SQLite JDBC driver already registered" }
                 } else {
@@ -52,7 +53,7 @@ object JvmCipherUtils {
                 val driverClass = Class.forName(SQLITE_JDBC_DRIVER)
                 val driver = driverClass.getDeclaredConstructor().newInstance() as java.sql.Driver
                 val props = java.util.Properties()
-                driver.connect(url, props) ?: throw java.sql.SQLException("Failed to connect to encrypted database")
+                driver.connect(url, props) ?: throw SQLException("Failed to connect to encrypted database")
             } catch (e: Exception) {
                 logger.e(e) { "Failed to create encrypted connection, falling back to DriverManager" }
                 DriverManager.getConnection(url)

core/presentation/src/commonMain/kotlin/com/softartdev/notedelight/presentation/main/MainViewModel.kt

@@ -16,6 +16,7 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 
 class MainViewModel(
     private val safeRepo: SafeRepo,
@@ -44,18 +45,20 @@ class MainViewModel(
         is MainAction.OnRefresh -> updateNotes()
     }
 
-    fun launchNotes() {
-        checkDbConnection()
-        if (job != null) return
+    fun launchNotes() = viewModelScope.launch {
+        if (!hasDbConnection()) return@launch
+        if (job != null) return@launch
         updateNotes()
     }
 
-    private fun checkDbConnection() = viewModelScope.launch(coroutineDispatchers.io) {
+    private suspend fun hasDbConnection(): Boolean {
         try {
-            val count: Long = safeRepo.noteDAO.count()
+            val count: Long = withContext(coroutineDispatchers.io) { safeRepo.noteDAO.count() }
             logger.d { "check DB connection, notes: $count" }
+            return true
         } catch (throwable: Throwable) {
             handleError("Error checking DB connection", throwable)
+            return false
         }
     }
 
@@ -81,7 +84,7 @@ class MainViewModel(
 
     private fun handleError(message: String, throwable: Throwable) {
         logger.e(message, throwable)
-        if (isDbError(throwable)) {
+        if (isDbError(throwable)) viewModelScope.launch(coroutineDispatchers.main) {
             router.navigateClearingBackStack(AppNavGraph.Splash)
         }
         mutableStateFlow.value = NoteListResult.Error(throwable.message)