react-native-nitro-storage 0.8.0 → 0.10.0

package/cpp/bindings/HybridStorage.cpp

@@ -14,8 +14,16 @@
 namespace margelo::nitro::NitroStorage {
 
 namespace {
-constexpr auto kBatchMissingSentinel = "__nitro_storage_batch_missing__::v1";
 constexpr int kDefaultBiometricLevel = 2;
+
+template <typename Map>
+size_t mapMemorySize(const Map& map) noexcept {
+    size_t total = map.size() * sizeof(typename Map::value_type);
+    if constexpr (requires { map.bucket_count(); }) {
+        total += map.bucket_count() * sizeof(void*);
+    }
+    return total;
+}
 } // namespace
 
 HybridStorage::HybridStorage()
@@ -57,27 +65,16 @@ void HybridStorage::set(const std::string& key, const std::string& value, double
         }
         case Scope::Disk:
             ensureAdapter();
-            try {
-                nativeAdapter_->setDisk(key, value);
-            } catch (const std::exception&) {
-                throw;
-            } catch (...) {
-                throw std::runtime_error("NitroStorage: Disk set failed (unknown error)");
-            }
+            runAdapterOperation(
+                [&] { nativeAdapter_->setDisk(key, value); }, "Disk set");
             break;
         case Scope::Secure:
             ensureAdapter();
-            try {
-                nativeAdapter_->setSecure(key, value);
-            } catch (const std::exception&) {
-                throw;
-            } catch (...) {
-                throw std::runtime_error("NitroStorage: Secure set failed (unknown error)");
-            }
+            runAdapterOperation(
+                [&] { nativeAdapter_->setSecure(key, value); }, "Secure set");
             break;
     }
 
-    onKeySet(static_cast<int>(s), key);
     notifyListeners(static_cast<int>(s), key, value);
 }
 
@@ -95,22 +92,12 @@ std::optional<std::string> HybridStorage::get(const std::string& key, double sco
         }
         case Scope::Disk:
             ensureAdapter();
-            try {
-                return nativeAdapter_->getDisk(key);
-            } catch (const std::exception&) {
-                throw;
-            } catch (...) {
-                throw std::runtime_error("NitroStorage: Disk get failed (unknown error)");
-            }
+            return runAdapterOperation(
+                [&] { return nativeAdapter_->getDisk(key); }, "Disk get");
         case Scope::Secure:
             ensureAdapter();
-            try {
-                return nativeAdapter_->getSecure(key);
-            } catch (const std::exception&) {
-                throw;
-            } catch (...) {
-                throw std::runtime_error("NitroStorage: Secure get failed (unknown error)");
-            }
+            return runAdapterOperation(
+                [&] { return nativeAdapter_->getSecure(key); }, "Secure get");
     }
     
     return std::nullopt;
@@ -127,27 +114,16 @@ void HybridStorage::remove(const std::string& key, double scope) {
         }
         case Scope::Disk:
             ensureAdapter();
-            try {
-                nativeAdapter_->deleteDisk(key);
-            } catch (const std::exception&) {
-                throw;
-            } catch (...) {
-                throw std::runtime_error("NitroStorage: Disk delete failed (unknown error)");
-            }
+            runAdapterOperation(
+                [&] { nativeAdapter_->deleteDisk(key); }, "Disk delete");
             break;
         case Scope::Secure:
             ensureAdapter();
-            try {
-                nativeAdapter_->deleteSecure(key);
-            } catch (const std::exception&) {
-                throw;
-            } catch (...) {
-                throw std::runtime_error("NitroStorage: Secure delete failed (unknown error)");
-            }
+            runAdapterOperation(
+                [&] { nativeAdapter_->deleteSecure(key); }, "Secure delete");
             break;
     }
 
-    onKeyRemove(static_cast<int>(s), key);
     notifyListeners(static_cast<int>(s), key, std::nullopt);
 }
 
@@ -160,16 +136,13 @@ bool HybridStorage::has(const std::string& key, double scope) {
             return memoryStore_.find(key) != memoryStore_.end();
         }
         case Scope::Disk:
-        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 false;
-            }
-            return indexIt->second.count(key) > 0;
-        }
+            ensureAdapter();
+            return runAdapterOperation(
+                [&] { return nativeAdapter_->hasDisk(key); }, "Disk has");
+        case Scope::Secure:
+            ensureAdapter();
+            return runAdapterOperation(
+                [&] { return nativeAdapter_->hasSecure(key); }, "Secure has");
     }
     return false;
 }
