react-native-mmkv 4.1.1 → 4.2.0

package/NitroMmkv.podspec

@@ -24,7 +24,7 @@ Pod::Spec.new do |s|
 
   # Add MMKV Core dependency
   s.compiler_flags = '-x objective-c++'
-  s.dependency 'MMKVCore', '2.2.4'
+  s.dependency 'MMKVCore', '2.3.0'
 
   # TODO: Remove when no one uses RN 0.79 anymore
   # Add support for React Native 0.79 or below

package/android/build.gradle

@@ -5,7 +5,7 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.13.1"
+    classpath "com.android.tools.build:gradle:9.0.0"
   }
 }
 
@@ -74,6 +74,7 @@ android {
     excludes = [
             "META-INF",
             "META-INF/**",
+            "**/libNitroModules.so",
             "**/libc++_shared.so",
             "**/libfbjni.so",
             "**/libjsi.so",
@@ -139,6 +140,6 @@ dependencies {
   implementation project(":react-native-nitro-modules")
 
   // Add a dependency on mmkv core (this ships a C++ prefab)
-  implementation "io.github.zhongwuzw:mmkv:2.2.4"
+  implementation "io.github.zhongwuzw:mmkv:2.3.0"
 }
 

package/android/src/main/cpp/cpp-adapter.cpp

@@ -1,6 +1,7 @@
 #include "NitroMmkvOnLoad.hpp"
+#include <fbjni/fbjni.h>
 #include <jni.h>
 
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-  return margelo::nitro::mmkv::initialize(vm);
+  return facebook::jni::initialize(vm, []() { margelo::nitro::mmkv::registerAllNatives(); });
 }

package/cpp/HybridMMKV.cpp

@@ -22,6 +22,8 @@ HybridMMKV::HybridMMKV(const Configuration& config) : HybridObject(TAG) {
 
   std::string* pathPtr = path.size() > 0 ? &path : nullptr;
   std::string* encryptionKeyPtr = encryptionKey.size() > 0 ? &encryptionKey : nullptr;
+  size_t defaultExpectedCapacity = 0;
+  bool useAes256Encryption = config.encryptionType.has_value() && config.encryptionType.value() == EncryptionType::AES_256;
   MMKVMode mode = getMMKVMode(config);
   if (config.readOnly.has_value() && config.readOnly.value()) {
     Logger::log(LogLevel::Info, TAG, "Instance is read-only!");
@@ -29,9 +31,9 @@ HybridMMKV::HybridMMKV(const Configuration& config) : HybridObject(TAG) {
   }
 
 #ifdef __APPLE__
-  instance = MMKV::mmkvWithID(config.id, mode, encryptionKeyPtr, pathPtr);
+  instance = MMKV::mmkvWithID(config.id, mode, encryptionKeyPtr, pathPtr, defaultExpectedCapacity, useAes256Encryption);
 #else
-  instance = MMKV::mmkvWithID(config.id, DEFAULT_MMAP_SIZE, mode, encryptionKeyPtr, pathPtr);
+  instance = MMKV::mmkvWithID(config.id, DEFAULT_MMAP_SIZE, mode, encryptionKeyPtr, pathPtr, defaultExpectedCapacity, useAes256Encryption);
 #endif
 
   if (instance == nullptr) [[unlikely]] {
@@ -40,10 +42,18 @@ HybridMMKV::HybridMMKV(const Configuration& config) : HybridObject(TAG) {
       throw std::runtime_error("Failed to create MMKV instance! `id` cannot be empty!");
     }
 
-    // Check if encryptionKey is invalid
-    if (encryptionKey.size() > 16) [[unlikely]] {
-      throw std::runtime_error("Failed to create MMKV instance! `encryptionKey` cannot be longer "
-                               "than 16 bytes!");
+    if (useAes256Encryption) {
+      // With AES-256, the max key length is 32 bytes.
+      if (encryptionKey.size() > 32) [[unlikely]] {
+        throw std::runtime_error("Failed to create MMKV instance! `encryptionKey` cannot be longer "
+                                 "than 32 bytes with AES-256 encryption!");
+      }
+    } else {
+      // With AES-128, the max key length is 16 bytes.
+      if (encryptionKey.size() > 16) [[unlikely]] {
+        throw std::runtime_error("Failed to create MMKV instance! `encryptionKey` cannot be longer "
+                                 "than 16 bytes with AES-128 encryption!");
+      }
     }
 
     // Check if path is maybe invalid
@@ -58,13 +68,27 @@ HybridMMKV::HybridMMKV(const Configuration& config) : HybridObject(TAG) {
 std::string HybridMMKV::getId() {
   return instance->mmapID();
 }
+
+double HybridMMKV::getLength() {
+  return instance->count();
+}
+
 double HybridMMKV::getSize() {
+  return getByteSize();
+}
+
+double HybridMMKV::getByteSize() {
   return instance->actualSize();
 }
+
 bool HybridMMKV::getIsReadOnly() {
   return instance->isReadOnly();
 }
 
+bool HybridMMKV::getIsEncrypted() {
+  return instance->isEncryptionEnabled();
+}
+
 // helper: overload pattern matching for lambdas
 template <class... Ts>
 struct overloaded : Ts... {
@@ -104,6 +128,7 @@ void HybridMMKV::set(const std::string& key, const std::variant<bool, std::share
   // Notify on changed
   MMKVValueChangedListenerRegistry::notifyOnValueChanged(instance->mmapID(), key);
 }
+
 std::optional<bool> HybridMMKV::getBoolean(const std::string& key) {
   bool hasValue;
   bool result = instance->getBool(key, /* defaultValue */ false, &hasValue);
@@ -113,6 +138,7 @@ std::optional<bool> HybridMMKV::getBoolean(const std::string& key) {
     return std::nullopt;
   }
 }
+
 std::optional<std::string> HybridMMKV::getString(const std::string& key) {
   std::string result;
   bool hasValue = instance->getString(key, result, /* inplaceModification */ true);
@@ -122,6 +148,7 @@ std::optional<std::string> HybridMMKV::getString(const std::string& key) {
     return std::nullopt;
   }
 }
+
 std::optional<double> HybridMMKV::getNumber(const std::string& key) {
   bool hasValue;
   double result = instance->getDouble(key, /* defaultValue */ 0.0, &hasValue);
@@ -131,6 +158,7 @@ std::optional<double> HybridMMKV::getNumber(const std::string& key) {
     return std::nullopt;
   }
 }
+
 std::optional<std::shared_ptr<ArrayBuffer>> HybridMMKV::getBuffer(const std::string& key) {
   MMBuffer result;
 #ifdef __APPLE__
@@ -147,9 +175,11 @@ std::optional<std::shared_ptr<ArrayBuffer>> HybridMMKV::getBuffer(const std::str
     return std::nullopt;
   }
 }
+
 bool HybridMMKV::contains(const std::string& key) {
   return instance->containsKey(key);
 }
+
 bool HybridMMKV::remove(const std::string& key) {
   bool wasRemoved = instance->removeValueForKey(key);
   if (wasRemoved) {
@@ -158,9 +188,11 @@ bool HybridMMKV::remove(const std::string& key) {
   }
   return wasRemoved;
 }
+
 std::vector<std::string> HybridMMKV::getAllKeys() {
   return instance->allKeys();
 }
+
 void HybridMMKV::clearAll() {
   auto keysBefore = getAllKeys();
   instance->clearAll();
@@ -169,19 +201,30 @@ void HybridMMKV::clearAll() {
     MMKVValueChangedListenerRegistry::notifyOnValueChanged(instance->mmapID(), key);
   }
 }
+
 void HybridMMKV::recrypt(const std::optional<std::string>& key) {
-  bool successful = false;
   if (key.has_value()) {
-    // Encrypt with the given key
-    successful = instance->reKey(key.value());
+    encrypt(key.value(), std::nullopt);
   } else {
-    // Remove the encryption key by setting it to a blank string
-    successful = instance->reKey(std::string());
+    decrypt();
+  }
+}
+
+void HybridMMKV::encrypt(const std::string& key, std::optional<EncryptionType> encryptionType) {
+  bool isAes256Encryption = encryptionType == EncryptionType::AES_256;
+  bool successful = instance->reKey(key, isAes256Encryption);
+  if (!successful) {
+    throw std::runtime_error("Failed to encrypt MMKV instance!");
   }
+}
+
+void HybridMMKV::decrypt() {
+  bool successful = instance->reKey("");
   if (!successful) {
-    throw std::runtime_error("Failed to recrypt MMKV instance!");
+    throw std::runtime_error("Failed to decrypt MMKV instance!");
   }
 }
+
 void HybridMMKV::trim() {
   instance->trim();
   instance->clearMemoryCache();

package/cpp/HybridMMKV.hpp

@@ -21,7 +21,10 @@ public:
   // Properties
   std::string getId() override;
   double getSize() override;
+  double getByteSize() override;
+  double getLength() override;
   bool getIsReadOnly() override;
+  bool getIsEncrypted() override;
 
 public:
   // Methods
@@ -35,6 +38,8 @@ public:
   std::vector<std::string> getAllKeys() override;
   void clearAll() override;
   void recrypt(const std::optional<std::string>& key) override;
+  void encrypt(const std::string& key, std::optional<EncryptionType> encryptionType) override;
+  void decrypt() override;
   void trim() override;
   Listener addOnValueChangedListener(const std::function<void(const std::string& /* key */)>& onValueChanged) override;
   double importAllFrom(const std::shared_ptr<HybridMMKVSpec>& other) override;

package/lib/__tests__/hooks.test.js

@@ -1,6 +1,6 @@
 import React from 'react';
 import { Button, Text } from 'react-native';
-import { act, fireEvent, render, renderHook, screen, cleanup, } from '@testing-library/react-native';
+import { act, fireEvent, render, renderHook, screen, cleanup, waitFor, } from '@testing-library/react-native';
 import { createMMKV, useMMKVNumber, useMMKVString } from '..';
 const mmkv = createMMKV();
 beforeEach(() => {
@@ -67,3 +67,32 @@ test('functional updates to hooks', () => {
         '4',
     ]);
 });
+test('useMMKV hook does not miss updates that happen during subscription setup', async () => {
+    const raceKey = 'race-key';
+    const raceMMKV = createMMKV();
+    let simulatedRaceDone = false;
+    const originalSubscribe = raceMMKV.addOnValueChangedListener.bind(raceMMKV);
+    raceMMKV.addOnValueChangedListener = ((listener) => {
+        if (!simulatedRaceDone) {
+            simulatedRaceDone = true;
+            raceMMKV.set(raceKey, 'updated-before-subscribe');
+        }
+        return originalSubscribe(listener);
+    });
+    const { result } = renderHook(() => useMMKVString(raceKey, raceMMKV));
+    await waitFor(() => {
+        expect(result.current[0]).toBe('updated-before-subscribe');
+    });
+});
+test('useMMKV hook stays consistent during rapid updates', async () => {
+    const raceKey = 'rapid-key';
+    const { result } = renderHook(() => useMMKVNumber(raceKey, mmkv));
+    act(() => {
+        for (let i = 1; i <= 100; i++) {
+            mmkv.set(raceKey, i);
+        }
+    });
+    await waitFor(() => {
+        expect(result.current[0]).toBe(100);
+    });
+});

package/lib/createMMKV/createMMKV.web.js

@@ -24,8 +24,18 @@ export function createMMKV(config = { id: 'mmkv.default' }) {
     };
     return {
         id: config.id,
-        size: 0,
+        get length() {
+            return getLocalStorage().length;
+        },
+        get size() {
+            return this.byteSize;
+        },
+        get byteSize() {
+            // esimate - assumes UTF8
+            return JSON.stringify(getLocalStorage()).length;
+        },
         isReadOnly: false,
+        isEncrypted: false,
         clearAll: () => {
             const storage = getLocalStorage();
             const keys = Object.keys(storage);
@@ -90,6 +100,12 @@ export function createMMKV(config = { id: 'mmkv.default' }) {
         recrypt: () => {
             throw new Error('`recrypt(..)` is not supported on Web!');
         },
+        encrypt: () => {
+            throw new Error('`encrypt(..)` is not supported on Web!');
+        },
+        decrypt: () => {
+            throw new Error('`decrypt(..)` is not supported on Web!');
+        },
         trim: () => {
             // no-op
         },

package/lib/createMMKV/createMockMMKV.js

@@ -11,10 +11,18 @@ export function createMockMMKV(config = { id: 'mmkv.default' }) {
     };
     return {
         id: config.id,
-        get size() {
+        get length() {
             return storage.size;
         },
+        get size() {
+            return this.byteSize;
+        },
+        get byteSize() {
+            // esimate - assumes UTF8
+            return JSON.stringify(storage).length;
+        },
         isReadOnly: false,
+        isEncrypted: false,
         clearAll: () => {
             const keysBefore = storage.keys();
             storage.clear();
@@ -57,6 +65,12 @@ export function createMockMMKV(config = { id: 'mmkv.default' }) {
         recrypt: () => {
             console.warn('Encryption is not supported in mocked MMKV instances!');
         },
+        encrypt: () => {
+            console.warn('Encryption is not supported in mocked MMKV instances!');
+        },
+        decrypt: () => {
+            console.warn('Encryption is not supported in mocked MMKV instances!');
+        },
         trim: () => {
             // no-op
         },

package/lib/hooks/createMMKVHook.js

@@ -1,16 +1,16 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useSyncExternalStore } from 'react';
 import { getDefaultMMKVInstance } from '../createMMKV/getDefaultMMKVInstance';
 export function createMMKVHook(getter) {
     return (key, instance) => {
         const mmkv = instance ?? getDefaultMMKVInstance();
-        const [bump, setBump] = useState(0);
-        const value = useMemo(() => {
-            // bump is here as an additional outside dependency, so this useMemo
-            // re-computes the value each time bump changes, effectively acting as a hint
-            // that the outside value (storage) has changed. setting bump refreshes this value.
-            bump;
-            return getter(mmkv, key);
-        }, [mmkv, key, bump]);
+        const value = useSyncExternalStore(useCallback((onStoreChange) => {
+            const listener = mmkv.addOnValueChangedListener((changedKey) => {
+                if (changedKey === key) {
+                    onStoreChange();
+                }
+            });
+            return () => listener.remove();
+        }, [key, mmkv]), useCallback(() => getter(mmkv, key), [key, mmkv]), useCallback(() => getter(mmkv, key), [key, mmkv]));
         // update value by user set
         const set = useCallback((v) => {
             const newValue = typeof v === 'function' ? v(getter(mmkv, key)) : v;
@@ -35,15 +35,6 @@ export function createMMKVHook(getter) {
                     throw new Error(`MMKV: Type ${typeof newValue} is not supported!`);
             }
         }, [key, mmkv]);
-        // update value if it changes somewhere else (second hook, same key)
-        useEffect(() => {
-            const listener = mmkv.addOnValueChangedListener((changedKey) => {
-                if (changedKey === key) {
-                    setBump((b) => b + 1);
-                }
-            });
-            return () => listener.remove();
-        }, [key, mmkv]);
         return [value, set];
     };
 }

package/lib/specs/MMKV.nitro.d.ts

@@ -1,4 +1,5 @@
 import type { HybridObject } from 'react-native-nitro-modules';
+import type { EncryptionType } from './MMKVFactory.nitro';
 export interface Listener {
     remove: () => void;
 }
@@ -10,15 +11,31 @@ export interface MMKV extends HybridObject<{
      * Get the ID of this {@linkcode MMKV} instance.
      */
     readonly id: string;
+    /**
+     * Get the current amount of key/value pairs stored in
+     * this storage.
+     */
+    readonly length: number;
     /**
      * Get the current total size of the storage, in bytes.
+     * @deprecated Use {@linkcode byteSize} instead.
      */
     readonly size: number;
     /**
-     * Returns whether this instance is in read-only mode or not.
+     * Get the current total size of the storage, in bytes.
+     */
+    readonly byteSize: number;
+    /**
+     * Get whether this instance is in read-only mode or not.
      * If this is `true`, you can only use "get"-functions.
      */
     readonly isReadOnly: boolean;
+    /**
+     * Get whether this instance is encrypted, or not.
+     * @see {@linkcode encrypt | encrypt(...)}
+     * @see {@linkcode decrypt | decrypt()}
+     */
+    readonly isEncrypted: boolean;
     /**
      * Set a {@linkcode value} for the given {@linkcode key}.
      *
@@ -77,8 +94,36 @@ export interface MMKV extends HybridObject<{
      * Encryption keys can have a maximum length of 16 bytes.
      *
      * @throws an Error if the instance cannot be recrypted.
+     * @deprecated Use {@linkcode encrypt | encrypt(...)} or {@linkcode decrypt | decrypt()} instead.
      */
     recrypt(key: string | undefined): void;
+    /**
+     * Encrypts the data in this MMKV instance with the
+     * given {@linkcode key} and {@linkcode ecnryptionType}.
+     *
+     * If this MMKV instance is already encrypted ({@linkcode isEncrypted}),
+     * it will re-encrypt the data.
+     *
+     * Future attempts to open this MMKV instance will require the same
+     * {@linkcode key} and {@linkcode encryptionType}, otherwise reads
+     * will fail.
+     *
+     * The {@linkcode key} must be 16-bytes in {@linkcode EncryptionType | 'AES-128'}
+     * encryption (the default), or 32-bytes in {@linkcode EncryptionType | 'AES-256'}
+     * encryption.
+     *
+     * @param key The encryption key to use. In AES-128 this must be 16-bytes, in AES-256 it must be 32-bytes long.
+     * @param encryptionType The encryption type to use. Default: AES-128
+     */
+    encrypt(key: string, encryptionType?: EncryptionType): void;
+    /**
+     * Decrypts the data in this MMKV instance and removes
+     * the encryption key.
+     *
+     * Future attempts to open this MMKV instance must be done
+     * without an encryption key, as it is now plain-text.
+     */
+    decrypt(): void;
     /**
      * Trims the storage space and clears memory cache.
      *

package/lib/specs/MMKVFactory.nitro.d.ts

@@ -6,6 +6,12 @@ import type { MMKV } from './MMKV.nitro';
  * - `multi-process`: The MMKV instance may be used from multiple processes, such as app clips, share extensions or background services.
  */
 export type Mode = 'single-process' | 'multi-process';
+/**
+ * Configures the encryption algorithm for the MMKV instance.
+ * - `AES-128`: Uses AES-128 encryption (default).
+ * - `AES-256`: Uses AES-256 encryption for enhanced security.
+ */
+export type EncryptionType = 'AES-128' | 'AES-256';
 /**
  * Used for configuration of a single MMKV instance.
  */
@@ -40,7 +46,7 @@ export interface Configuration {
     /**
      * The MMKV instance's encryption/decryption key. By default, MMKV stores all key-values in plain text on file, relying on iOS's sandbox to make sure the file is encrypted. Should you worry about information leaking, you can choose to encrypt MMKV.
      *
-     * Encryption keys can have a maximum length of 16 bytes.
+     * Encryption keys can have a maximum length of 16 bytes with AES-128 encryption and 32 bytes with AES-256 encryption.
      *
      * @example
      * ```ts
@@ -50,6 +56,21 @@ export interface Configuration {
      * @default undefined
      */
     encryptionKey?: string;
+    /**
+     * The encryption algorithm to use when an encryption key is provided.
+     *
+     * @example
+     * ```ts
+     * const secureStorage = createMMKV({
+     *   id: 'secure-storage',
+     *   encryptionKey: 'my-encryption-key!',
+     *   encryptionType: 'AES-256'
+     * })
+     * ```
+     *
+     * @default 'AES-128'
+     */
+    encryptionType?: EncryptionType;
     /**
      * Configure the processing mode for MMKV.
      *

package/nitrogen/generated/android/NitroMmkvOnLoad.cpp

@@ -22,33 +22,43 @@
 namespace margelo::nitro::mmkv {
 
 int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::mmkv::registerAllNatives();
+  });
+}
+
+struct JHybridMMKVPlatformContextSpecImpl: public jni::JavaClass<JHybridMMKVPlatformContextSpecImpl, JHybridMMKVPlatformContextSpec::JavaPart> {
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/mmkv/HybridMMKVPlatformContext;";
+  static std::shared_ptr<JHybridMMKVPlatformContextSpec> create() {
+    static auto constructorFn = javaClassStatic()->getConstructor<JHybridMMKVPlatformContextSpecImpl::javaobject()>();
+    jni::local_ref<JHybridMMKVPlatformContextSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridMMKVPlatformContextSpec();
+  }
+};
+
+void registerAllNatives() {
   using namespace margelo::nitro;
   using namespace margelo::nitro::mmkv;
-  using namespace facebook;
-
-  return facebook::jni::initialize(vm, [] {
-    // Register native JNI methods
-    margelo::nitro::mmkv::JHybridMMKVPlatformContextSpec::registerNatives();
-
-    // Register Nitro Hybrid Objects
-    HybridObjectRegistry::registerHybridObjectConstructor(
-      "MMKVFactory",
-      []() -> std::shared_ptr<HybridObject> {
-        static_assert(std::is_default_constructible_v<HybridMMKVFactory>,
-                      "The HybridObject \"HybridMMKVFactory\" is not default-constructible! "
-                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
-        return std::make_shared<HybridMMKVFactory>();
-      }
-    );
-    HybridObjectRegistry::registerHybridObjectConstructor(
-      "MMKVPlatformContext",
-      []() -> std::shared_ptr<HybridObject> {
-        static DefaultConstructableObject<JHybridMMKVPlatformContextSpec::javaobject> object("com/margelo/nitro/mmkv/HybridMMKVPlatformContext");
-        auto instance = object.create();
-        return instance->cthis()->shared();
-      }
-    );
-  });
+
+  // Register native JNI methods
+  margelo::nitro::mmkv::JHybridMMKVPlatformContextSpec::CxxPart::registerNatives();
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MMKVFactory",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridMMKVFactory>,
+                    "The HybridObject \"HybridMMKVFactory\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridMMKVFactory>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MMKVPlatformContext",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridMMKVPlatformContextSpecImpl::create();
+    }
+  );
 }
 
 } // namespace margelo::nitro::mmkv

package/nitrogen/generated/android/NitroMmkvOnLoad.hpp

@@ -6,20 +6,29 @@
 ///
 
 #include <jni.h>
+#include <functional>
 #include <NitroModules/NitroDefines.hpp>
 
 namespace margelo::nitro::mmkv {
 
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
   /**
-   * Initializes the native (C++) part of NitroMmkv, and autolinks all Hybrid Objects.
-   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`).
+   * Register the native (C++) part of NitroMmkv, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
    * Example:
    * ```cpp (cpp-adapter.cpp)
    * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-   *   return margelo::nitro::mmkv::initialize(vm);
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all NitroMmkv HybridObjects
+   *     margelo::nitro::mmkv::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
    * }
    * ```
    */
-  int initialize(JavaVM* vm);
+  void registerAllNatives();
 
 } // namespace margelo::nitro::mmkv