react-native-nitro-storage 0.3.1 → 0.4.0

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

@@ -33,6 +33,12 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
             encryptedPreferences
         }
     }
+
+    @Volatile
+    private var secureWritesAsync = false
+
+    @Volatile
+    private var secureKeysCache: Array<String>? = null
     
     private fun initializeEncryptedPreferences(name: String, key: MasterKey): SharedPreferences {
         return try {
@@ -90,6 +96,38 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
             }
         }
     }
+
+    private fun applySecureEditor(editor: SharedPreferences.Editor) {
+        if (secureWritesAsync) {
+            editor.apply()
+        } else {
+            editor.commit()
+        }
+    }
+
+    private fun invalidateSecureKeysCache() {
+        secureKeysCache = null
+    }
+
+    private fun getSecureKeysCached(): Array<String> {
+        val cached = secureKeysCache
+        if (cached != null) {
+            return cached
+        }
+
+        synchronized(this) {
+            val existing = secureKeysCache
+            if (existing != null) {
+                return existing
+            }
+            val keys = linkedSetOf<String>()
+            keys.addAll(encryptedPreferences.all.keys)
+            keys.addAll(biometricPreferences.all.keys)
+            val built = keys.toTypedArray()
+            secureKeysCache = built
+            return built
+        }
+    }
     
     companion object {
         @Volatile
@@ -118,6 +156,11 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
             return getInstanceOrThrow().context
         }
 
+        @JvmStatic
+        fun setSecureWritesAsync(enabled: Boolean) {
+            getInstanceOrThrow().secureWritesAsync = enabled
+        }
+
         // --- Disk ---
         
         @JvmStatic
@@ -172,6 +215,13 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
             return getInstanceOrThrow().sharedPreferences.all.keys.toTypedArray()
         }
 
+        @JvmStatic
+        fun getKeysByPrefixDisk(prefix: String): Array<String> {
+            return getInstanceOrThrow().sharedPreferences.all.keys
+                .filter { it.startsWith(prefix) }
+                .toTypedArray()
+        }
+
         @JvmStatic
         fun sizeDisk(): Int {
             return getInstanceOrThrow().sharedPreferences.all.size
@@ -182,21 +232,26 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
             getInstanceOrThrow().sharedPreferences.edit().clear().apply()
         }
 
-        // --- Secure (uses commit for reliability) ---
+        // --- Secure (sync commit by default, async apply when enabled) ---
         
         @JvmStatic
         fun setSecure(key: String, value: String) {
-            getInstanceOrThrow().encryptedPreferences.edit().putString(key, value).commit()
+            val inst = getInstanceOrThrow()
+            val editor = inst.encryptedPreferences.edit().putString(key, value)
+            inst.applySecureEditor(editor)
+            inst.invalidateSecureKeysCache()
         }
 
         @JvmStatic
         fun setSecureBatch(keys: Array<String>, values: Array<String>) {
-            val editor = getInstanceOrThrow().encryptedPreferences.edit()
+            val inst = getInstanceOrThrow()
+            val editor = inst.encryptedPreferences.edit()
             val count = minOf(keys.size, values.size)
             for (index in 0 until count) {
                 editor.putString(keys[index], values[index])
             }
-            editor.commit()
+            inst.applySecureEditor(editor)
+            inst.invalidateSecureKeysCache()
         }
         
         @JvmStatic
@@ -215,8 +270,9 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         @JvmStatic
         fun deleteSecure(key: String) {
             val inst = getInstanceOrThrow()
-            inst.encryptedPreferences.edit().remove(key).commit()
-            inst.biometricPreferences.edit().remove(key).commit()
+            inst.applySecureEditor(inst.encryptedPreferences.edit().remove(key))
+            inst.applySecureEditor(inst.biometricPreferences.edit().remove(key))
+            inst.invalidateSecureKeysCache()
         }
 
         @JvmStatic
@@ -228,8 +284,9 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
                 secureEditor.remove(key)
                 biometricEditor.remove(key)
             }
-            secureEditor.commit()
-            biometricEditor.commit()
+            inst.applySecureEditor(secureEditor)
+            inst.applySecureEditor(biometricEditor)
+            inst.invalidateSecureKeysCache()
         }
 
         @JvmStatic