@@ -188,16 +161,13 @@ std::vector<std::string> HybridStorage::getAllKeys(double scope) {
             return keys;
         }
         case Scope::Disk:
-        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);
-        }
+            ensureAdapter();
+            return runAdapterOperation(
+                [&] { return nativeAdapter_->getAllKeysDisk(); }, "Disk getAllKeys");
+        case Scope::Secure:
+            ensureAdapter();
+            return runAdapterOperation(
+                [&] { return nativeAdapter_->getAllKeysSecure(); }, "Secure getAllKeys");
     }
     return {};
 }
@@ -221,23 +191,13 @@ std::vector<std::string> HybridStorage::getKeysByPrefix(const std::string& prefi
             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;
-        }
+            ensureAdapter();
+            return runAdapterOperation(
+                [&] { return nativeAdapter_->getKeysByPrefixDisk(prefix); }, "Disk getKeysByPrefix");
+        case Scope::Secure:
+            ensureAdapter();
+            return runAdapterOperation(
+                [&] { return nativeAdapter_->getKeysByPrefixSecure(prefix); }, "Secure getKeysByPrefix");
     }
     return {};
 }
@@ -251,20 +211,46 @@ double HybridStorage::size(double scope) {
             return static_cast<double>(memoryStore_.size());
         }
         case Scope::Disk:
-        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());
-        }
+            ensureAdapter();
+            return static_cast<double>(runAdapterOperation(
+                [&] { return nativeAdapter_->sizeDisk(); }, "Disk size"));
+        case Scope::Secure:
+            ensureAdapter();
+            return static_cast<double>(runAdapterOperation(
+                [&] { return nativeAdapter_->sizeSecure(); }, "Secure size"));
     }
     return 0.0;
 }
 
+size_t HybridStorage::getExternalMemorySize() noexcept {
+    return memorySize();
+}
+
+size_t HybridStorage::memorySize() noexcept {
+    size_t total = 0;
+    {
+        std::lock_guard<std::mutex> lock(memoryMutex_);
+        total += mapMemorySize(memoryStore_);
+        for (const auto& [key, value] : memoryStore_) {
+            total += key.capacity() * sizeof(std::string::value_type);
+            total += value.capacity() * sizeof(std::string::value_type);
+        }
+    }
+    {
+        std::lock_guard<std::mutex> lock(listenersMutex_);
+        total += mapMemorySize(listeners_);
+        for (const auto& [scope, listeners] : listeners_) {
+            (void)scope;
+            total += listeners.capacity() * sizeof(Listener);
+        }
+    }
+    // The adapter interface exposes no memory-sizing contract, so platform
+    // preference/keychain caches are intentionally outside this bounded
+    // HybridStorage-owned estimate. std::function target allocations are also
+    // opaque; the retained Listener wrapper itself is counted above.
+    return total;
+}
+
 std::function<void()> HybridStorage::addOnChange(
     double scope,
     const std::function<void(const std::string&, const std::optional<std::string>&)>& callback
@@ -317,27 +303,16 @@ void HybridStorage::clear(double scope) {
         }
         case Scope::Disk:
             ensureAdapter();
-            try {
-                nativeAdapter_->clearDisk();
-            } catch (const std::exception&) {
-                throw;
-            } catch (...) {
-                throw std::runtime_error("NitroStorage: Disk clear failed (unknown error)");
-            }
+            runAdapterOperation(
+                [&] { nativeAdapter_->clearDisk(); }, "Disk clear");
             break;
         case Scope::Secure:
             ensureAdapter();
-            try {
-                nativeAdapter_->clearSecure();
-            } catch (const std::exception&) {
-                throw;
-            } catch (...) {
-                throw std::runtime_error("NitroStorage: Secure clear failed (unknown error)");
-            }
+            runAdapterOperation(
+                [&] { nativeAdapter_->clearSecure(); }, "Secure clear");
             break;
     }
 
-    onScopeClear(static_cast<int>(s));
     notifyListeners(static_cast<int>(s), kClearSentinelKey, std::nullopt);
 }
 
@@ -358,38 +333,25 @@ void HybridStorage::setBatch(const std::vector<std::string>& keys, const std::ve
         }
         case Scope::Disk:
             ensureAdapter();
