react-native-nitro-storage 0.3.0 → 0.3.2

package/cpp/bindings/HybridStorage.cpp

@@ -1,12 +1,14 @@
 #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 {
 
@@ -16,12 +18,14 @@ constexpr auto kBatchMissingSentinel = "__nitro_storage_batch_missing__::v1";
 
 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)
@@ -143,6 +147,65 @@ void HybridStorage::remove(const std::string& key, double scope) {
     notifyListeners(static_cast<int>(s), key, std::nullopt);
 }
 
+bool HybridStorage::has(const std::string& key, double scope) {
+    Scope s = toScope(scope);
+
+    switch (s) {
+        case Scope::Memory: {
+            std::lock_guard<std::mutex> lock(memoryMutex_);
+            return memoryStore_.find(key) != memoryStore_.end();
+        }
+        case Scope::Disk:
+            ensureAdapter();
+            return nativeAdapter_->hasDisk(key);
+        case Scope::Secure:
+            ensureAdapter();
+            return nativeAdapter_->hasSecure(key);
+    }
+    return false;
+}
+
+std::vector<std::string> HybridStorage::getAllKeys(double scope) {
+    Scope s = toScope(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& pair : memoryStore_) {
+                keys.push_back(pair.first);
+            }
+            return keys;
+        }
+        case Scope::Disk:
+            ensureAdapter();
+            return nativeAdapter_->getAllKeysDisk();
+        case Scope::Secure:
+            ensureAdapter();
+            return nativeAdapter_->getAllKeysSecure();
+    }
+    return {};
+}
+
+double HybridStorage::size(double scope) {
+    Scope s = toScope(scope);
+
+    switch (s) {
+        case Scope::Memory: {
+            std::lock_guard<std::mutex> lock(memoryMutex_);
+            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());
+    }
+    return 0.0;
+}
+
 std::function<void()> HybridStorage::addOnChange(
     double scope,
     const std::function<void(const std::string&, const std::optional<std::string>&)>& callback
@@ -239,12 +302,13 @@ void HybridStorage::setBatch(const std::vector<std::string>& keys, const std::ve
             break;
     }
 
+    const auto scopeValue = static_cast<int>(s);
+    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]);
     }
 }
 
-
 std::vector<std::string> HybridStorage::getBatch(const std::vector<std::string>& keys, double scope) {
     std::vector<std::string> results;
     results.reserve(keys.size());
@@ -276,11 +340,7 @@ std::vector<std::string> HybridStorage::getBatch(const std::vector<std::string>&
             }
 
             for (const auto& value : values) {
-                if (value.has_value()) {
-                    results.push_back(*value);
-                } else {
-                    results.push_back(kBatchMissingSentinel);
-                }
+                results.push_back(value.has_value() ? *value : std::string(kBatchMissingSentinel));
             }
             return results;
         }
@@ -296,11 +356,7 @@ std::vector<std::string> HybridStorage::getBatch(const std::vector<std::string>&
             }
 
             for (const auto& value : values) {
-                if (value.has_value()) {
-                    results.push_back(*value);
-                } else {
-                    results.push_back(kBatchMissingSentinel);
-                }
+                results.push_back(value.has_value() ? *value : std::string(kBatchMissingSentinel));
             }
             return results;
         }
@@ -309,7 +365,6 @@ std::vector<std::string> HybridStorage::getBatch(const std::vector<std::string>&
     return results;
 }
 
-
 void HybridStorage::removeBatch(const std::vector<std::string>& keys, double scope) {
     Scope s = toScope(scope);
 
@@ -343,16 +398,100 @@ void HybridStorage::removeBatch(const std::vector<std::string>& keys, double sco
             break;
     }
 
+    const auto scopeValue = static_cast<int>(s);
+    const auto listeners = copyListenersForScope(scopeValue);
     for (const auto& key : keys) {
-        notifyListeners(static_cast<int>(s), key, std::nullopt);
+        notifyListeners(listeners, key, std::nullopt);
     }
 }
 