@@ -241,29 +298,40 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         @JvmStatic
         fun getAllKeysSecure(): Array<String> {
             val inst = getInstanceOrThrow()
-            val keys = linkedSetOf<String>()
-            keys.addAll(inst.encryptedPreferences.all.keys)
-            keys.addAll(inst.biometricPreferences.all.keys)
-            return keys.toTypedArray()
+            return inst.getSecureKeysCached()
+        }
+
+        @JvmStatic
+        fun getKeysByPrefixSecure(prefix: String): Array<String> {
+            return getAllKeysSecure().filter { it.startsWith(prefix) }.toTypedArray()
         }
 
         @JvmStatic
         fun sizeSecure(): Int {
-            return getAllKeysSecure().size
+            return getInstanceOrThrow().getSecureKeysCached().size
         }
 
         @JvmStatic
         fun clearSecure() {
             val inst = getInstanceOrThrow()
-            inst.encryptedPreferences.edit().clear().commit()
-            inst.biometricPreferences.edit().clear().commit()
+            inst.applySecureEditor(inst.encryptedPreferences.edit().clear())
+            inst.applySecureEditor(inst.biometricPreferences.edit().clear())
+            inst.invalidateSecureKeysCache()
         }
 
         // --- Biometric (separate encrypted store, requires recent biometric auth on Android) ---
 
         @JvmStatic
         fun setSecureBiometric(key: String, value: String) {
-            getInstanceOrThrow().biometricPreferences.edit().putString(key, value).commit()
+            setSecureBiometricWithLevel(key, value, 2)
+        }
+
+        @JvmStatic
+        fun setSecureBiometricWithLevel(key: String, value: String, @Suppress("UNUSED_PARAMETER") level: Int) {
+            val inst = getInstanceOrThrow()
+            val editor = inst.biometricPreferences.edit().putString(key, value)
+            inst.applySecureEditor(editor)
+            inst.invalidateSecureKeysCache()
         }
 
         @JvmStatic
@@ -273,7 +341,9 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
 
         @JvmStatic
         fun deleteSecureBiometric(key: String) {
-            getInstanceOrThrow().biometricPreferences.edit().remove(key).commit()
+            val inst = getInstanceOrThrow()
+            inst.applySecureEditor(inst.biometricPreferences.edit().remove(key))
+            inst.invalidateSecureKeysCache()
         }
 
         @JvmStatic
@@ -283,7 +353,9 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
 
         @JvmStatic
         fun clearSecureBiometric() {
-            getInstanceOrThrow().biometricPreferences.edit().clear().commit()
+            val inst = getInstanceOrThrow()
+            inst.applySecureEditor(inst.biometricPreferences.edit().clear())
+            inst.invalidateSecureKeysCache()
         }
     }
 }

package/cpp/bindings/HybridStorage.cpp

@@ -1,27 +1,32 @@
 #include "HybridStorage.hpp"
 #include <stdexcept>
 
+#ifndef NITRO_STORAGE_DISABLE_PLATFORM_ADAPTER
 #if __APPLE__
 #include "../../ios/IOSStorageAdapterCpp.hpp"
 #elif __ANDROID__
 #include "../../android/src/main/cpp/AndroidStorageAdapterCpp.hpp"
 #include <fbjni/fbjni.h>
 #endif
+#endif
 
 namespace margelo::nitro::NitroStorage {
 
 namespace {
 constexpr auto kBatchMissingSentinel = "__nitro_storage_batch_missing__::v1";
+constexpr int kDefaultBiometricLevel = 2;
 } // namespace
 
 HybridStorage::HybridStorage()
     : HybridObject(TAG), HybridStorageSpec() {
+#ifndef NITRO_STORAGE_DISABLE_PLATFORM_ADAPTER
 #if __APPLE__
     nativeAdapter_ = std::make_shared<::NitroStorage::IOSStorageAdapterCpp>();
 #elif __ANDROID__
     auto context = ::NitroStorage::AndroidStorageAdapterJava::getContext();
     nativeAdapter_ = std::make_shared<::NitroStorage::AndroidStorageAdapterCpp>(context);
 #endif
+#endif
 }
 
 HybridStorage::HybridStorage(std::shared_ptr<::NitroStorage::NativeStorageAdapter> adapter)
@@ -70,7 +75,8 @@ void HybridStorage::set(const std::string& key, const std::string& value, double
             }
             break;
     }
-    
+
+    onKeySet(static_cast<int>(s), key);
     notifyListeners(static_cast<int>(s), key, value);
 }
 
@@ -139,7 +145,8 @@ void HybridStorage::remove(const std::string& key, double scope) {
             }
             break;
     }