-            try {
-                nativeAdapter_->setDiskBatch(keys, values);
-            } catch (const std::exception&) {
-                throw;
-            } catch (...) {
-                throw std::runtime_error("NitroStorage: Disk setBatch failed (unknown error)");
-            }
+            runAdapterOperation(
+                [&] { nativeAdapter_->setDiskBatch(keys, values); }, "Disk setBatch");
             break;
         case Scope::Secure:
             ensureAdapter();
-            try {
-                nativeAdapter_->setSecureBatch(keys, values);
-            } catch (const std::exception&) {
-                throw;
-            } catch (...) {
-                throw std::runtime_error("NitroStorage: Secure setBatch failed (unknown error)");
-            }
+            runAdapterOperation(
+                [&] { nativeAdapter_->setSecureBatch(keys, values); }, "Secure setBatch");
             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(listeners, keys[i], values[i]);
     }
 }
 
-std::vector<std::string> HybridStorage::getBatch(const std::vector<std::string>& keys, double scope) {
-    std::vector<std::string> results;
+std::vector<std::optional<std::string>> HybridStorage::getBatch(const std::vector<std::string>& keys, double scope) {
+    std::vector<std::optional<std::string>> results;
     results.reserve(keys.size());
 
     Scope s = toScope(scope);
@@ -402,42 +364,20 @@ std::vector<std::string> HybridStorage::getBatch(const std::vector<std::string>&
                 if (it != memoryStore_.end()) {
                     results.push_back(it->second);
                 } else {
-                    results.push_back(kBatchMissingSentinel);
+                    results.push_back(std::nullopt);
                 }
             }
             return results;
         }
         case Scope::Disk: {
             ensureAdapter();
-            std::vector<std::optional<std::string>> values;
-            try {
-                values = nativeAdapter_->getDiskBatch(keys);
-            } catch (const std::exception&) {
-                throw;
-            } catch (...) {
-                throw std::runtime_error("NitroStorage: Disk getBatch failed (unknown error)");
-            }
-
-            for (const auto& value : values) {
-                results.push_back(value.has_value() ? *value : std::string(kBatchMissingSentinel));
-            }
-            return results;
+            return runAdapterOperation(
+                [&] { return nativeAdapter_->getDiskBatch(keys); }, "Disk getBatch");
         }
         case Scope::Secure: {
             ensureAdapter();
-            std::vector<std::optional<std::string>> values;
-            try {
-                values = nativeAdapter_->getSecureBatch(keys);
-            } catch (const std::exception&) {
-                throw;
-            } catch (...) {
-                throw std::runtime_error("NitroStorage: Secure getBatch failed (unknown error)");
-            }
-
-            for (const auto& value : values) {
-                results.push_back(value.has_value() ? *value : std::string(kBatchMissingSentinel));
-            }
-            return results;
+            return runAdapterOperation(
+                [&] { return nativeAdapter_->getSecureBatch(keys); }, "Secure getBatch");
         }
     }
 
@@ -457,30 +397,17 @@ void HybridStorage::removeBatch(const std::vector<std::string>& keys, double sco
         }
         case Scope::Disk:
             ensureAdapter();
-            try {
-                nativeAdapter_->deleteDiskBatch(keys);
-            } catch (const std::exception&) {
-                throw;
-            } catch (...) {
-                throw std::runtime_error("NitroStorage: Disk removeBatch failed (unknown error)");
-            }
+            runAdapterOperation(
+                [&] { nativeAdapter_->deleteDiskBatch(keys); }, "Disk removeBatch");
             break;
         case Scope::Secure:
             ensureAdapter();
-            try {
-                nativeAdapter_->deleteSecureBatch(keys);
-            } catch (const std::exception&) {
-                throw;
-            } catch (...) {
-                throw std::runtime_error("NitroStorage: Secure removeBatch failed (unknown error)");
-            }
+            runAdapterOperation(
+                [&] { nativeAdapter_->deleteSecureBatch(keys); }, "Secure removeBatch");
             break;
     }
 
     const auto scopeValue = static_cast<int>(s);
-    for (const auto& key : keys) {
-        onKeyRemove(scopeValue, key);
-    }
     const auto listeners = copyListenersForScope(scopeValue);
     for (const auto& key : keys) {
         notifyListeners(listeners, key, std::nullopt);
@@ -550,43 +477,23 @@ void HybridStorage::setSecureBiometricWithLevel(const std::string& key, const st
             "NitroStorage: Invalid biometric level");
     }
     ensureAdapter();