-void HybridStorage::notifyListeners(
-    int scope,
-    const std::string& key,
-    const std::optional<std::string>& value
-) {
+void HybridStorage::removeByPrefix(const std::string& prefix, double scope) {
+    if (prefix.empty()) {
+        return;
+    }
+
+    const auto keys = getAllKeys(scope);
+    std::vector<std::string> prefixedKeys;
+    prefixedKeys.reserve(keys.size());
+    for (const auto& key : keys) {
+        if (key.rfind(prefix, 0) == 0) {
+            prefixedKeys.push_back(key);
+        }
+    }
+
+    if (prefixedKeys.empty()) {
+        return;
+    }
+
+    removeBatch(prefixedKeys, scope);
+}
+
+// --- Configuration ---
+
+void HybridStorage::setSecureAccessControl(double level) {
+    ensureAdapter();
+    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);
+}
+
+// --- Biometric ---
+
+void HybridStorage::setSecureBiometric(const std::string& key, const std::string& value) {
+    ensureAdapter();
+    try {
+        nativeAdapter_->setSecureBiometric(key, value);
+        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());
+    }
+}
+
+std::optional<std::string> HybridStorage::getSecureBiometric(const std::string& key) {
+    ensureAdapter();
+    try {
+        return nativeAdapter_->getSecureBiometric(key);
+    } catch (const std::exception& e) {
+        throw std::runtime_error(std::string("NitroStorage: Biometric get failed: ") + e.what());
+    }
+}
+
+void HybridStorage::deleteSecureBiometric(const std::string& key) {
+    ensureAdapter();
+    try {
+        nativeAdapter_->deleteSecureBiometric(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());
+    }
+}
+
+bool HybridStorage::hasSecureBiometric(const std::string& key) {
+    ensureAdapter();
+    return nativeAdapter_->hasSecureBiometric(key);
+}
+
+void HybridStorage::clearSecureBiometric() {
+    ensureAdapter();
+    try {
+        nativeAdapter_->clearSecureBiometric();
+        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());
+    }
+}
+
+// --- Internal ---
+
+std::vector<HybridStorage::Listener> HybridStorage::copyListenersForScope(int scope) {
     std::vector<Listener> listenersCopy;
     {
         std::lock_guard<std::mutex> lock(listenersMutex_);
@@ -362,8 +501,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 (...) {
@@ -372,6 +518,15 @@ 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);
+}
+
 void HybridStorage::ensureAdapter() const {
     if (!nativeAdapter_) {
         throw std::runtime_error("NitroStorage: Native adapter not initialized");

package/cpp/bindings/HybridStorage.hpp

@@ -3,6 +3,7 @@
 #include "HybridStorageSpec.hpp"
 #include "../core/NativeStorageAdapter.hpp"
 #include <unordered_map>
+#include <map>
 #include <mutex>
 #include <functional>
 #include <memory>
@@ -10,6 +11,14 @@
 
 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();
@@ -20,13 +29,25 @@ public:
     std::optional<std::string> get(const std::string& key, double scope) override;
     void remove(const std::string& key, double scope) override;
     void clear(double scope) override;
+    bool has(const std::string& key, double scope) override;
+    std::vector<std::string> getAllKeys(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;
+    std::optional<std::string> getSecureBiometric(const std::string& key) override;
+    void deleteSecureBiometric(const std::string& key) override;
+    bool hasSecureBiometric(const std::string& key) override;
+    void clearSecureBiometric() override;
 
 private:
     enum class Scope {
@@ -40,15 +61,21 @@ 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;
 
+    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);
     void ensureAdapter() const;
     Scope toScope(double scopeValue);

package/cpp/core/NativeStorageAdapter.hpp

@@ -13,6 +13,9 @@ public:
     virtual void setDisk(const std::string& key, const std::string& value) = 0;
     virtual std::optional<std::string> getDisk(const std::string& key) = 0;
     virtual void deleteDisk(const std::string& key) = 0;
+    virtual bool hasDisk(const std::string& key) = 0;
+    virtual std::vector<std::string> getAllKeysDisk() = 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;
     virtual void deleteDiskBatch(const std::vector<std::string>& keys) = 0;
@@ -20,12 +23,25 @@ public:
     virtual void setSecure(const std::string& key, const std::string& value) = 0;
     virtual std::optional<std::string> getSecure(const std::string& key) = 0;
     virtual void deleteSecure(const std::string& key) = 0;
+    virtual bool hasSecure(const std::string& key) = 0;
+    virtual std::vector<std::string> getAllKeysSecure() = 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;
     virtual void deleteSecureBatch(const std::vector<std::string>& keys) = 0;
     
     virtual void clearDisk() = 0;
     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 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;
+    virtual void clearSecureBiometric() = 0;
 };
 
 } // namespace NitroStorage

package/ios/IOSStorageAdapterCpp.hpp

@@ -12,6 +12,9 @@ public:
     void setDisk(const std::string& key, const std::string& value) override;
     std::optional<std::string> getDisk(const std::string& key) override;
     void deleteDisk(const std::string& key) override;
+    bool hasDisk(const std::string& key) override;
+    std::vector<std::string> getAllKeysDisk() override;
+    size_t sizeDisk() override;
     void setDiskBatch(const std::vector<std::string>& keys, const std::vector<std::string>& values) override;
     std::vector<std::optional<std::string>> getDiskBatch(const std::vector<std::string>& keys) override;
     void deleteDiskBatch(const std::vector<std::string>& keys) override;
@@ -19,12 +22,29 @@ public:
     void setSecure(const std::string& key, const std::string& value) override;
     std::optional<std::string> getSecure(const std::string& key) override;
     void deleteSecure(const std::string& key) override;
+    bool hasSecure(const std::string& key) override;
+    std::vector<std::string> getAllKeysSecure() override;
+    size_t sizeSecure() override;
     void setSecureBatch(const std::vector<std::string>& keys, const std::vector<std::string>& values) override;
     std::vector<std::optional<std::string>> getSecureBatch(const std::vector<std::string>& keys) override;
     void deleteSecureBatch(const std::vector<std::string>& keys) override;
     
     void clearDisk() override;
     void clearSecure() override;
+
+    void setSecureAccessControl(int 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;
+    std::optional<std::string> getSecureBiometric(const std::string& key) override;
+    void deleteSecureBiometric(const std::string& key) override;
+    bool hasSecureBiometric(const std::string& key) override;
+    void clearSecureBiometric() override;
+
+private:
+    int accessControlLevel_ = 0;
+    std::string keychainAccessGroup_;
 };
 
 } // namespace NitroStorage