react-native-nitro-storage 0.1.3 → 0.3.0

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__
@@ -24,12 +28,21 @@ HybridStorage::HybridStorage(std::shared_ptr<::NitroStorage::NativeStorageAdapte
     : HybridObject(TAG), HybridStorageSpec(), nativeAdapter_(std::move(adapter)) {}
 
 HybridStorage::Scope HybridStorage::toScope(double scopeValue) {
-    return static_cast<Scope>(static_cast<int>(scopeValue));
+    if (scopeValue < 0.0 || scopeValue > 2.0) {
+        throw std::runtime_error("NitroStorage: Invalid scope value");
+    }
+
+    int intValue = static_cast<int>(scopeValue);
+    if (scopeValue != static_cast<double>(intValue)) {
+        throw std::runtime_error("NitroStorage: Invalid scope value");
+    }
+
+    return static_cast<Scope>(intValue);
 }
 
 void HybridStorage::set(const std::string& key, const std::string& value, double scope) {
     Scope s = toScope(scope);
-    
+
     switch (s) {
         case Scope::Memory: {
             std::lock_guard<std::mutex> lock(memoryMutex_);
@@ -37,10 +50,24 @@ void HybridStorage::set(const std::string& key, const std::string& value, double
             break;
         }
         case Scope::Disk:
-            nativeAdapter_->setDisk(key, value);
+            ensureAdapter();
+            try {
+                nativeAdapter_->setDisk(key, value);
+            } catch (const std::exception& e) {
+                throw std::runtime_error(std::string("NitroStorage: Disk set failed: ") + e.what());
+            } catch (...) {
+                throw std::runtime_error("NitroStorage: Disk set failed");
+            }
             break;
         case Scope::Secure:
-            nativeAdapter_->setSecure(key, value);
+            ensureAdapter();
+            try {
+                nativeAdapter_->setSecure(key, value);
+            } catch (const std::exception& e) {
+                throw std::runtime_error(std::string("NitroStorage: Secure set failed: ") + e.what());
+            } catch (...) {
+                throw std::runtime_error("NitroStorage: Secure set failed");
+            }
             break;
     }
     
@@ -60,9 +87,23 @@ std::optional<std::string> HybridStorage::get(const std::string& key, double sco
             return std::nullopt;
         }
         case Scope::Disk:
-            return nativeAdapter_->getDisk(key);
+            ensureAdapter();
+            try {
+                return nativeAdapter_->getDisk(key);
+            } catch (const std::exception& e) {
+                throw std::runtime_error(std::string("NitroStorage: Disk get failed: ") + e.what());
+            } catch (...) {
+                throw std::runtime_error("NitroStorage: Disk get failed");
+            }
         case Scope::Secure:
-            return nativeAdapter_->getSecure(key);
+            ensureAdapter();
+            try {
+                return nativeAdapter_->getSecure(key);
+            } catch (const std::exception& e) {
+                throw std::runtime_error(std::string("NitroStorage: Secure get failed: ") + e.what());
+            } catch (...) {
+                throw std::runtime_error("NitroStorage: Secure get failed");
+            }
     }
     
     return std::nullopt;
@@ -78,10 +119,24 @@ void HybridStorage::remove(const std::string& key, double scope) {
             break;
         }
         case Scope::Disk:
-            nativeAdapter_->deleteDisk(key);
+            ensureAdapter();
+            try {
+                nativeAdapter_->deleteDisk(key);
+            } catch (const std::exception& e) {
+                throw std::runtime_error(std::string("NitroStorage: Disk delete failed: ") + e.what());
+            } catch (...) {
+                throw std::runtime_error("NitroStorage: Disk delete failed");
+            }
             break;
         case Scope::Secure:
-            nativeAdapter_->deleteSecure(key);
+            ensureAdapter();
+            try {
+                nativeAdapter_->deleteSecure(key);
+            } catch (const std::exception& e) {
+                throw std::runtime_error(std::string("NitroStorage: Secure delete failed: ") + e.what());
+            } catch (...) {
+                throw std::runtime_error("NitroStorage: Secure delete failed");
+            }
             break;
     }
     
@@ -123,10 +178,24 @@ void HybridStorage::clear(double scope) {
             break;
         }
         case Scope::Disk:
-            nativeAdapter_->clearDisk();
+            ensureAdapter();
+            try {
+                nativeAdapter_->clearDisk();
+            } catch (const std::exception& e) {
+                throw std::runtime_error(std::string("NitroStorage: Disk clear failed: ") + e.what());
+            } catch (...) {
+                throw std::runtime_error("NitroStorage: Disk clear failed");
+            }
             break;
         case Scope::Secure:
-            nativeAdapter_->clearSecure();
+            ensureAdapter();
+            try {
+                nativeAdapter_->clearSecure();
+            } catch (const std::exception& e) {
+                throw std::runtime_error(std::string("NitroStorage: Secure clear failed: ") + e.what());
+            } catch (...) {
+                throw std::runtime_error("NitroStorage: Secure clear failed");
+            }
             break;
     }
     