-    
+
+    onKeyRemove(static_cast<int>(s), key);
     notifyListeners(static_cast<int>(s), key, std::nullopt);
 }
 
@@ -175,11 +182,56 @@ std::vector<std::string> HybridStorage::getAllKeys(double scope) {
             return keys;
         }
         case Scope::Disk:
-            ensureAdapter();
-            return nativeAdapter_->getAllKeysDisk();
-        case Scope::Secure:
-            ensureAdapter();
-            return nativeAdapter_->getAllKeysSecure();
+        case Scope::Secure: {
+            const int scopeValue = static_cast<int>(s);
+            ensureKeyIndexHydrated(scopeValue);
+            std::lock_guard<std::mutex> lock(keyIndexMutex_);
+            auto indexIt = keyIndex_.find(scopeValue);
+            if (indexIt == keyIndex_.end()) {
+                return {};
+            }
+            return toVector(indexIt->second);
+        }
+    }
+    return {};
+}
+
+std::vector<std::string> HybridStorage::getKeysByPrefix(const std::string& prefix, double scope) {
+    Scope s = toScope(scope);
+    if (prefix.empty()) {
+        return getAllKeys(scope);
+    }
+
+    switch (s) {
+        case Scope::Memory: {
+            std::lock_guard<std::mutex> lock(memoryMutex_);
+            std::vector<std::string> keys;
+            keys.reserve(memoryStore_.size());
+            for (const auto& [key, _] : memoryStore_) {
+                if (key.rfind(prefix, 0) == 0) {
+                    keys.push_back(key);
+                }
+            }
+            return keys;
+        }
+        case Scope::Disk:
+        case Scope::Secure: {
+            const int scopeValue = static_cast<int>(s);
+            ensureKeyIndexHydrated(scopeValue);
+            std::lock_guard<std::mutex> lock(keyIndexMutex_);
+            std::vector<std::string> keys;
+            auto indexIt = keyIndex_.find(scopeValue);
+            if (indexIt == keyIndex_.end()) {
+                return keys;
+            }
+            keys.reserve(indexIt->second.size());
+            for (const auto& key : indexIt->second) {
+                if (key.rfind(prefix, 0) == 0) {
+                    keys.push_back(key);
+                }
+            }
+            return keys;
+        }
     }
     return {};
 }
@@ -193,11 +245,16 @@ double HybridStorage::size(double scope) {
             return static_cast<double>(memoryStore_.size());
         }
         case Scope::Disk:
-            ensureAdapter();
-            return static_cast<double>(nativeAdapter_->sizeDisk());
-        case Scope::Secure:
-            ensureAdapter();
-            return static_cast<double>(nativeAdapter_->sizeSecure());
+        case Scope::Secure: {
+            const int scopeValue = static_cast<int>(s);
+            ensureKeyIndexHydrated(scopeValue);
+            std::lock_guard<std::mutex> lock(keyIndexMutex_);
+            auto indexIt = keyIndex_.find(scopeValue);
+            if (indexIt == keyIndex_.end()) {
+                return 0.0;
+            }
+            return static_cast<double>(indexIt->second.size());
+        }
     }
     return 0.0;
 }
@@ -257,7 +314,8 @@ void HybridStorage::clear(double scope) {
             }
             break;
     }
-    
+
+    onScopeClear(static_cast<int>(s));
     notifyListeners(static_cast<int>(s), "", std::nullopt);
 }
 
@@ -298,8 +356,13 @@ void HybridStorage::setBatch(const std::vector<std::string>& keys, const std::ve
             break;
     }
 
+    const auto scopeValue = static_cast<int>(s);
+    for (const auto& key : keys) {
+        onKeySet(scopeValue, key);
+    }
+    const auto listeners = copyListenersForScope(scopeValue);
     for (size_t i = 0; i < keys.size(); ++i) {
-        notifyListeners(static_cast<int>(s), keys[i], values[i]);
+        notifyListeners(listeners, keys[i], values[i]);
     }
 }
 
@@ -392,9 +455,28 @@ void HybridStorage::removeBatch(const std::vector<std::string>& keys, double sco
             break;
     }
 
