react-native-nitro-storage 0.11.0 → 0.13.0

package/android/src/main/java/com/nitrostorage/DiskSqliteStore.kt

@@ -2,28 +2,71 @@ package com.nitrostorage
 
 import android.content.Context
 import android.content.SharedPreferences
+import android.database.DatabaseErrorHandler
 import android.database.sqlite.SQLiteDatabase
+import android.database.sqlite.SQLiteDatabaseCorruptException
+import android.database.sqlite.SQLiteException
+import java.io.ByteArrayOutputStream
 import java.io.File
 
+internal typealias DiskDatabaseOpener = (path: String, flags: Int) -> SQLiteDatabase
+
+internal fun openDiskDatabase(path: String, flags: Int): SQLiteDatabase {
+    return SQLiteDatabase.openDatabase(path, null, flags, DatabaseErrorHandler { })
+}
+
+internal fun openDiskDatabaseWithWalFallback(
+    path: String,
+    opener: DiskDatabaseOpener,
+): SQLiteDatabase {
+    val flags = SQLiteDatabase.CREATE_IF_NECESSARY or SQLiteDatabase.NO_LOCALIZED_COLLATORS
+    return try {
+        opener(path, flags or SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING)
+    } catch (walError: SQLiteDatabaseCorruptException) {
+        throw walError
+    } catch (walError: SQLiteException) {
+        try {
+            opener(path, flags)
+        } catch (fallbackError: Exception) {
+            walError.addSuppressed(fallbackError)
+            throw walError
+        }
+    }
+}
+
 internal class DiskSqliteStore(
     context: Context,
     private val legacyPreferences: SharedPreferences,
+    opener: DiskDatabaseOpener = ::openDiskDatabase,
 ) {
-    private val db: SQLiteDatabase
+    private val db: SQLiteDatabase =
+        openDiskDatabaseWithWalFallback(databaseFile(context).path, opener)
 
     init {
-        val file = File(context.filesDir, DATABASE_NAME)
-        db = SQLiteDatabase.openOrCreateDatabase(file, null)
-        // PRAGMA journal_mode returns a row; Android forbids result-bearing SQL on execSQL.
-        db.rawQuery("PRAGMA journal_mode=WAL", null).close()
-        db.execSQL("PRAGMA synchronous=NORMAL")
-        db.execSQL(
-            "CREATE TABLE IF NOT EXISTS kv (key TEXT PRIMARY KEY NOT NULL, value TEXT NOT NULL)",
-        )
-        db.execSQL(
-            "CREATE TABLE IF NOT EXISTS meta (k TEXT PRIMARY KEY NOT NULL, v TEXT NOT NULL)",
-        )
-        migrateLegacyPreferences()
+        try {
+            db.execSQL(synchronousPragmaFor(queryPragma("PRAGMA journal_mode")))
+            db.execSQL(
+                "CREATE TABLE IF NOT EXISTS kv (key TEXT PRIMARY KEY NOT NULL, value TEXT NOT NULL)",
+            )
+            db.execSQL(
+                "CREATE TABLE IF NOT EXISTS meta (k TEXT PRIMARY KEY NOT NULL, v TEXT NOT NULL)",
+            )
+            migrateLegacyPreferences()
+        } catch (e: Exception) {
+            db.close()
+            throw e
+        }
+    }
+
+    private fun queryPragma(sql: String): String? {
+        return db.rawQuery(sql, null).use { cursor ->
+            if (cursor.moveToFirst()) cursor.getString(0) else null
+        }
+    }
+
+    @Synchronized
+    fun close() {
+        db.close()
     }
 
     @Synchronized
@@ -36,9 +79,39 @@ internal class DiskSqliteStore(
 
     @Synchronized
     fun get(key: String): String? {
-        db.rawQuery("SELECT value FROM kv WHERE key = ? LIMIT 1", arrayOf(key)).use { cursor ->
-            return if (cursor.moveToFirst()) cursor.getString(0) else null
+        db.rawQuery(
+            "SELECT length(CAST(value AS BLOB)), " +
+                "CASE WHEN length(CAST(value AS BLOB)) <= $VALUE_CHUNK_BYTES THEN value END " +
+                "FROM kv WHERE key = ? LIMIT 1",
+            arrayOf(key),
+        ).use { cursor ->
+            if (!cursor.moveToFirst()) {
+                return null
+            }
+            if (!cursor.isNull(1)) {
+                return cursor.getString(1)
+            }
+            return readLargeValue(key, cursor.getLong(0))
+        }
+    }
+
+    private fun readLargeValue(key: String, byteCount: Long): String {
+        val bytes = ByteArrayOutputStream(byteCount.coerceAtMost(Int.MAX_VALUE.toLong()).toInt())
+        var offset = 1L
+        while (offset <= byteCount) {
+            val chunk = db.rawQuery(
+                "SELECT substr(CAST(value AS BLOB), ?, $VALUE_CHUNK_BYTES) FROM kv WHERE key = ?",
+                arrayOf(offset.toString(), key),
+            ).use { cursor ->
+                if (cursor.moveToFirst()) cursor.getBlob(0) else null
+            }
+            if (chunk == null || chunk.isEmpty()) {
+                break
+            }
+            bytes.write(chunk, 0, chunk.size)
+            offset += chunk.size
         }
+        return String(bytes.toByteArray(), Charsets.UTF_8)
     }
 
     @Synchronized
@@ -57,17 +130,13 @@ internal class DiskSqliteStore(
     @Synchronized
     fun setBatch(keys: Array<String>, values: Array<String>) {
         val count = minOf(keys.size, values.size)
-        db.beginTransaction()
-        try {
+        inTransaction {
             for (index in 0 until count) {
                 db.execSQL(
                     "INSERT OR REPLACE INTO kv(key, value) VALUES(?, ?)",
                     arrayOf(keys[index], values[index]),
                 )
             }
-            db.setTransactionSuccessful()
-        } finally {
-            db.endTransaction()
         }
     }
 
@@ -78,14 +147,10 @@ internal class DiskSqliteStore(
 
     @Synchronized
     fun removeBatch(keys: Array<String>) {
-        db.beginTransaction()
-        try {
+        inTransaction {
             for (key in keys) {
                 db.execSQL("DELETE FROM kv WHERE key = ?", arrayOf(key))
             }
-            db.setTransactionSuccessful()
-        } finally {
-            db.endTransaction()
         }
         removeLegacyKeys(keys.asIterable())
     }
@@ -103,19 +168,12 @@ internal class DiskSqliteStore(
 
     @Synchronized
     fun getKeysByPrefix(prefix: String): Array<String> {
-        val pattern = buildString {
-            for (character in prefix) {
-                // LIKE stops at NUL; startsWith below checks the complete prefix.
-                if (character == '\u0000') break
-                if (character == '%' || character == '_' || character == '\\') append('\\')
-                append(character)
-            }
-            append('%')
+        val cursor = if (hasUnpairedSurrogate(prefix)) {
+            db.rawQuery("SELECT key FROM kv WHERE key LIKE ? ESCAPE '\\'", arrayOf(likePattern(prefix)))
+        } else {
+            db.rawQuery("SELECT key FROM kv WHERE key >= ?1 AND key < (?1 || x'FF')", arrayOf(prefix))
         }
-        db.rawQuery(
-            "SELECT key FROM kv WHERE key LIKE ? ESCAPE '\\'",
-            arrayOf(pattern),
-        ).use { cursor ->
+        cursor.use {
             val keys = ArrayList<String>(cursor.count)
             while (cursor.moveToNext()) {
                 val key = cursor.getString(0)
@@ -152,8 +210,7 @@ internal class DiskSqliteStore(
             }
         }
 
-        db.beginTransaction()
-        try {
+        inTransaction {
             for ((key, value) in legacyPreferences.all) {
                 if (value is String) {
                     db.execSQL(
@@ -166,9 +223,25 @@ internal class DiskSqliteStore(
                 "INSERT OR REPLACE INTO meta(k, v) VALUES(?, ?)",
                 arrayOf(PREFS_MIGRATION_KEY, "1"),
             )
+        }
+    }
+
+    private inline fun inTransaction(block: () -> Unit) {
+        db.beginTransaction()
+        var failure: Throwable? = null
+        try {
+            block()
             db.setTransactionSuccessful()
+        } catch (error: Throwable) {
+            failure = error
+            throw error
         } finally {
-            db.endTransaction()
+            try {
+                db.endTransaction()
+            } catch (error: SQLiteException) {
+                val primary = failure ?: throw error
+                primary.addSuppressed(error)
+            }
         }
     }
 
@@ -182,8 +255,52 @@ internal class DiskSqliteStore(
         editor.apply()
     }
 
-    private companion object {
-        const val DATABASE_NAME = "nitro-storage-disk.sqlite"
-        const val PREFS_MIGRATION_KEY = "prefs_v1"
+    companion object {
+        private const val DATABASE_NAME = "nitro-storage-disk.sqlite"
+        private const val PREFS_MIGRATION_KEY = "prefs_v1"
+        private const val VALUE_CHUNK_BYTES = 512 * 1024
+
+        fun databaseFile(context: Context): File = File(context.filesDir, DATABASE_NAME)
+
+        fun deleteDatabaseFiles(context: Context) {
+            SQLiteDatabase.deleteDatabase(databaseFile(context))
+        }
+    }
+}
+
+private fun hasUnpairedSurrogate(value: String): Boolean {
+    var index = 0
+    while (index < value.length) {
+        val character = value[index]
+        if (Character.isHighSurrogate(character)) {
+            if (index + 1 >= value.length || !Character.isLowSurrogate(value[index + 1])) {
+                return true
+            }
+            index += 2
+        } else if (Character.isLowSurrogate(character)) {
+            return true
+        } else {
+            index += 1
+        }
+    }
+    return false
+}
+
+private fun likePattern(prefix: String): String {
+    return buildString {
+        for (character in prefix) {
+            if (character == '\u0000') break
+            if (character == '%' || character == '_' || character == '\\') append('\\')
+            append(character)
+        }
+        append('%')
+    }
+}
+
+internal fun synchronousPragmaFor(journalMode: String?): String {
+    return if (journalMode.equals("wal", ignoreCase = true)) {
+        "PRAGMA synchronous=NORMAL"
+    } else {
+        "PRAGMA synchronous=FULL"
     }
 }

package/cpp/bindings/HybridStorage.cpp

@@ -434,6 +434,7 @@ void HybridStorage::removeBatch(const std::vector<std::string>& keys, double sco
 }
 
 void HybridStorage::removeByPrefix(const std::string& prefix, double scope) {
+    toScope(scope);
     if (prefix.empty()) {
         return;
     }
@@ -462,17 +463,23 @@ void HybridStorage::setSecureAccessControl(double level) {
         throw std::runtime_error("NitroStorage: Invalid access control level");
     }
     ensureAdapter();
-    nativeAdapter_->setSecureAccessControl(intLevel);
+    runAdapterOperation(
+        [&] { nativeAdapter_->setSecureAccessControl(intLevel); },
+        "Secure access control");
 }
 
 void HybridStorage::setSecureWritesAsync(bool enabled) {
     ensureAdapter();
-    nativeAdapter_->setSecureWritesAsync(enabled);
+    runAdapterOperation(
+        [&] { nativeAdapter_->setSecureWritesAsync(enabled); },
+        "Secure write mode");
 }
 
 void HybridStorage::setKeychainAccessGroup(const std::string& group) {
     ensureAdapter();
-    nativeAdapter_->setKeychainAccessGroup(group);
+    runAdapterOperation(
+        [&] { nativeAdapter_->setKeychainAccessGroup(group); },
+        "Keychain access group");
 }
 
 // --- Biometric ---
@@ -517,7 +524,8 @@ void HybridStorage::deleteSecureBiometric(const std::string& key) {
 
 bool HybridStorage::hasSecureBiometric(const std::string& key) {
     ensureAdapter();
-    return nativeAdapter_->hasSecureBiometric(key);
+    return runAdapterOperation(
+        [&] { return nativeAdapter_->hasSecureBiometric(key); }, "Biometric has");
 }
 
 void HybridStorage::clearSecureBiometric() {