react-native-nitro-storage 0.10.4 → 0.12.0

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

@@ -3,6 +3,9 @@
 package com.nitrostorage
 
 import android.content.Context
+import android.database.sqlite.SQLiteDatabaseCorruptException
+import android.database.sqlite.SQLiteException
+import android.database.sqlite.SQLiteFullException
 import android.os.Build
 import android.security.keystore.KeyGenParameterSpec
 import android.security.keystore.KeyPermanentlyInvalidatedException
@@ -33,7 +36,9 @@ private fun Throwable.storageErrorCode(): String? {
         return taggedCode
     }
     return when {
-        hasCause(AEADBadTagException::class.java) -> "storage_corruption"
+        hasCause(SQLiteFullException::class.java) -> "storage_full"
+        hasCause(SQLiteDatabaseCorruptException::class.java) ||
+            hasCause(AEADBadTagException::class.java) -> "storage_corruption"
         hasCause(UserNotAuthenticatedException::class.java) ||
             hasCause(KeyStoreException::class.java) -> "authentication_required"
         hasCause(KeyPermanentlyInvalidatedException::class.java) ||
@@ -61,24 +66,50 @@ private fun Throwable.wrapStorageException(
 class AndroidStorageAdapter private constructor(private val context: Context) {
     private val sharedPreferences: SharedPreferences =
         context.getSharedPreferences("NitroStorage", Context.MODE_PRIVATE)
-    private val diskStore: DiskSqliteStore = DiskSqliteStore(context, sharedPreferences)
+    private val diskStore: DiskSqliteStore by lazy {
+        DiskSqliteStore(context, sharedPreferences)
+    }
 
     private val masterKeyAlias = "${context.packageName}.nitro_storage.master_key"
 
-    private val masterKey: MasterKey = try {
-        MasterKey.Builder(context, masterKeyAlias)
-            .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
-            .build()
-    } catch (e: Exception) {
-        throw RuntimeException("NitroStorage: Cannot create encryption key. Device may not support AES256-GCM.", e)
+    private val masterKey: MasterKey by lazy {
+        try {
+            createDefaultMasterKey()
+        } catch (e: Exception) {
+            throw permanentSecureStoreError(
+                "NitroStorage: Cannot create the Secure encryption key.",
+                e,
+            )
+        }
     }
 
-    private val encryptedPreferences: SharedPreferences = initializeEncryptedPreferences(
-        "NitroStorageSecure",
-        masterKey,
-        masterKeyAlias,
-        ::createDefaultMasterKey,
-    )
+    private val encryptedPreferences: SharedPreferences by lazy {
+        try {
+            initializeEncryptedPreferences(
+                "NitroStorageSecure",
+                masterKey,
+                masterKeyAlias,
+                ::createDefaultMasterKey,
+            )
+        } catch (e: Exception) {
+            throw permanentSecureStoreError(
+                "NitroStorage: Cannot open Secure storage.",
+                e,
+            )
+        }
+    }
+
+    private fun permanentSecureStoreError(message: String, cause: Exception): RuntimeException {
+        if (cause.message?.contains("[nitro-error:storage_corruption]") == true &&
+            cause is RuntimeException
+        ) {
+            return cause
+        }
+        return RuntimeException(
+            "[nitro-error:storage_corruption] $message ${cause.message ?: ""}".trimEnd(),
+            cause,
+        )
+    }
 
     private val biometricMasterKeyAlias = "${context.packageName}.nitro_storage.biometric_key"
     private val biometricOrPasscodeMasterKeyAlias =
@@ -273,25 +304,55 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
 
     private fun existingBiometricPreferences(): List<SharedPreferences> {
         val stores = mutableListOf<SharedPreferences>()
+        if (
+            biometricOrPasscodeInitialized ||
+            preferencesFileExists("NitroStorageBiometricOrPasscode")
+        ) {
+            stores.add(biometricOrPasscodePreferences)
+        }
+        if (
+            legacyBiometricInitialized ||
+            preferencesFileExists("NitroStorageBiometric")
+        ) {
+            stores.add(legacyBiometricPreferences)
+        }
         if (
             biometricOnlyInitialized ||
             preferencesFileExists("NitroStorageBiometricOnly")
         ) {
             stores.add(biometricOnlyPreferences)
         }
+        return stores
+    }
+
+    private fun <T : Any> firstInExistingBiometricPreferences(
+        lookup: (SharedPreferences) -> T?,
+    ): T? {
         if (
             biometricOrPasscodeInitialized ||
             preferencesFileExists("NitroStorageBiometricOrPasscode")
         ) {
-            stores.add(biometricOrPasscodePreferences)
+            lookup(biometricOrPasscodePreferences)?.let { return it }
         }
         if (
             legacyBiometricInitialized ||
             preferencesFileExists("NitroStorageBiometric")
         ) {
-            stores.add(legacyBiometricPreferences)
+            lookup(legacyBiometricPreferences)?.let { return it }
         }
-        return stores
+        if (
+            biometricOnlyInitialized ||
+            preferencesFileExists("NitroStorageBiometricOnly")
+        ) {
+            lookup(biometricOnlyPreferences)?.let { return it }
+        }
+        return null
+    }
+
+    private fun biometricPreferencesContain(key: String): Boolean {
+        return firstInExistingBiometricPreferences { preferences ->
+            if (preferences.contains(key)) true else null
+        } ?: false
     }
 
     private fun biometricPreferencesForLevel(level: Int): SharedPreferences {
@@ -518,59 +579,73 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
 
         // --- Disk ---
 
+        private inline fun <T> diskOperation(
+            operation: String,
+            block: DiskSqliteStore.() -> T,
+        ): T {
+            val instance = getInstanceOrThrow()
+            try {
+                return instance.diskStore.block()
+            } catch (e: SQLiteException) {
+                throw e.wrapStorageException(
+                    "NitroStorage: Disk SQLite $operation failed: ${e.message}",
+                )
+            }
+        }
+
         @JvmStatic
         fun setDisk(key: String, value: String) {
-            getInstanceOrThrow().diskStore.set(key, value)
+            diskOperation("set") { set(key, value) }
         }
 
         @JvmStatic
         fun setDiskBatch(keys: Array<String>, values: Array<String>) {
-            getInstanceOrThrow().diskStore.setBatch(keys, values)
+            diskOperation("set") { setBatch(keys, values) }
         }
 
         @JvmStatic
         fun getDisk(key: String): String? {
-            return getInstanceOrThrow().diskStore.get(key)
+            return diskOperation("get") { get(key) }
         }
 
         @JvmStatic
         fun getDiskBatch(keys: Array<String>): Array<String?> {
-            return getInstanceOrThrow().diskStore.getBatch(keys)
+            return diskOperation("get") { getBatch(keys) }
         }
 
         @JvmStatic
         fun deleteDisk(key: String) {
-            getInstanceOrThrow().diskStore.remove(key)
+            diskOperation("remove") { remove(key) }
         }
 
         @JvmStatic
         fun deleteDiskBatch(keys: Array<String>) {
-            getInstanceOrThrow().diskStore.removeBatch(keys)
+            diskOperation("remove") { removeBatch(keys) }
         }
 
         @JvmStatic
         fun hasDisk(key: String): Boolean {
-            return getInstanceOrThrow().diskStore.has(key)
+            return diskOperation("has") { has(key) }
         }
 
         @JvmStatic
         fun getAllKeysDisk(): Array<String> {
-            return getInstanceOrThrow().diskStore.getAllKeys()
+            return diskOperation("getAllKeys") { getAllKeys() }
         }
 
         @JvmStatic
         fun getKeysByPrefixDisk(prefix: String): Array<String> {
-            return getInstanceOrThrow().diskStore.getKeysByPrefix(prefix)
+            return diskOperation("getKeysByPrefix") { getKeysByPrefix(prefix) }
         }
 
         @JvmStatic
         fun sizeDisk(): Int {
-            return getInstanceOrThrow().diskStore.size()
+            return diskOperation("size") { size() }
         }
 
         @JvmStatic
         fun clearDisk() {
-            getInstanceOrThrow().diskStore.clear()
+            diskOperation("clear") { clear() }
         }
 
         // --- Secure (async apply by default, sync commit when requested) ---
@@ -663,7 +738,7 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
             if (inst.encryptedPreferences.contains(key)) {
                 return true
             }
-            return inst.existingBiometricPreferences().any { it.contains(key) }
+            return inst.biometricPreferencesContain(key)
         }
 
         @JvmStatic
@@ -776,13 +851,9 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         fun getSecureBiometric(key: String): String? {
             val inst = getInstanceOrThrow()
             return try {
-                for (preferences in inst.existingBiometricPreferences()) {
-                    val value = inst.getSecureSafe(preferences, key)
-                    if (value != null) {
-                        return value
-                    }
+                inst.firstInExistingBiometricPreferences { preferences ->
+                    inst.getSecureSafe(preferences, key)
                 }
-                null
             } catch (e: Exception) {
                 throw e.wrapStorageException(
                     "NitroStorage: Failed to read biometric storage: ${e.message}",
@@ -809,7 +880,7 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         fun hasSecureBiometric(key: String): Boolean {
             val inst = getInstanceOrThrow()
             return try {
-                inst.existingBiometricPreferences().any { it.contains(key) }
+                inst.biometricPreferencesContain(key)
             } catch (e: Exception) {
                 throw e.wrapStorageException(
                     "NitroStorage: Failed to inspect biometric storage: ${e.message}",

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

@@ -9,21 +9,25 @@ internal class DiskSqliteStore(
     context: Context,
     private val legacyPreferences: SharedPreferences,
 ) {
-    private val db: SQLiteDatabase
+    private val db: SQLiteDatabase =
+        SQLiteDatabase.openOrCreateDatabase(File(context.filesDir, DATABASE_NAME), null)
 
     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 {
+            // 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()
+        } catch (e: Exception) {
+            db.close()
+            throw e
+        }
     }
 
     @Synchronized
@@ -44,6 +48,7 @@ internal class DiskSqliteStore(
     @Synchronized
     fun remove(key: String) {
         db.execSQL("DELETE FROM kv WHERE key = ?", arrayOf(key))
+        removeLegacyKeys(listOf(key))
     }
 
     @Synchronized
@@ -86,6 +91,7 @@ internal class DiskSqliteStore(
         } finally {
             db.endTransaction()
         }
+        removeLegacyKeys(keys.asIterable())
     }
 
     @Synchronized
@@ -135,6 +141,9 @@ internal class DiskSqliteStore(
     @Synchronized
     fun clear() {
         db.execSQL("DELETE FROM kv")
+        if (legacyPreferences.all.isNotEmpty()) {
+            legacyPreferences.edit().clear().apply()
+        }
     }
 
     private fun migrateLegacyPreferences() {
@@ -167,6 +176,16 @@ internal class DiskSqliteStore(
         }
     }
 
+    private fun removeLegacyKeys(keys: Iterable<String>) {
+        val present = keys.filter { legacyPreferences.contains(it) }
+        if (present.isEmpty()) {
+            return
+        }
+        val editor = legacyPreferences.edit()
+        present.forEach { editor.remove(it) }
+        editor.apply()
+    }
+
     private companion object {
         const val DATABASE_NAME = "nitro-storage-disk.sqlite"
         const val PREFS_MIGRATION_KEY = "prefs_v1"

package/app.plugin.js

@@ -1,11 +1,11 @@
+const fs = require("fs");
+const path = require("path");
 const {
   withInfoPlist,
   withAndroidManifest,
   withDangerousMod,
   createRunOncePlugin,
-} = require("@expo/config-plugins");
-const fs = require("fs");
-const path = require("path");
+} = require("expo/config-plugins");
 const pkg = require("./package.json");
 
 const DATA_EXTRACTION_RULES_RESOURCE =
@@ -84,63 +84,61 @@ function writeAndroidBackupFiles(projectRoot) {
   );
 }
 
-const withNitroStorage = (config, props = {}) => {
-  const defaultFaceIDPermission =
-    "Allow $(PRODUCT_NAME) to use Face ID for secure authentication";
-  const {
-    faceIDPermission,
-    addBiometricPermissions = false,
-    configureAndroidBackup = true,
-  } = props;
-
-  config = withInfoPlist(config, (config) => {
-    if (
-      typeof faceIDPermission === "string" &&
-      faceIDPermission.trim() !== ""
-    ) {
-      config.modResults.NSFaceIDUsageDescription = faceIDPermission;
-    } else if (!config.modResults.NSFaceIDUsageDescription) {
-      config.modResults.NSFaceIDUsageDescription = defaultFaceIDPermission;
-    }
-    return config;
-  });
+const DEFAULT_FACE_ID_PERMISSION =
+  "Allow $(PRODUCT_NAME) to use Face ID for secure authentication";
 
-  config = withAndroidManifest(config, (config) => {
-    if (configureAndroidBackup) {
-      ensureBackupAttributes(config.modResults);
-    }
+const BIOMETRIC_PERMISSIONS = [
+  "android.permission.USE_BIOMETRIC",
+  "android.permission.USE_FINGERPRINT",
+];
 
-    if (!addBiometricPermissions) {
-      return config;
-    }
+function applyInfoPlist(infoPlist, props = {}) {
+  const { faceIDPermission } = props;
+  if (typeof faceIDPermission === "string" && faceIDPermission.trim() !== "") {
+    infoPlist.NSFaceIDUsageDescription = faceIDPermission;
+  } else if (!infoPlist.NSFaceIDUsageDescription) {
+    infoPlist.NSFaceIDUsageDescription = DEFAULT_FACE_ID_PERMISSION;
+  }
+  return infoPlist;
+}
 
-    if (!config.modResults.manifest["uses-permission"]) {
-      config.modResults.manifest["uses-permission"] = [];
-    }
+function applyAndroidManifest(androidManifest, props = {}) {
+  const { addBiometricPermissions = false, configureAndroidBackup = true } =
+    props;
 
-    const permissions = config.modResults.manifest["uses-permission"];
+  if (configureAndroidBackup) {
+    ensureBackupAttributes(androidManifest);
+  }
 
-    const biometricPermission = {
-      $: { "android:name": "android.permission.USE_BIOMETRIC" },
-    };
-    const fingerprintPermission = {
-      $: { "android:name": "android.permission.USE_FINGERPRINT" },
-    };
+  if (!addBiometricPermissions) {
+    return androidManifest;
+  }
 
-    const hasBiometric = permissions.some(
-      (p) => p.$?.["android:name"] === "android.permission.USE_BIOMETRIC",
-    );
-    const hasFingerprint = permissions.some(
-      (p) => p.$?.["android:name"] === "android.permission.USE_FINGERPRINT",
-    );
+  if (!androidManifest.manifest["uses-permission"]) {
+    androidManifest.manifest["uses-permission"] = [];
+  }
 
-    if (!hasBiometric) {
-      permissions.push(biometricPermission);
-    }
-    if (!hasFingerprint) {
-      permissions.push(fingerprintPermission);
+  const permissions = androidManifest.manifest["uses-permission"];
+  for (const name of BIOMETRIC_PERMISSIONS) {
+    const present = permissions.some((p) => p.$?.["android:name"] === name);
+    if (!present) {
+      permissions.push({ $: { "android:name": name } });
     }
+  }
+
+  return androidManifest;
+}
+
+const withNitroStorage = (config, props = {}) => {
+  const { configureAndroidBackup = true } = props;
+
+  config = withInfoPlist(config, (config) => {
+    applyInfoPlist(config.modResults, props);
+    return config;
+  });
 
+  config = withAndroidManifest(config, (config) => {
+    applyAndroidManifest(config.modResults, props);
     return config;
   });
 
@@ -164,6 +162,8 @@ module.exports = createRunOncePlugin(
 );
 module.exports.withNitroStorage = withNitroStorage;
 module.exports._internal = {
+  applyInfoPlist,
+  applyAndroidManifest,
   dataExtractionRulesXml,
   fullBackupContentXml,
   ensureBackupAttributes,

package/cpp/bindings/HybridStorage.cpp

@@ -1,4 +1,5 @@
 #include "HybridStorage.hpp"
+#include <algorithm>
 #include <cmath>
 #include <stdexcept>
 
@@ -32,8 +33,8 @@ HybridStorage::HybridStorage()
 #if __APPLE__
     nativeAdapter_ = std::make_shared<::NitroStorage::IOSStorageAdapterCpp>();
 #elif __ANDROID__
-    auto context = ::NitroStorage::AndroidStorageAdapterJava::getContext();
-    nativeAdapter_ = std::make_shared<::NitroStorage::AndroidStorageAdapterCpp>(context);
+    ::NitroStorage::AndroidStorageAdapterJava::ensureInitialized();
+    nativeAdapter_ = std::make_shared<::NitroStorage::AndroidStorageAdapterCpp>();
 #endif
 #endif
 }
@@ -338,8 +339,17 @@ void HybridStorage::setBatch(const std::vector<std::string>& keys, const std::ve
             break;
         case Scope::Secure:
             ensureAdapter();
-            runAdapterOperation(
-                [&] { nativeAdapter_->setSecureBatch(keys, values); }, "Secure setBatch");
+            try {
+                runAdapterOperation(
+                    [&] { nativeAdapter_->setSecureBatch(keys, values); }, "Secure setBatch");
+            } catch (const ::NitroStorage::PartialBatchError& error) {
+                const auto listeners = copyListenersForScope(static_cast<int>(s));
+                const auto applied = std::min(error.appliedCount(), keys.size());
+                for (size_t i = 0; i < applied; ++i) {
+                    notifyListeners(listeners, keys[i], values[i]);
+                }
+                throw;
+            }
             break;
     }
 
@@ -402,8 +412,17 @@ void HybridStorage::removeBatch(const std::vector<std::string>& keys, double sco
             break;
         case Scope::Secure:
             ensureAdapter();
-            runAdapterOperation(
-                [&] { nativeAdapter_->deleteSecureBatch(keys); }, "Secure removeBatch");
+            try {
+                runAdapterOperation(
+                    [&] { nativeAdapter_->deleteSecureBatch(keys); }, "Secure removeBatch");
+            } catch (const ::NitroStorage::PartialBatchError& error) {
+                const auto listeners = copyListenersForScope(static_cast<int>(s));
+                const auto applied = std::min(error.appliedCount(), keys.size());
+                for (size_t i = 0; i < applied; ++i) {
+                    notifyListeners(listeners, keys[i], std::nullopt);
+                }
+                throw;
+            }
             break;
     }
 

package/cpp/core/NativeStorageAdapter.hpp

@@ -1,11 +1,24 @@
 #pragma once
 
-#include <string>
+#include <cstddef>
 #include <optional>
+#include <stdexcept>
+#include <string>
 #include <vector>
 
 namespace NitroStorage {
 
+class PartialBatchError : public std::runtime_error {
+public:
+    PartialBatchError(size_t appliedCount, const std::string& message)
+        : std::runtime_error(message), appliedCount_(appliedCount) {}
+
+    size_t appliedCount() const noexcept { return appliedCount_; }
+
+private:
+    size_t appliedCount_;
+};
+
 class NativeStorageAdapter {
 public:
     virtual ~NativeStorageAdapter() = default;