react-native-nitro-storage 0.1.4 → 0.3.1

package/cpp/bindings/HybridStorage.cpp

@@ -10,6 +10,10 @@
 
 namespace margelo::nitro::NitroStorage {
 
+namespace {
+constexpr auto kBatchMissingSentinel = "__nitro_storage_batch_missing__::v1";
+} // namespace
+
 HybridStorage::HybridStorage()
     : HybridObject(TAG), HybridStorageSpec() {
 #if __APPLE__
@@ -139,6 +143,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
@@ -202,32 +265,198 @@ void HybridStorage::setBatch(const std::vector<std::string>& keys, const std::ve
     if (keys.size() != values.size()) {
         throw std::runtime_error("NitroStorage: Keys and values size mismatch in setBatch");
     }
-    
+
+    Scope s = toScope(scope);
+
+    switch (s) {
+        case Scope::Memory: {
+            std::lock_guard<std::mutex> lock(memoryMutex_);
+            for (size_t i = 0; i < keys.size(); ++i) {
+                memoryStore_[keys[i]] = values[i];
+            }
+            break;
+        }
+        case Scope::Disk:
+            ensureAdapter();
+            try {
+                nativeAdapter_->setDiskBatch(keys, values);
+            } catch (const std::exception& e) {
+                throw std::runtime_error(std::string("NitroStorage: Disk setBatch failed: ") + e.what());
+            } catch (...) {
+                throw std::runtime_error("NitroStorage: Disk setBatch failed");
+            }
+            break;
+        case Scope::Secure:
+            ensureAdapter();
+            try {
+                nativeAdapter_->setSecureBatch(keys, values);
+            } catch (const std::exception& e) {
+                throw std::runtime_error(std::string("NitroStorage: Secure setBatch failed: ") + e.what());
+            } catch (...) {
+                throw std::runtime_error("NitroStorage: Secure setBatch failed");
+            }
+            break;
+    }
+
     for (size_t i = 0; i < keys.size(); ++i) {
-        set(keys[i], values[i], scope);
+        notifyListeners(static_cast<int>(s), 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());
-    
-    for (const auto& key : keys) {
-        auto val = get(key, scope);
-        results.push_back(val.value_or(""));
+
+    Scope s = toScope(scope);
+
+    switch (s) {
+        case Scope::Memory: {
+            std::lock_guard<std::mutex> lock(memoryMutex_);
+            for (const auto& key : keys) {
+                auto it = memoryStore_.find(key);
+                if (it != memoryStore_.end()) {
+                    results.push_back(it->second);
+                } else {
+                    results.push_back(kBatchMissingSentinel);
+                }
+            }
+            return results;
+        }
+        case Scope::Disk: {
+            ensureAdapter();
+            std::vector<std::optional<std::string>> values;
+            try {
+                values = nativeAdapter_->getDiskBatch(keys);
+            } catch (const std::exception& e) {
+                throw std::runtime_error(std::string("NitroStorage: Disk getBatch failed: ") + e.what());
+            } catch (...) {
+                throw std::runtime_error("NitroStorage: Disk getBatch failed");
+            }
+
+            for (const auto& value : values) {
+                results.push_back(value.has_value() ? *value : std::string(kBatchMissingSentinel));
+            }
+            return results;
+        }
+        case Scope::Secure: {
+            ensureAdapter();
+            std::vector<std::optional<std::string>> values;
+            try {
+                values = nativeAdapter_->getSecureBatch(keys);
+            } catch (const std::exception& e) {
+                throw std::runtime_error(std::string("NitroStorage: Secure getBatch failed: ") + e.what());
+            } catch (...) {
+                throw std::runtime_error("NitroStorage: Secure getBatch failed");
+            }
+
+            for (const auto& value : values) {
+                results.push_back(value.has_value() ? *value : std::string(kBatchMissingSentinel));
+            }
+            return results;
+        }
     }
-    
+
     return results;
 }
 
-
 void HybridStorage::removeBatch(const std::vector<std::string>& keys, double scope) {
+    Scope s = toScope(scope);
+
+    switch (s) {
+        case Scope::Memory: {
+            std::lock_guard<std::mutex> lock(memoryMutex_);
+            for (const auto& key : keys) {
+                memoryStore_.erase(key);
+            }
+            break;
+        }
+        case Scope::Disk:
+            ensureAdapter();
+            try {
+                nativeAdapter_->deleteDiskBatch(keys);
+            } catch (const std::exception& e) {
+                throw std::runtime_error(std::string("NitroStorage: Disk removeBatch failed: ") + e.what());
+            } catch (...) {
+                throw std::runtime_error("NitroStorage: Disk removeBatch failed");
+            }
+            break;
+        case Scope::Secure:
+            ensureAdapter();
+            try {
+                nativeAdapter_->deleteSecureBatch(keys);
+            } catch (const std::exception& e) {
+                throw std::runtime_error(std::string("NitroStorage: Secure removeBatch failed: ") + e.what());
+            } catch (...) {
+                throw std::runtime_error("NitroStorage: Secure removeBatch failed");
+            }
+            break;
+    }
+
     for (const auto& key : keys) {
-        remove(key, scope);
+        notifyListeners(static_cast<int>(s), key, std::nullopt);
     }
 }
 
+// --- Configuration ---
+
+void HybridStorage::setSecureAccessControl(double level) {
+    ensureAdapter();
+    nativeAdapter_->setSecureAccessControl(static_cast<int>(level));
+}
+
+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 ---
+
 void HybridStorage::notifyListeners(
     int scope,
     const std::string& key,

package/cpp/bindings/HybridStorage.hpp

@@ -20,6 +20,9 @@ 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;
@@ -27,6 +30,13 @@ public:
         double scope,
         const std::function<void(const std::string&, const std::optional<std::string>&)>& callback
     ) override;
+    void setSecureAccessControl(double level) 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 {

package/cpp/core/NativeStorageAdapter.hpp

@@ -2,6 +2,7 @@
 
 #include <string>
 #include <optional>
+#include <vector>
 
 namespace NitroStorage {
 
@@ -12,13 +13,34 @@ 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;
     
     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 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,13 +12,38 @@ 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;
     
     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 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