storage exceptions

Author: krizzu

shared-storage/schemas/org.asyncstorage.shared_storage.database.StorageDatabase/3.json renamed to shared-storage/schemas/org.asyncstorage.shared_storage.database.StorageDatabase/1.json

@@ -1,7 +1,7 @@
 {
   "formatVersion": 1,
   "database": {
-    "version": 3,
+    "version": 1,
     "identityHash": "4d8baac8b3ec8e6bbde4d79eb33fbcd9",
     "entities": [
       {

shared-storage/src/commonMain/kotlin/org/asyncstorage/shared_storage/SharedStorageImpl.kt

@@ -1,7 +1,5 @@
 package org.asyncstorage.shared_storage
 
-import androidx.sqlite.SQLiteException
-import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.map
@@ -28,6 +26,7 @@ internal class SharedStorageImpl(val database: StorageDatabase) : SharedStorage
             .getValuesFlow(keys)
             .map { list -> list.map(StorageEntry::toEntry) }
             .distinctUntilChanged()
+            .catchStorageException()
 
     override suspend fun setValues(entries: List<Entry>): List<Entry> = catchStorageException {
         val values = entries.map(Entry::toStorageEntry)
@@ -40,22 +39,7 @@ internal class SharedStorageImpl(val database: StorageDatabase) : SharedStorage
 
     override suspend fun getKeys(): List<String> = catchStorageException { storage.getKeys() }
 
-    override fun getKeysFlow(): Flow<List<String>> = storage.getKeysFlow()
+    override fun getKeysFlow(): Flow<List<String>> = storage.getKeysFlow().catchStorageException()
 
     override suspend fun clear() = catchStorageException { storage.clear() }
 }
-
-private suspend fun <T> catchStorageException(block: suspend () -> T): T {
-    try {
-        return block()
-    } catch (e: CancellationException) {
-        throw e
-    } catch (e: SQLiteException) {
-        throw StorageException.SqliteException(e.message ?: "Unexcepted Sqlite exception", e.cause)
-    } catch (e: Exception) {
-        throw StorageException.OtherException(
-            e.message ?: "Unknown exception: ${e::class.simpleName}",
-            e.cause,
-        )
-    }
-}

shared-storage/src/commonMain/kotlin/org/asyncstorage/shared_storage/StorageException.kt

@@ -0,0 +1,40 @@
+package org.asyncstorage.shared_storage
+
+import androidx.sqlite.SQLiteException
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.catch
+
+sealed class StorageException(message: String, cause: Throwable?) : Exception(message, cause) {
+
+    /** Catch exception thrown by sqlite itself https://www.sqlite.org/rescode.html */
+    class SqliteException(message: String, cause: Throwable?) : StorageException(message, cause)
+
+    class OtherException(message: String, cause: Throwable?) : StorageException(message, cause)
+}
+
+internal suspend fun <T> catchStorageException(block: suspend () -> T): T {
+    try {
+        return block()
+    } catch (e: CancellationException) {
+        throw e
+    } catch (e: Throwable) {
+        throw e.asStorageException()
+    }
+}
+
+internal fun <T> Flow<T>.catchStorageException(): Flow<T> = catch { throw it }
+
+private fun Throwable.asStorageException(): StorageException {
+    if (this is SQLiteException) {
+        return StorageException.SqliteException(
+            message ?: "Unexcepted Sqlite exception: ${this::class.qualifiedName}",
+            cause,
+        )
+    }
+
+    return StorageException.OtherException(
+        message ?: "Unknown storage exception: ${this::class.qualifiedName}",
+        cause,
+    )
+}

shared-storage/src/commonMain/kotlin/org/asyncstorage/shared_storage/database/StorageDatabase.kt

@@ -3,7 +3,7 @@ package org.asyncstorage.shared_storage.database
 import androidx.room.*
 import kotlinx.coroutines.flow.Flow
 
-private const val DATABASE_VERSION = 3
+private const val DATABASE_VERSION = 1
 
 @Entity(tableName = "storage")
 internal data class StorageEntry(@PrimaryKey val key: String, val value: String?)
@@ -46,8 +46,6 @@ abstract class StorageDatabase : RoomDatabase() {
     companion object
 }
 
-// The Room compiler generates the `actual` implementations.
-@Suppress("KotlinNoActualForExpect")
 expect object StorageDatabaseConstructor : RoomDatabaseConstructor<StorageDatabase> {
     override fun initialize(): StorageDatabase
 }