@@ -137,9 +206,41 @@ 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]);
     }
 }
 
@@ -147,19 +248,103 @@ void HybridStorage::setBatch(const std::vector<std::string>& keys, const std::ve
 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) {
+                if (value.has_value()) {
+                    results.push_back(*value);
+                } else {
+                    results.push_back(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) {
+                if (value.has_value()) {
+                    results.push_back(*value);
+                } else {
+                    results.push_back(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);
     }
 }
 
@@ -179,7 +364,17 @@ void HybridStorage::notifyListeners(
     }
     
     for (const auto& listener : listenersCopy) {
-        listener.callback(key, value);
+        try {
+            listener.callback(key, value);
+        } catch (...) {
+            // Ignore listener failures to avoid crashing the caller.
+        }
+    }
+}
+
+void HybridStorage::ensureAdapter() const {
+    if (!nativeAdapter_) {
+        throw std::runtime_error("NitroStorage: Native adapter not initialized");
     }
 }
 

package/cpp/bindings/HybridStorage.hpp

@@ -50,6 +50,7 @@ private:
     size_t nextListenerId_ = 0;
 
     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

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

package/ios/IOSStorageAdapterCpp.hpp

@@ -12,10 +12,16 @@ 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;
+    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;
+    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;

package/ios/IOSStorageAdapterCpp.mm

@@ -5,23 +5,77 @@
 namespace NitroStorage {
 
 static NSString* const kKeychainService = @"com.nitrostorage.keychain";
+static NSString* const kDiskSuiteName = @"com.nitrostorage.disk";
+
+static NSUserDefaults* NitroDiskDefaults() {
+    static NSUserDefaults* defaults = [[NSUserDefaults alloc] initWithSuiteName:kDiskSuiteName];
+    return defaults ?: [NSUserDefaults standardUserDefaults];
+}
 
 IOSStorageAdapterCpp::IOSStorageAdapterCpp() {}
 IOSStorageAdapterCpp::~IOSStorageAdapterCpp() {}
 
 void IOSStorageAdapterCpp::setDisk(const std::string& key, const std::string& value) {
-    [[NSUserDefaults standardUserDefaults] setObject:[NSString stringWithUTF8String:value.c_str()]
-                                              forKey:[NSString stringWithUTF8String:key.c_str()]];
+    NSString* nsKey = [NSString stringWithUTF8String:key.c_str()];
+    NSString* nsValue = [NSString stringWithUTF8String:value.c_str()];
+    NSUserDefaults* defaults = NitroDiskDefaults();
+    [defaults setObject:nsValue forKey:nsKey];
+    [[NSUserDefaults standardUserDefaults] removeObjectForKey:nsKey];
 }
 
 std::optional<std::string> IOSStorageAdapterCpp::getDisk(const std::string& key) {
-    NSString* result = [[NSUserDefaults standardUserDefaults] stringForKey:[NSString stringWithUTF8String:key.c_str()]];
+    NSString* nsKey = [NSString stringWithUTF8String:key.c_str()];
+    NSUserDefaults* defaults = NitroDiskDefaults();
+    NSString* result = [defaults stringForKey:nsKey];
+
+    if (!result) {
+        NSUserDefaults* legacyDefaults = [NSUserDefaults standardUserDefaults];
+        NSString* legacyValue = [legacyDefaults stringForKey:nsKey];
+        if (legacyValue) {
+            [defaults setObject:legacyValue forKey:nsKey];
+            [legacyDefaults removeObjectForKey:nsKey];
+            result = legacyValue;
+        }
+    }
+
     if (!result) return std::nullopt;
     return std::string([result UTF8String]);
 }
 
 void IOSStorageAdapterCpp::deleteDisk(const std::string& key) {
-    [[NSUserDefaults standardUserDefaults] removeObjectForKey:[NSString stringWithUTF8String:key.c_str()]];
+    NSString* nsKey = [NSString stringWithUTF8String:key.c_str()];
+    [NitroDiskDefaults() removeObjectForKey:nsKey];
+    [[NSUserDefaults standardUserDefaults] removeObjectForKey:nsKey];
+}
+
+void IOSStorageAdapterCpp::setDiskBatch(
+    const std::vector<std::string>& keys,
+    const std::vector<std::string>& values
+) {
+    NSUserDefaults* defaults = NitroDiskDefaults();
+    for (size_t i = 0; i < keys.size() && i < values.size(); ++i) {
+        NSString* nsKey = [NSString stringWithUTF8String:keys[i].c_str()];
+        NSString* nsValue = [NSString stringWithUTF8String:values[i].c_str()];
+        [defaults setObject:nsValue forKey:nsKey];
+        [[NSUserDefaults standardUserDefaults] removeObjectForKey:nsKey];
+    }
+}
+
+std::vector<std::optional<std::string>> IOSStorageAdapterCpp::getDiskBatch(
+    const std::vector<std::string>& keys
+) {
+    std::vector<std::optional<std::string>> results;
+    results.reserve(keys.size());
+    for (const auto& key : keys) {
+        results.push_back(getDisk(key));
+    }
+    return results;
+}
+
+void IOSStorageAdapterCpp::deleteDiskBatch(const std::vector<std::string>& keys) {
+    for (const auto& key : keys) {
+        deleteDisk(key);
+    }
 }
 
 void IOSStorageAdapterCpp::setSecure(const std::string& key, const std::string& value) {
@@ -39,7 +93,7 @@ void IOSStorageAdapterCpp::setSecure(const std::string& key, const std::string&
     };
 
     OSStatus status = SecItemUpdate((__bridge CFDictionaryRef)query, (__bridge CFDictionaryRef)updateAttributes);
-    
+
     if (status == errSecItemNotFound) {
         NSMutableDictionary* addQuery = [query mutableCopy];
         addQuery[(__bridge id)kSecValueData] = data;
@@ -75,9 +129,38 @@ void IOSStorageAdapterCpp::deleteSecure(const std::string& key) {
     SecItemDelete((__bridge CFDictionaryRef)query);
 }
 
+void IOSStorageAdapterCpp::setSecureBatch(
+    const std::vector<std::string>& keys,
+    const std::vector<std::string>& values
+) {
+    for (size_t i = 0; i < keys.size() && i < values.size(); ++i) {
+        setSecure(keys[i], values[i]);
+    }
+}
+
+std::vector<std::optional<std::string>> IOSStorageAdapterCpp::getSecureBatch(
+    const std::vector<std::string>& keys
+) {
+    std::vector<std::optional<std::string>> results;
+    results.reserve(keys.size());
+    for (const auto& key : keys) {
+        results.push_back(getSecure(key));
+    }
+    return results;
+}
+
+void IOSStorageAdapterCpp::deleteSecureBatch(const std::vector<std::string>& keys) {
+    for (const auto& key : keys) {
+        deleteSecure(key);
+    }
+}
+
 void IOSStorageAdapterCpp::clearDisk() {
-    NSString* appDomain = [[NSBundle mainBundle] bundleIdentifier];
-    [[NSUserDefaults standardUserDefaults] removePersistentDomainForName:appDomain];
+    NSUserDefaults* defaults = NitroDiskDefaults();
+    NSDictionary<NSString*, id>* entries = [defaults dictionaryRepresentation];
+    for (NSString* key in entries) {
+        [defaults removeObjectForKey:key];
+    }
 }
 
 void IOSStorageAdapterCpp::clearSecure() {