react-native-nitro-storage 0.1.4 → 0.3.0

package/android/src/main/cpp/AndroidStorageAdapterCpp.cpp

@@ -3,6 +3,39 @@
 namespace NitroStorage {
 
 using namespace facebook::jni;
+using JavaStringArray = JArrayClass<jstring>;
+
+namespace {
+
+local_ref<JavaStringArray> toJavaStringArray(const std::vector<std::string>& values) {
+    auto javaArray = JavaStringArray::newArray(static_cast<jsize>(values.size()));
+    for (size_t i = 0; i < values.size(); ++i) {
+        auto javaValue = make_jstring(values[i]);
+        javaArray->setElement(static_cast<jsize>(i), javaValue.get());
+    }
+    return javaArray;
+}
+
+std::vector<std::optional<std::string>> fromJavaStringArray(alias_ref<JavaStringArray> values) {
+    std::vector<std::optional<std::string>> parsedValues;
+    if (!values) {
+        return parsedValues;
+    }
+
+    const auto size = values->size();
+    parsedValues.reserve(size);
+    for (jsize i = 0; i < size; ++i) {
+        auto currentValue = values->getElement(i);
+        if (!currentValue) {
+            parsedValues.push_back(std::nullopt);
+            continue;
+        }
+        parsedValues.push_back(currentValue->toStdString());
+    }
+    return parsedValues;
+}
+
+} // namespace
 
 AndroidStorageAdapterCpp::AndroidStorageAdapterCpp(alias_ref<JObject> context) {
     if (!context) [[unlikely]] {
@@ -29,6 +62,40 @@ void AndroidStorageAdapterCpp::deleteDisk(const std::string& key) {
     method(AndroidStorageAdapterJava::javaClassStatic(), key);
 }
 
+void AndroidStorageAdapterCpp::setDiskBatch(
+    const std::vector<std::string>& keys,
+    const std::vector<std::string>& values
+) {
+    auto javaKeys = toJavaStringArray(keys);
+    auto javaValues = toJavaStringArray(values);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            void(alias_ref<JavaStringArray>, alias_ref<JavaStringArray>)
+        >("setDiskBatch");
+    method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys, javaValues);
+}
+
+std::vector<std::optional<std::string>> AndroidStorageAdapterCpp::getDiskBatch(
+    const std::vector<std::string>& keys
+) {
+    auto javaKeys = toJavaStringArray(keys);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            local_ref<JavaStringArray>(alias_ref<JavaStringArray>)
+        >("getDiskBatch");
+    auto values = method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys);
+    return fromJavaStringArray(values);
+}
+
+void AndroidStorageAdapterCpp::deleteDiskBatch(const std::vector<std::string>& keys) {
+    auto javaKeys = toJavaStringArray(keys);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            void(alias_ref<JavaStringArray>)
+        >("deleteDiskBatch");
+    method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys);
+}
+
 void AndroidStorageAdapterCpp::setSecure(const std::string& key, const std::string& value) {
     static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(std::string, std::string)>("setSecure");
     method(AndroidStorageAdapterJava::javaClassStatic(), key, value);
@@ -46,6 +113,40 @@ void AndroidStorageAdapterCpp::deleteSecure(const std::string& key) {
     method(AndroidStorageAdapterJava::javaClassStatic(), key);
 }
 
+void AndroidStorageAdapterCpp::setSecureBatch(
+    const std::vector<std::string>& keys,
+    const std::vector<std::string>& values
+) {
+    auto javaKeys = toJavaStringArray(keys);
+    auto javaValues = toJavaStringArray(values);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            void(alias_ref<JavaStringArray>, alias_ref<JavaStringArray>)
+        >("setSecureBatch");
+    method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys, javaValues);
+}
+
+std::vector<std::optional<std::string>> AndroidStorageAdapterCpp::getSecureBatch(
+    const std::vector<std::string>& keys
+) {
+    auto javaKeys = toJavaStringArray(keys);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            local_ref<JavaStringArray>(alias_ref<JavaStringArray>)
+        >("getSecureBatch");
+    auto values = method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys);
+    return fromJavaStringArray(values);
+}
+
+void AndroidStorageAdapterCpp::deleteSecureBatch(const std::vector<std::string>& keys) {
+    auto javaKeys = toJavaStringArray(keys);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            void(alias_ref<JavaStringArray>)
+        >("deleteSecureBatch");
+    method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys);
+}
+
 void AndroidStorageAdapterCpp::clearDisk() {
     static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void()>("clearDisk");
     method(AndroidStorageAdapterJava::javaClassStatic());

package/android/src/main/cpp/AndroidStorageAdapterCpp.hpp

@@ -18,47 +18,6 @@ struct AndroidStorageAdapterJava : facebook::jni::JavaClass<AndroidStorageAdapte
      return method(javaClassStatic());
   }
 