-    try {
-        nativeAdapter_->setSecureBiometricWithLevel(
-            key,
-            value,
-            intLevel
-        );
-        onKeySet(static_cast<int>(Scope::Secure), key);
-        notifyListeners(static_cast<int>(Scope::Secure), key, value);
-    } catch (const std::exception&) {
-        throw;
-    } catch (...) {
-        throw std::runtime_error("NitroStorage: Biometric set failed (unknown error)");
-    }
+    runAdapterOperation(
+        [&] { nativeAdapter_->setSecureBiometricWithLevel(key, value, intLevel); },
+        "Biometric set");
+    notifyListeners(static_cast<int>(Scope::Secure), key, value);
 }
 
 std::optional<std::string> HybridStorage::getSecureBiometric(const std::string& key) {
     ensureAdapter();
-    try {
-        return nativeAdapter_->getSecureBiometric(key);
-    } catch (const std::exception&) {
-        throw;
-    } catch (...) {
-        throw std::runtime_error("NitroStorage: Biometric get failed (unknown error)");
-    }
+    return runAdapterOperation(
+        [&] { return nativeAdapter_->getSecureBiometric(key); }, "Biometric get");
 }
 
 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&) {
-        throw;
-    } catch (...) {
-        throw std::runtime_error("NitroStorage: Biometric delete failed (unknown error)");
-    }
+    runAdapterOperation(
+        [&] { nativeAdapter_->deleteSecureBiometric(key); }, "Biometric delete");
+    notifyListeners(static_cast<int>(Scope::Secure), key, std::nullopt);
 }
 
 bool HybridStorage::hasSecureBiometric(const std::string& key) {
@@ -596,22 +503,9 @@ bool HybridStorage::hasSecureBiometric(const std::string& key) {
 
 void HybridStorage::clearSecureBiometric() {
     ensureAdapter();
-    try {
-        nativeAdapter_->clearSecureBiometric();
-        // Invalidate the secure key index so next access re-hydrates from native adapter
-        // (which will now correctly exclude the cleared biometric keys).
-        // We do NOT call onScopeClear() here because that would also clear the index
-        // contents for regular secure keys; marking stale is sufficient.
-        {
-            std::lock_guard<std::mutex> lock(keyIndexMutex_);
-            keyIndexHydrated_[static_cast<int>(Scope::Secure)] = false;
-        }
-        notifyListeners(static_cast<int>(Scope::Secure), kClearSentinelKey, std::nullopt);
-    } catch (const std::exception&) {
-        throw;
-    } catch (...) {
-        throw std::runtime_error("NitroStorage: Biometric clear failed (unknown error)");
-    }
+    runAdapterOperation(
+        [&] { nativeAdapter_->clearSecureBiometric(); }, "Biometric clear");
+    notifyListeners(static_cast<int>(Scope::Secure), kClearSentinelKey, std::nullopt);
 }
 
 // --- Internal ---
@@ -658,84 +552,6 @@ void HybridStorage::notifyListeners(
     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&) {
-        throw;
-    } catch (...) {
-        throw std::runtime_error("NitroStorage: Key index hydration failed (unknown error)");
-    }
-
-    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

@@ -10,9 +10,9 @@
 #include <functional>
 #include <memory>
 #include <vector>
-#include <unordered_set>
 #include <atomic>
 #include <array>
+#include <stdexcept>
 
 namespace margelo::nitro::NitroStorage {
 
@@ -38,8 +38,9 @@ public:
     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;
+    size_t getExternalMemorySize() noexcept 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;
+    std::vector<std::optional<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(
@@ -79,9 +80,6 @@ private:
     // Lock-free fast path: skip locking/copying the listener vector on the
     // write/notify path when no listeners are registered for a scope.
     std::array<std::atomic<size_t>, 3> listenerScopeCounts_{};
-    HybridStorageMap<int, std::unordered_set<std::string>> keyIndex_;
-    HybridStorageMap<int, bool> keyIndexHydrated_;
-    std::mutex keyIndexMutex_;
 
     std::vector<Listener> copyListenersForScope(int scope);
     void notifyListeners(
@@ -90,13 +88,22 @@ private:
         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);
+    size_t memorySize() noexcept;
+
+    template <typename TOperation>
+    auto runAdapterOperation(TOperation&& operation, const char* description) -> decltype(operation()) {
+        try {
+            return operation();
+        } catch (const std::exception&) {
+            throw;
+        } catch (...) {
+            throw std::runtime_error(
+                std::string("NitroStorage: ") + description + " failed (unknown error)"
+            );
+        }
+    }
 
     static constexpr const char* kClearSentinelKey = "";
 };