+    const auto scopeValue = static_cast<int>(s);
     for (const auto& key : keys) {
-        notifyListeners(static_cast<int>(s), key, std::nullopt);
+        onKeyRemove(scopeValue, key);
+    }
+    const auto listeners = copyListenersForScope(scopeValue);
+    for (const auto& key : keys) {
+        notifyListeners(listeners, key, std::nullopt);
+    }
+}
+
+void HybridStorage::removeByPrefix(const std::string& prefix, double scope) {
+    if (prefix.empty()) {
+        return;
+    }
+
+    const auto prefixedKeys = getKeysByPrefix(prefix, scope);
+
+    if (prefixedKeys.empty()) {
+        return;
     }
+
+    removeBatch(prefixedKeys, scope);
 }
 
 // --- Configuration ---
@@ -404,6 +486,11 @@ void HybridStorage::setSecureAccessControl(double level) {
     nativeAdapter_->setSecureAccessControl(static_cast<int>(level));
 }
 
+void HybridStorage::setSecureWritesAsync(bool enabled) {
+    ensureAdapter();
+    nativeAdapter_->setSecureWritesAsync(enabled);
+}
+
 void HybridStorage::setKeychainAccessGroup(const std::string& group) {
     ensureAdapter();
     nativeAdapter_->setKeychainAccessGroup(group);
@@ -412,9 +499,18 @@ void HybridStorage::setKeychainAccessGroup(const std::string& group) {
 // --- Biometric ---
 
 void HybridStorage::setSecureBiometric(const std::string& key, const std::string& value) {
+    setSecureBiometricWithLevel(key, value, kDefaultBiometricLevel);
+}
+
+void HybridStorage::setSecureBiometricWithLevel(const std::string& key, const std::string& value, double level) {
     ensureAdapter();
     try {
-        nativeAdapter_->setSecureBiometric(key, value);
+        nativeAdapter_->setSecureBiometricWithLevel(
+            key,
+            value,
+            static_cast<int>(level)
+        );
+        onKeySet(static_cast<int>(Scope::Secure), key);
         notifyListeners(static_cast<int>(Scope::Secure), key, value);
     } catch (const std::exception& e) {
         throw std::runtime_error(std::string("NitroStorage: Biometric set failed: ") + e.what());
@@ -434,6 +530,7 @@ void HybridStorage::deleteSecureBiometric(const std::string& key) {
     ensureAdapter();
     try {
         nativeAdapter_->deleteSecureBiometric(key);
+        onKeyRemove(static_cast<int>(Scope::Secure), key);
         notifyListeners(static_cast<int>(Scope::Secure), key, std::nullopt);
     } catch (const std::exception& e) {
         throw std::runtime_error(std::string("NitroStorage: Biometric delete failed: ") + e.what());
@@ -449,6 +546,7 @@ void HybridStorage::clearSecureBiometric() {
     ensureAdapter();
     try {
         nativeAdapter_->clearSecureBiometric();
+        onScopeClear(static_cast<int>(Scope::Secure));
         notifyListeners(static_cast<int>(Scope::Secure), "", std::nullopt);
     } catch (const std::exception& e) {
         throw std::runtime_error(std::string("NitroStorage: Biometric clear failed: ") + e.what());
@@ -457,11 +555,7 @@ void HybridStorage::clearSecureBiometric() {
 
 // --- Internal ---
 
-void HybridStorage::notifyListeners(
-    int scope,
-    const std::string& key,
-    const std::optional<std::string>& value
-) {
+std::vector<HybridStorage::Listener> HybridStorage::copyListenersForScope(int scope) {
     std::vector<Listener> listenersCopy;
     {
         std::lock_guard<std::mutex> lock(listenersMutex_);
@@ -471,8 +565,15 @@ void HybridStorage::notifyListeners(
             listenersCopy = it->second;
         }
     }
-    
-    for (const auto& listener : listenersCopy) {
+    return listenersCopy;
+}
+
+void HybridStorage::notifyListeners(
+    const std::vector<Listener>& listeners,
+    const std::string& key,
+    const std::optional<std::string>& value
+) {
+    for (const auto& listener : listeners) {
         try {
             listener.callback(key, value);
         } catch (...) {
@@ -481,6 +582,96 @@ void HybridStorage::notifyListeners(
     }
 }
 
+void HybridStorage::notifyListeners(
+    int scope,
+    const std::string& key,
+    const std::optional<std::string>& value
+) {
+    const auto listeners = copyListenersForScope(scope);
+    notifyListeners(listeners, key, value);
+}
+
+std::vector<std::string> HybridStorage::toVector(const std::unordered_set<std::string>& keys) {
+    std::vector<std::string> values;
+    values.reserve(keys.size());
+    for (const auto& key : keys) {
+        values.push_back(key);
+    }
+    return values;
+}
+
+void HybridStorage::ensureKeyIndexHydrated(int scope) {
+    if (scope != static_cast<int>(Scope::Disk) && scope != static_cast<int>(Scope::Secure)) {
+        return;
+    }
+
+    {
+        std::lock_guard<std::mutex> lock(keyIndexMutex_);
+        auto hydratedIt = keyIndexHydrated_.find(scope);
+        if (hydratedIt != keyIndexHydrated_.end() && hydratedIt->second) {
+            return;
+        }
+    }
+
+    ensureAdapter();
+    std::vector<std::string> keys;
+    try {
+        if (scope == static_cast<int>(Scope::Disk)) {
+            keys = nativeAdapter_->getAllKeysDisk();
+        } else {
+            keys = nativeAdapter_->getAllKeysSecure();
+        }
+    } catch (const std::exception& e) {
+        throw std::runtime_error(std::string("NitroStorage: Key index hydration failed: ") + e.what());
+    } catch (...) {
+        throw std::runtime_error("NitroStorage: Key index hydration failed");
+    }
+
+    std::lock_guard<std::mutex> lock(keyIndexMutex_);
+    auto& index = keyIndex_[scope];
+    index.clear();
+    for (const auto& key : keys) {
+        index.insert(key);
+    }
+    keyIndexHydrated_[scope] = true;
+}
+
+void HybridStorage::onKeySet(int scope, const std::string& key) {
+    if (scope != static_cast<int>(Scope::Disk) && scope != static_cast<int>(Scope::Secure)) {
+        return;
+    }
+
+    std::lock_guard<std::mutex> lock(keyIndexMutex_);
+    auto hydratedIt = keyIndexHydrated_.find(scope);
+    if (hydratedIt != keyIndexHydrated_.end() && hydratedIt->second) {
+        keyIndex_[scope].insert(key);
+    }
+}
+
+void HybridStorage::onKeyRemove(int scope, const std::string& key) {
+    if (scope != static_cast<int>(Scope::Disk) && scope != static_cast<int>(Scope::Secure)) {
+        return;
+    }
+
+    std::lock_guard<std::mutex> lock(keyIndexMutex_);
+    auto hydratedIt = keyIndexHydrated_.find(scope);
+    if (hydratedIt != keyIndexHydrated_.end() && hydratedIt->second) {
+        keyIndex_[scope].erase(key);
+    }
+}
+
+void HybridStorage::onScopeClear(int scope) {
+    if (scope != static_cast<int>(Scope::Disk) && scope != static_cast<int>(Scope::Secure)) {
+        return;
+    }
+
+    std::lock_guard<std::mutex> lock(keyIndexMutex_);
+    auto hydratedIt = keyIndexHydrated_.find(scope);
+    if (hydratedIt != keyIndexHydrated_.end() && hydratedIt->second) {
+        keyIndex_[scope].clear();
+    }
+}
+
 void HybridStorage::ensureAdapter() const {
     if (!nativeAdapter_) {
         throw std::runtime_error("NitroStorage: Native adapter not initialized");

package/cpp/bindings/HybridStorage.hpp

@@ -3,13 +3,23 @@
 #include "HybridStorageSpec.hpp"
 #include "../core/NativeStorageAdapter.hpp"
 #include <unordered_map>
+#include <map>
 #include <mutex>
 #include <functional>
 #include <memory>
 #include <vector>
+#include <unordered_set>
 
 namespace margelo::nitro::NitroStorage {
 
+#ifdef NITRO_STORAGE_USE_ORDERED_MAP_FOR_TESTS
+template <typename Key, typename Value>
+using HybridStorageMap = std::map<Key, Value>;
+#else
+template <typename Key, typename Value>
+using HybridStorageMap = std::unordered_map<Key, Value>;
+#endif
+
 class HybridStorage : public HybridStorageSpec {
 public:
     HybridStorage();
@@ -22,17 +32,21 @@ public:
     void clear(double scope) override;
     bool has(const std::string& key, double scope) override;
     std::vector<std::string> getAllKeys(double scope) override;
+    std::vector<std::string> getKeysByPrefix(const std::string& prefix, double scope) override;
     double size(double scope) override;
     void setBatch(const std::vector<std::string>& keys, const std::vector<std::string>& values, double scope) override;
     std::vector<std::string> getBatch(const std::vector<std::string>& keys, double scope) override;
     void removeBatch(const std::vector<std::string>& keys, double scope) override;
+    void removeByPrefix(const std::string& prefix, double scope) override;
     std::function<void()> addOnChange(
         double scope,
         const std::function<void(const std::string&, const std::optional<std::string>&)>& callback
     ) override;
     void setSecureAccessControl(double level) override;
+    void setSecureWritesAsync(bool enabled) override;
     void setKeychainAccessGroup(const std::string& group) override;
     void setSecureBiometric(const std::string& key, const std::string& value) override;
+    void setSecureBiometricWithLevel(const std::string& key, const std::string& value, double level) override;
     std::optional<std::string> getSecureBiometric(const std::string& key) override;
     void deleteSecureBiometric(const std::string& key) override;
     bool hasSecureBiometric(const std::string& key) override;
@@ -50,16 +64,30 @@ private:
         std::function<void(const std::string&, const std::optional<std::string>&)> callback;
     };
 
-    std::unordered_map<std::string, std::string> memoryStore_;
+    HybridStorageMap<std::string, std::string> memoryStore_;
     std::mutex memoryMutex_;
     
     std::shared_ptr<::NitroStorage::NativeStorageAdapter> nativeAdapter_;
-    
-    std::unordered_map<int, std::vector<Listener>> listeners_;
+
+    HybridStorageMap<int, std::vector<Listener>> listeners_;
     std::mutex listenersMutex_;
     size_t nextListenerId_ = 0;
+    HybridStorageMap<int, std::unordered_set<std::string>> keyIndex_;
+    HybridStorageMap<int, bool> keyIndexHydrated_;
+    std::mutex keyIndexMutex_;
 
+    std::vector<Listener> copyListenersForScope(int scope);
+    void notifyListeners(
+        const std::vector<Listener>& listeners,
+        const std::string& key,
+        const std::optional<std::string>& value
+    );
     void notifyListeners(int scope, const std::string& key, const std::optional<std::string>& value);
+    std::vector<std::string> toVector(const std::unordered_set<std::string>& keys);
+    void ensureKeyIndexHydrated(int scope);
+    void onKeySet(int scope, const std::string& key);
+    void onKeyRemove(int scope, const std::string& key);
+    void onScopeClear(int scope);
     void ensureAdapter() const;
     Scope toScope(double scopeValue);
 };

package/cpp/core/NativeStorageAdapter.hpp

@@ -15,6 +15,7 @@ public:
     virtual void deleteDisk(const std::string& key) = 0;
     virtual bool hasDisk(const std::string& key) = 0;
     virtual std::vector<std::string> getAllKeysDisk() = 0;
+    virtual std::vector<std::string> getKeysByPrefixDisk(const std::string& prefix) = 0;
     virtual size_t sizeDisk() = 0;
     virtual void setDiskBatch(const std::vector<std::string>& keys, const std::vector<std::string>& values) = 0;
     virtual std::vector<std::optional<std::string>> getDiskBatch(const std::vector<std::string>& keys) = 0;
@@ -25,6 +26,7 @@ public:
     virtual void deleteSecure(const std::string& key) = 0;
     virtual bool hasSecure(const std::string& key) = 0;
     virtual std::vector<std::string> getAllKeysSecure() = 0;
+    virtual std::vector<std::string> getKeysByPrefixSecure(const std::string& prefix) = 0;
     virtual size_t sizeSecure() = 0;
     virtual void setSecureBatch(const std::vector<std::string>& keys, const std::vector<std::string>& values) = 0;
     virtual std::vector<std::optional<std::string>> getSecureBatch(const std::vector<std::string>& keys) = 0;
@@ -34,9 +36,11 @@ public:
     virtual void clearSecure() = 0;
 
     virtual void setSecureAccessControl(int level) = 0;
+    virtual void setSecureWritesAsync(bool enabled) = 0;
     virtual void setKeychainAccessGroup(const std::string& group) = 0;
 
     virtual void setSecureBiometric(const std::string& key, const std::string& value) = 0;
+    virtual void setSecureBiometricWithLevel(const std::string& key, const std::string& value, int level) = 0;
     virtual std::optional<std::string> getSecureBiometric(const std::string& key) = 0;
     virtual void deleteSecureBiometric(const std::string& key) = 0;
     virtual bool hasSecureBiometric(const std::string& key) = 0;