feat(rn-native-module): handle errors from shared storage

Author: krizzu

packages/async-storage/android/src/main/kotlin/org/asyncstorage/storage/PersistentStorage.kt

@@ -1,8 +1,10 @@
 package org.asyncstorage.storage
 
 import android.content.Context
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableMap
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.EmptyCoroutineContext
 import kotlinx.coroutines.CancellationException
@@ -12,6 +14,7 @@ import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.plus
 import org.asyncstorage.shared_storage.SharedStorage
+import org.asyncstorage.shared_storage.StorageException
 
 private val createStorageScope = { name: String ->
     CoroutineScope(SupervisorJob() + CoroutineName(name))
@@ -69,7 +72,26 @@ private fun <T> CoroutineScope.lunchWithRejection(promise: Promise, block: suspe
         } catch (e: CancellationException) {
             throw e
         } catch (e: Exception) {
-            promise.reject(code = "AsyncStorageException", message = e.message, throwable = e)
+
+            var userInfo: WritableMap? = null
+
+            if (e is StorageException) {
+                userInfo =
+                    Arguments.createMap().also {
+                        if (e is StorageException.SqliteException) {
+                            it.putString("type", "SqliteException")
+                        } else {
+                            it.putString("type", "OtherException")
+                        }
+                    }
+            }
+
+            promise.reject(
+                code = "AsyncStorageError",
+                message = e.message,
+                throwable = e,
+                userInfo = userInfo,
+            )
         }
     }
 }

packages/async-storage/apple/storage/PersistentStorage.swift

@@ -91,11 +91,33 @@ func runWithReject(_ reject: @escaping RCTPromiseRejectBlock, block: @escaping (
     Task {
         do {
             try await block()
-        } catch {
-            if error is CancellationError {
-                throw error
+        } catch let error as CancellationError {
+            throw error
+        } catch let error as NSError {
+            if let exception = error.getStorageException() {
+                reject("AsyncStorageError", exception.localizedDescription, exception)
+            } else {
+                reject("AsyncStorageError", error.localizedDescription, error)
             }
+        } catch {
             reject("AsyncStorageError", error.localizedDescription, error)
         }
     }
 }
+
+extension NSError {
+    func getStorageException() -> NSError? {
+        guard let exception = userInfo["KotlinException"] as? StorageException else {
+            return nil
+        }
+
+        if exception is StorageException.SqliteException {
+            return NSError(domain: "SqliteException", code: 0, userInfo: [NSLocalizedDescriptionKey: exception.message ?? exception.description(), "type": "SqliteException"])
+
+        } else if exception is StorageException.SqliteException {
+            return NSError(domain: "OtherException", code: 0, userInfo: [NSLocalizedDescriptionKey: exception.message ?? exception.description(), "type": "OtherException"])
+        }
+
+        return nil
+    }
+}