-  void setDisk(std::string key, std::string value) {
-      static auto method = javaClassStatic()->getMethod<void(std::string, std::string)>("setDisk");
-      method(self(), key, value);
-  }
-
-  std::string getDisk(std::string key) {
-      static auto method = javaClassStatic()->getMethod<jstring(std::string)>("getDisk");
-      auto result = method(self(), key);
-      return result ? result->toStdString() : "";
-  }
-  
-  void deleteDisk(std::string key) {
-      static auto method = javaClassStatic()->getMethod<void(std::string)>("deleteDisk");
-      method(self(), key);
-  }
-
-  void setSecure(std::string key, std::string value) {
-      static auto method = javaClassStatic()->getMethod<void(std::string, std::string)>("setSecure");
-      method(self(), key, value);
-  }
-
-  std::string getSecure(std::string key) {
-      static auto method = javaClassStatic()->getMethod<jstring(std::string)>("getSecure");
-      auto result = method(self(), key);
-      return result ? result->toStdString() : "";
-  }
-  
-  void deleteSecure(std::string key) {
-      static auto method = javaClassStatic()->getMethod<void(std::string)>("deleteSecure");
-      method(self(), key);
-  }
-
-  void clearDisk() {
-      static auto method = javaClassStatic()->getStaticMethod<void()>("clearDisk");
-      method(javaClassStatic());
-  }
-
-  void clearSecure() {
-      static auto method = javaClassStatic()->getStaticMethod<void()>("clearSecure");
-      method(javaClassStatic());
-  }
 };
 
 class AndroidStorageAdapterCpp : public NativeStorageAdapter {
@@ -69,10 +28,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/android/src/main/java/com/nitrostorage/AndroidStorageAdapter.kt

@@ -11,8 +11,9 @@ import javax.crypto.AEADBadTagException
 class AndroidStorageAdapter private constructor(private val context: Context) {
     private val sharedPreferences: SharedPreferences = 
         context.getSharedPreferences("NitroStorage", Context.MODE_PRIVATE)
-    
-    private val masterKey: MasterKey = MasterKey.Builder(context)
+
+    private val masterKeyAlias = "${context.packageName}.nitro_storage.master_key"
+    private val masterKey: MasterKey = MasterKey.Builder(context, masterKeyAlias)
         .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
         .build()
     
@@ -59,7 +60,7 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
             // Delete the master key from Android Keystore
             val keyStore = KeyStore.getInstance("AndroidKeyStore")
             keyStore.load(null)
-            keyStore.deleteEntry(MasterKey.DEFAULT_MASTER_KEY_ALIAS)
+            keyStore.deleteEntry(masterKeyAlias)
             
             Log.i("NitroStorage", "Successfully cleared corrupted secure storage")
         } catch (e: Exception) {
@@ -98,32 +99,86 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         fun setDisk(key: String, value: String) {
             getInstanceOrThrow().sharedPreferences.edit().putString(key, value).apply()
         }
+
+        @JvmStatic
+        fun setDiskBatch(keys: Array<String>, values: Array<String>) {
+            val editor = getInstanceOrThrow().sharedPreferences.edit()
+            val count = minOf(keys.size, values.size)
+            for (index in 0 until count) {
+                editor.putString(keys[index], values[index])
+            }
+            editor.apply()
+        }
         
         @JvmStatic
         fun getDisk(key: String): String? {
             return getInstanceOrThrow().sharedPreferences.getString(key, null)
         }
+
+        @JvmStatic
+        fun getDiskBatch(keys: Array<String>): Array<String?> {
+            val prefs = getInstanceOrThrow().sharedPreferences
+            return Array(keys.size) { index ->
+                prefs.getString(keys[index], null)
+            }
+        }
         
         @JvmStatic
         fun deleteDisk(key: String) {
             getInstanceOrThrow().sharedPreferences.edit().remove(key).apply()
         }
+
+        @JvmStatic
+        fun deleteDiskBatch(keys: Array<String>) {
+            val editor = getInstanceOrThrow().sharedPreferences.edit()
+            for (key in keys) {
+                editor.remove(key)
+            }
+            editor.apply()
+        }
         
         @JvmStatic
         fun setSecure(key: String, value: String) {
             getInstanceOrThrow().encryptedPreferences.edit().putString(key, value).apply()
         }
+
+        @JvmStatic
+        fun setSecureBatch(keys: Array<String>, values: Array<String>) {
+            val editor = getInstanceOrThrow().encryptedPreferences.edit()
+            val count = minOf(keys.size, values.size)
+            for (index in 0 until count) {
+                editor.putString(keys[index], values[index])
+            }
+            editor.apply()
+        }
         
         @JvmStatic
         fun getSecure(key: String): String? {
             return getInstanceOrThrow().encryptedPreferences.getString(key, null)
         }
+
+        @JvmStatic
+        fun getSecureBatch(keys: Array<String>): Array<String?> {
+            val prefs = getInstanceOrThrow().encryptedPreferences
+            return Array(keys.size) { index ->
+                prefs.getString(keys[index], null)
+            }
+        }
         
         @JvmStatic
         fun deleteSecure(key: String) {
             getInstanceOrThrow().encryptedPreferences.edit().remove(key).apply()
         }
 
+        @JvmStatic
+        fun deleteSecureBatch(keys: Array<String>) {
+            val editor = getInstanceOrThrow().encryptedPreferences.edit()
+            for (key in keys) {
+                editor.remove(key)
+            }
+            editor.apply()
+        }
+
         @JvmStatic
         fun clearDisk() {
             getInstanceOrThrow().sharedPreferences.edit().clear().apply()

package/app.plugin.js

@@ -6,19 +6,21 @@ const {
 } = require("@expo/config-plugins");
 
 const withNitroStorage = (config, props = {}) => {
-  const {
-    faceIDPermission = "Allow $(PRODUCT_NAME) to use Face ID for secure authentication",
-  } = props;
+  const defaultFaceIDPermission =
+    "Allow $(PRODUCT_NAME) to use Face ID for secure authentication";
+  const { faceIDPermission, addBiometricPermissions = false } = props;
 
   config = withInfoPlist(config, (config) => {
-    config.modResults.NSFaceIDUsageDescription =
-      faceIDPermission || config.modResults.NSFaceIDUsageDescription;
+    if (typeof faceIDPermission === "string" && faceIDPermission.trim() !== "") {
+      config.modResults.NSFaceIDUsageDescription = faceIDPermission;
+    } else if (!config.modResults.NSFaceIDUsageDescription) {
+      config.modResults.NSFaceIDUsageDescription = defaultFaceIDPermission;
+    }
     return config;
   });
 
   config = withAndroidManifest(config, (config) => {
-    const mainApplication = config.modResults.manifest.application?.[0];
-    if (!mainApplication) {
+    if (!addBiometricPermissions) {
       return config;
     }
 

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__
@@ -202,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]);
     }
 }
 
@@ -212,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);
     }
 }
 

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) {
@@ -75,10 +129,37 @@ 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];
-    if (appDomain) {
-        [[NSUserDefaults standardUserDefaults] removePersistentDomainForName:appDomain];
+    NSUserDefaults* defaults = NitroDiskDefaults();
+    NSDictionary<NSString*, id>* entries = [defaults dictionaryRepresentation];
+    for (NSString* key in entries) {
+        [defaults removeObjectForKey:key];
     }
 }