react-native-mmkv 2.0.0 → 2.1.1

package/MMKV/Core/MemoryFile_Win32.cpp

@@ -28,6 +28,7 @@
 #    include "ScopedLock.hpp"
 #    include "ThreadLock.h"
 #    include <cassert>
+#    include <strsafe.h>
 
 using namespace std;
 
@@ -36,13 +37,73 @@ namespace mmkv {
 static bool getFileSize(MMKVFileHandle_t fd, size_t &size);
 static bool ftruncate(MMKVFileHandle_t file, size_t size);
 
-MemoryFile::MemoryFile(const MMKVPath_t &path)
-    : m_name(path), m_fd(INVALID_HANDLE_VALUE), m_fileMapping(nullptr), m_ptr(nullptr), m_size(0) {
+File::File(MMKVPath_t path, OpenFlag flag) : m_path(std::move(path)), m_fd(INVALID_HANDLE_VALUE), m_flag(flag) {
+    open();
+}
+
+static pair<int, int> OpenFlag2NativeFlag(OpenFlag flag) {
+    int access = 0, create = OPEN_EXISTING;
+    if (flag & OpenFlag::ReadWrite) {
+        access = (GENERIC_READ | GENERIC_WRITE);
+    } else if (flag & OpenFlag::ReadOnly) {
+        access |= GENERIC_READ;
+    } else if (flag & OpenFlag::WriteOnly) {
+        access |= GENERIC_WRITE;
+    }
+    if (flag & OpenFlag::Create) {
+        create = OPEN_ALWAYS;
+    }
+    if (flag & OpenFlag::Excel) {
+        access = CREATE_NEW;
+    }
+    if (flag & OpenFlag::Truncate) {
+        access = CREATE_ALWAYS;
+    }
+    return {access, create};
+}
+
+bool File::open() {
+    if (isFileValid()) {
+        return true;
+    }
+    auto pair = OpenFlag2NativeFlag(m_flag);
+    m_fd = CreateFile(m_path.c_str(), pair.first, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr,
+                      pair.second, FILE_ATTRIBUTE_NORMAL, nullptr);
+    if (!isFileValid()) {
+        MMKVError("fail to open:[%ws], %d", m_path.c_str(), GetLastError());
+        return false;
+    }
+    MMKVInfo("open fd[%p], %ws", m_fd, m_path.c_str());
+    return true;
+}
+
+void File::close() {
+    if (isFileValid()) {
+        MMKVInfo("closing fd[%p], %ws", m_fd, m_path.c_str());
+        if (CloseHandle(m_fd)) {
+            m_fd = INVALID_HANDLE_VALUE;
+        } else {
+            MMKVError("fail to close [%ws], %d", m_path.c_str(), GetLastError());
+        }
+    }
+}
+
+size_t File::getActualFileSize() const {
+    size_t size = 0;
+    mmkv::getFileSize(m_fd, size);
+    return size;
+}
+
+MemoryFile::MemoryFile(MMKVPath_t path)
+    : m_diskFile(std::move(path), OpenFlag::ReadWrite | OpenFlag::Create)
+    , m_fileMapping(nullptr)
+    , m_ptr(nullptr)
+    , m_size(0) {
     reloadFromFile();
 }
 
 bool MemoryFile::truncate(size_t size) {
-    if (m_fd < 0) {
+    if (!m_diskFile.isFileValid()) {
         return false;
     }
     if (size == m_size) {
@@ -56,14 +117,14 @@ bool MemoryFile::truncate(size_t size) {
         m_size = ((m_size / DEFAULT_MMAP_SIZE) + 1) * DEFAULT_MMAP_SIZE;
     }
 
-    if (!ftruncate(m_fd, m_size)) {
-        MMKVError("fail to truncate [%ws] to size %zu", m_name.c_str(), m_size);
+    if (!ftruncate(m_diskFile.getFd(), m_size)) {
+        MMKVError("fail to truncate [%ws] to size %zu", m_diskFile.m_path.c_str(), m_size);
         m_size = oldSize;
         return false;
     }
     if (m_size > oldSize) {
-        if (!zeroFillFile(m_fd, oldSize, m_size - oldSize)) {
-            MMKVError("fail to zeroFile [%ws] to size %zu", m_name.c_str(), m_size);
+        if (!zeroFillFile(m_diskFile.getFd(), oldSize, m_size - oldSize)) {
+            MMKVError("fail to zeroFile [%ws] to size %zu", m_diskFile.m_path.c_str(), m_size);
             m_size = oldSize;
             return false;
         }
@@ -71,7 +132,7 @@ bool MemoryFile::truncate(size_t size) {
 
     if (m_ptr) {
         if (!UnmapViewOfFile(m_ptr)) {
-            MMKVError("fail to munmap [%ws], %d", m_name.c_str(), GetLastError());
+            MMKVError("fail to munmap [%ws], %d", m_diskFile.m_path.c_str(), GetLastError());
         }
         m_ptr = nullptr;
     }
@@ -90,28 +151,28 @@ bool MemoryFile::msync(SyncFlag syncFlag) {
     if (m_ptr) {
         if (FlushViewOfFile(m_ptr, m_size)) {
             if (syncFlag == MMKV_SYNC) {
-                if (!FlushFileBuffers(m_fd)) {
-                    MMKVError("fail to FlushFileBuffers [%ws]:%d", m_name.c_str(), GetLastError());
+                if (!FlushFileBuffers(m_diskFile.getFd())) {
+                    MMKVError("fail to FlushFileBuffers [%ws]:%d", m_diskFile.m_path.c_str(), GetLastError());
                     return false;
                 }
             }
             return true;
         }
-        MMKVError("fail to FlushViewOfFile [%ws]:%d", m_name.c_str(), GetLastError());
+        MMKVError("fail to FlushViewOfFile [%ws]:%d", m_diskFile.m_path.c_str(), GetLastError());
         return false;
     }
     return false;
 }
 
 bool MemoryFile::mmap() {
-    m_fileMapping = CreateFileMapping(m_fd, nullptr, PAGE_READWRITE, 0, 0, nullptr);
+    m_fileMapping = CreateFileMapping(m_diskFile.getFd(), nullptr, PAGE_READWRITE, 0, 0, nullptr);
     if (!m_fileMapping) {
-        MMKVError("fail to CreateFileMapping [%ws], %d", m_name.c_str(), GetLastError());
+        MMKVError("fail to CreateFileMapping [%ws], %d", m_diskFile.m_path.c_str(), GetLastError());
         return false;
     } else {
         m_ptr = (char *) MapViewOfFile(m_fileMapping, FILE_MAP_ALL_ACCESS, 0, 0, 0);
         if (!m_ptr) {
-            MMKVError("fail to mmap [%ws], %d", m_name.c_str(), GetLastError());
+            MMKVError("fail to mmap [%ws], %d", m_diskFile.m_path.c_str(), GetLastError());
             return false;
         }
     }
@@ -121,22 +182,17 @@ bool MemoryFile::mmap() {
 
 void MemoryFile::reloadFromFile() {
     if (isFileValid()) {
-        MMKVWarning("calling reloadFromFile while the cache [%ws] is still valid", m_name.c_str());
+        MMKVWarning("calling reloadFromFile while the cache [%ws] is still valid", m_diskFile.m_path.c_str());
         assert(0);
         clearMemoryCache();
     }
-
-    m_fd =
-        CreateFile(m_name.c_str(), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                   nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
-    if (m_fd == INVALID_HANDLE_VALUE) {
-        MMKVError("fail to open:%ws, %d", m_name.c_str(), GetLastError());
-    } else {
-        FileLock fileLock(m_fd);
+    m_diskFile.open();
+    if (m_diskFile.isFileValid()) {
+        FileLock fileLock(m_diskFile.getFd());
         InterProcessLock lock(&fileLock, ExclusiveLockType);
         SCOPED_LOCK(&lock);
 
-        mmkv::getFileSize(m_fd, m_size);
+        mmkv::getFileSize(m_diskFile.getFd(), m_size);
         // round up to (n * pagesize)
         if (m_size < DEFAULT_MMAP_SIZE || (m_size % DEFAULT_MMAP_SIZE != 0)) {
             size_t roundSize = ((m_size / DEFAULT_MMAP_SIZE) + 1) * DEFAULT_MMAP_SIZE;
@@ -159,16 +215,7 @@ void MemoryFile::doCleanMemoryCache(bool forceClean) {
         CloseHandle(m_fileMapping);
         m_fileMapping = nullptr;
     }
-    if (m_fd != INVALID_HANDLE_VALUE) {
-        CloseHandle(m_fd);
-        m_fd = INVALID_HANDLE_VALUE;
-    }
-}
-
-size_t MemoryFile::getActualFileSize() {
-    size_t size = 0;
-    mmkv::getFileSize(m_fd, size);
-    return size;
+    m_diskFile.close();
 }
 
 size_t getPageSize() {
@@ -302,6 +349,170 @@ static bool getFileSize(MMKVFileHandle_t fd, size_t &size) {
     return false;
 }
 
+static pair<MMKVPath_t, MMKVFileHandle_t> createUniqueTempFile(const wchar_t *prefix) {
+    wchar_t lpTempPathBuffer[MAX_PATH];
+    //  Gets the temp path env string (no guarantee it's a valid path).
+    auto dwRetVal = GetTempPath(MAX_PATH, lpTempPathBuffer);
+    if (dwRetVal > MAX_PATH || (dwRetVal == 0)) {
+        MMKVError("GetTempPath failed %d", GetLastError());
+        return {L"", INVALID_HANDLE_VALUE};
+    }
+    //  Generates a temporary file name.
+    wchar_t szTempFileName[MAX_PATH];
+    if (!GetTempFileName(lpTempPathBuffer, prefix, 0, szTempFileName)) {
+        MMKVError("GetTempFileName failed %d", GetLastError());
+        return {L"", INVALID_HANDLE_VALUE};
+    }
+    auto hTempFile = CreateFile(szTempFileName, GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
+    if (hTempFile == INVALID_HANDLE_VALUE) {
+        MMKVError("fail to create unique temp file [%ws], %d", szTempFileName, GetLastError());
+        return {L"", INVALID_HANDLE_VALUE};
+    }
+    MMKVDebug("create unique temp file [%ws] with fd[%p]", szTempFileName, hTempFile);
+    return {MMKVPath_t(szTempFileName), hTempFile};
+}
+
+bool tryAtomicRename(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath) {
+    if (MoveFileEx(srcPath.c_str(), dstPath.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED) == 0) {
+        MMKVError("MoveFileEx [%ws] to [%ws] failed %d", srcPath.c_str(), dstPath.c_str(), GetLastError());
+        return false;
+    }
+    return true;
+}
+
+bool copyFileContent(const MMKVPath_t &srcPath, MMKVFileHandle_t dstFD, bool needTruncate) {
+    if (dstFD == INVALID_HANDLE_VALUE) {
+        return false;
+    }
+    bool ret = false;
+    File srcFile(srcPath, OpenFlag::ReadOnly);
+    if (!srcFile.isFileValid()) {
+        return false;
+    }
+    auto bufferSize = getPageSize();
+    auto buffer = (char *) malloc(bufferSize);
+    if (!buffer) {
+        MMKVError("fail to malloc size %zu, %d(%s)", bufferSize, errno, strerror(errno));
+        goto errorOut;
+    }
+    SetFilePointer(dstFD, 0, 0, FILE_BEGIN);
+
+    // the Win32 platform don't have sendfile()/fcopyfile() equivalent, do it the hard way
+    while (true) {
+        DWORD sizeRead = 0;
+        if (!ReadFile(srcFile.getFd(), buffer, bufferSize, &sizeRead, nullptr)) {
+            MMKVError("fail to read %ws: %d", srcPath.c_str(), GetLastError());
+            goto errorOut;
+        }
+
+        DWORD sizeWrite = 0;
+        if (!WriteFile(dstFD, buffer, sizeRead, &sizeWrite, nullptr)) {
+            MMKVError("fail to write fd [%d], %d", dstFD, GetLastError());
+            goto errorOut;
+        }
+
+        if (sizeRead < bufferSize) {
+            break;
+        }
+    }
+    if (needTruncate) {
+        size_t dstFileSize = 0;
+        getFileSize(dstFD, dstFileSize);
+        auto srcFileSize = srcFile.getActualFileSize();
+        if ((dstFileSize != srcFileSize) && !ftruncate(dstFD, static_cast<off_t>(srcFileSize))) {
+            MMKVError("fail to truncate [%d] to size [%zu]", dstFD, srcFileSize);
+            goto errorOut;
+        }
+    }
+
+    ret = true;
+    MMKVInfo("copy content from %ws to fd[%d] finish", srcPath.c_str(), dstFD);
+
+errorOut:
+    free(buffer);
+    return ret;
+}
+
+// copy to a temp file then rename it
+// this is the best we can do on Win32
+bool copyFile(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath) {
+    auto pair = createUniqueTempFile(L"MMKV");
+    auto tmpFD = pair.second;
+    auto &tmpPath = pair.first;
+    if (tmpFD == INVALID_HANDLE_VALUE) {
+        return false;
+    }
+
+    bool renamed = false;
+    if (copyFileContent(srcPath, tmpFD, false)) {
+        MMKVInfo("copyed file [%ws] to [%ws]", srcPath.c_str(), tmpPath.c_str());
+        CloseHandle(tmpFD);
+        renamed = tryAtomicRename(tmpPath.c_str(), dstPath.c_str());
+        if (renamed) {
+            MMKVInfo("copyfile [%ws] to [%ws] finish.", srcPath.c_str(), dstPath.c_str());
+        }
+    } else {
+        CloseHandle(tmpFD);
+    }
+
+    if (!renamed) {
+        DeleteFile(tmpPath.c_str());
+    }
+    return renamed;
+}
+
+bool copyFileContent(const MMKVPath_t &srcPath, const MMKVPath_t &dstPath) {
+    File dstFile(dstPath, OpenFlag::WriteOnly | OpenFlag::Create | OpenFlag::Truncate);
+    if (!dstFile.isFileValid()) {
+        return false;
+    }
+    auto ret = copyFileContent(srcPath, dstFile.getFd(), false);
+    if (!ret) {
+        MMKVError("fail to copyfile(): target file %ws", dstPath.c_str());
+    } else {
+        MMKVInfo("copy content from %ws to [%ws] finish", srcPath.c_str(), dstPath.c_str());
+    }
+    return ret;
+}
+
+bool copyFileContent(const MMKVPath_t &srcPath, MMKVFileHandle_t dstFD) {
+    return copyFileContent(srcPath, dstFD, true);
+}
+
+void walkInDir(const MMKVPath_t &dirPath,
+               WalkType type,
+               const std::function<void(const MMKVPath_t &, WalkType)> &walker) {
+    wchar_t szDir[MAX_PATH];
+    StringCchCopy(szDir, MAX_PATH, dirPath.c_str());
+    StringCchCat(szDir, MAX_PATH, L"\\*");
+
+    WIN32_FIND_DATA ffd;
+    auto hFind = FindFirstFile(szDir, &ffd);
+    if (hFind == INVALID_HANDLE_VALUE) {
+        return;
+    }
+
+    do {
+        if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+            if (type & WalkFolder) {
+                if (wcscmp(ffd.cFileName, L".") == 0 || wcscmp(ffd.cFileName, L"..") == 0) {
+                    continue;
+                }
+                walker(dirPath + L"\\" + ffd.cFileName, WalkFolder);
+            }
+        } else if (type & WalkFile) {
+            walker(dirPath + L"\\" + ffd.cFileName, WalkFile);
+        }
+    } while (FindNextFile(hFind, &ffd) != 0);
+
+    auto dwError = GetLastError();
+    if (dwError != ERROR_NO_MORE_FILES) {
+        MMKVError("WalkInDir fail %d", dwError);
+    }
+
+    FindClose(hFind);
+}
+
 } // namespace mmkv
 
 std::wstring string2MMKVPath_t(const std::string &str) {
@@ -313,4 +524,13 @@ std::wstring string2MMKVPath_t(const std::string &str) {
     return result;
 }
 
+std::string MMKVPath_t2String(const MMKVPath_t &str) {
+    auto length = WideCharToMultiByte(CP_UTF8, 0, str.c_str(), -1, nullptr, 0, 0, 0);
+    auto buffer = new char[length];
+    WideCharToMultiByte(CP_UTF8, 0, str.c_str(), -1, buffer, length, 0, 0);
+    string result(buffer);
+    delete[] buffer;
+    return result;
+}
+
 #endif // MMKV_WIN32

package/MMKV/Core/aes/openssl/openssl_aes.h

@@ -89,13 +89,13 @@ int AES_C_set_decrypt_key(const uint8_t *userKey, const int bits, void *key);
 void AES_C_encrypt(const uint8_t *in, uint8_t *out, const void *key);
 void AES_C_decrypt(const uint8_t *in, uint8_t *out, const void *key);
 
-} // namespace openssl
-
 extern aes_set_encrypt_t AES_set_encrypt_key;
 extern aes_set_decrypt_t AES_set_decrypt_key;
 extern aes_encrypt_t AES_encrypt;
 extern aes_decrypt_t AES_decrypt;
 
+} // namespace openssl
+
 #endif // __ARM_MAX_ARCH__ <= 7
 
 #endif // __linux__

package/MMKV/Core/aes/openssl/openssl_aes_core.cpp

@@ -43,6 +43,8 @@
 
 #ifndef MMKV_DISABLE_CRYPT
 
+namespace openssl {
+
 #if (__ARM_MAX_ARCH__ > 7) && defined(__linux__)
 
 aes_set_encrypt_t AES_set_encrypt_key = openssl::AES_C_set_encrypt_key;
@@ -54,8 +56,6 @@ aes_encrypt_t AES_decrypt = openssl::AES_C_decrypt;
 
 #if (__ARM_MAX_ARCH__ <= 0) || (__ARM_MAX_ARCH__ > 7 && defined(__linux__))
 
-namespace openssl {
-
 /*-
 Te0[x] = S [x].[02, 01, 01, 03];
 Te1[x] = S [x].[03, 02, 01, 01];
@@ -1037,8 +1037,8 @@ void AES_C_decrypt(const uint8_t *in, uint8_t *out, const void *k) {
     PUTU32(out + 12, s3);
 }
 
-} // namespace openssl
-
 #endif // (__ARM_MAX_ARCH__ < 0) || (__ARM_MAX_ARCH__ > 7 && defined(__linux__))
 
+} // namespace openssl
+
 #endif // MMKV_DISABLE_CRYPT

package/MMKV/README.md

@@ -1,6 +1,6 @@
 [![license](https://img.shields.io/badge/license-BSD_3-brightgreen.svg?style=flat)](https://github.com/Tencent/MMKV/blob/master/LICENSE.TXT)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/Tencent/MMKV/pulls)
-[![Release Version](https://img.shields.io/badge/release-1.2.10-brightgreen.svg)](https://github.com/Tencent/MMKV/releases)
+[![Release Version](https://img.shields.io/badge/release-1.2.12-brightgreen.svg)](https://github.com/Tencent/MMKV/releases)
 [![Platform](https://img.shields.io/badge/Platform-%20Android%20%7C%20iOS%2FmacOS%20%7C%20Win32%20%7C%20POSIX-brightgreen.svg)](https://github.com/Tencent/MMKV/wiki/home)
 
 中文版本请参看[这里](./README_CN.md)
@@ -28,12 +28,12 @@ Add the following lines to `build.gradle` on your app module:
 
 ```gradle
 dependencies {
-    implementation 'com.tencent:mmkv-static:1.2.10'
-    // replace "1.2.10" with any available version
+    implementation 'com.tencent:mmkv:1.2.12'
+    // replace "1.2.12" with any available version
 }
 ```
 
-Starting from v1.2.8, MMKV has been **migrated to Maven Central**. Older versions (<= v1.2.7) are still available on JCenter.  
+Starting from v1.2.8, MMKV has been **migrated to Maven Central**.  
 For other installation options, see [Android Setup](https://github.com/Tencent/MMKV/wiki/android_setup).
 
 ### Quick Tutorial

package/README.md

@@ -33,6 +33,7 @@
 * **~30x faster than AsyncStorage**
 * Uses [**JSI**](https://github.com/react-native-community/discussions-and-proposals/issues/91) instead of the "old" Bridge
 * **iOS**, **Android** and **Web** support
+* Easy to use **React Hooks** API
 
 ## Sponsors
 
@@ -82,7 +83,7 @@ To create a new instance of the MMKV storage, use the `MMKV` constructor. It is
 ```js
 import { MMKV } from 'react-native-mmkv'
 
-const storage = new MMKV()
+export const storage = new MMKV()
 ```
 
 This creates a new storage instance using the default MMKV storage ID (`mmkv.default`).
@@ -92,10 +93,10 @@ This creates a new storage instance using the default MMKV storage ID (`mmkv.def
 ```js
 import { MMKV } from 'react-native-mmkv'
 
-const storage = new MMKV({
+export const storage = new MMKV({
   id: `user-${userId}-storage`,
   path: `${USER_DIRECTORY}/storage`,
-  encryptionKey: 'some-encryption-key'
+  encryptionKey: 'hunter2'
 })
 ```
 
@@ -155,14 +156,26 @@ const jsonUser = storage.getString('user') // { 'username': 'Marc', 'age': 21 }
 const userObject = JSON.parse(jsonUser)
 ```
 
+### Encryption
+
+```js
+// encrypt all data with a private key
+storage.recrypt('hunter2')
+
+// remove encryption
+storage.recrypt(undefined)
+```
+
 ## Documentation
 
 * [Hooks](./docs/HOOKS.md)
 * [Value-change Listeners](./docs/LISTENERS.md)
 * [Migrate from AsyncStorage](./docs/MIGRATE_FROM_ASYNC_STORAGE.md)
-* [Using MMKV with redux-persis](./docs/WRAPPER_REDUX.md)
+* [Using MMKV with redux-persist](./docs/WRAPPER_REDUX.md)
 * [Using MMKV with mobx-persist-storage](./docs/WRAPPER_MOBX.md)
 * [Using MMKV with mobx-persist](./docs/WRAPPER_MOBXPERSIST.md)
+* [Using MMKV with zustand persist-middleware](./docs/WRAPPER_ZUSTAND_PERSIST_MIDDLEWARE.md)
+* [How is this library different from **react-native-mmkv-storage**?](https://github.com/mrousavy/react-native-mmkv/issues/100#issuecomment-886477361)
 
 ## Limitations
 

package/android/CMakeLists.txt

@@ -13,9 +13,10 @@ include_directories(
 )
 
 if(${REACT_NATIVE_VERSION} LESS 66)
-        set (
-                INCLUDE_JSI_CPP
+        file(
+                TO_CMAKE_PATH 
                 "${NODE_MODULES_DIR}/react-native/ReactCommon/jsi/jsi/jsi.cpp"
+                INCLUDE_JSI_CPP
         )
 endif()
 

package/android/src/main/cpp/MmkvHostObject.cpp

@@ -16,7 +16,18 @@ MmkvHostObject::MmkvHostObject(const std::string& instanceId, std::string path,
   std::string* pathPtr = path.size() > 0 ? &path : nullptr;
   std::string* cryptKeyPtr = cryptKey.size() > 0 ? &cryptKey : nullptr;
   instance = MMKV::mmkvWithID(instanceId, mmkv::DEFAULT_MMAP_SIZE, MMKV_SINGLE_PROCESS, cryptKeyPtr, pathPtr);
+
   if (instance == nullptr) {
+    // Check if instanceId is invalid
+    if (instanceId.empty()) {
+      throw std::runtime_error("Failed to create MMKV instance! `id` cannot be empty!");
+    }
+
+    // Check if encryptionKey is invalid
+    if (cryptKey.size() > 16) {
+      throw std::runtime_error("Failed to create MMKV instance! `encryptionKey` cannot be longer than 16 bytes!");
+    }
+
     throw std::runtime_error("Failed to create MMKV instance!");
   }
 }
@@ -31,6 +42,7 @@ std::vector<jsi::PropNameID> MmkvHostObject::getPropertyNames(jsi::Runtime& rt)
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("delete")));
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("getAllKeys")));
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("deleteAll")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("recrypt")));
   return result;
 }
 
@@ -181,9 +193,33 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
                                                         const jsi::Value* arguments,
                                                         size_t count) -> jsi::Value {
                                                    instance->clearAll();
+
                                                    return jsi::Value::undefined();
                                                  });
   }
 
+  if (propName == "recrypt") {
+    // MMKV.recrypt(key)
+    return jsi::Function::createFromHostFunction(runtime,
+                                                 jsi::PropNameID::forAscii(runtime, funcName),
+                                                 0,
+                                                 [this](jsi::Runtime& runtime,
+                                                        const jsi::Value& thisValue,
+                                                        const jsi::Value* arguments,
+                                                        size_t count) -> jsi::Value {
+      if (arguments[0].isUndefined()) {
+        // reset encryption key to "no encryption"
+        instance->reKey(nullptr);
+      } else if (arguments[0].isString()) {
+        // reKey(..) with new encryption-key
+        auto encryptionKey = arguments[0].getString(runtime).utf8(runtime);
+        instance->reKey(encryptionKey);
+      } else {
+        throw jsi::JSError(runtime, "First argument ('encryptionKey') has to be of type string (or undefined)!");
+      }
+      return jsi::Value::undefined();
+    });
+  }
+
   return jsi::Value::undefined();
 }

package/ios/MmkvHostObject.mm

@@ -13,7 +13,25 @@
 MmkvHostObject::MmkvHostObject(NSString* instanceId, NSString* path, NSString* cryptKey) {
   NSData* cryptData = cryptKey == nil ? nil : [cryptKey dataUsingEncoding:NSUTF8StringEncoding];
   instance = [MMKV mmkvWithID:instanceId cryptKey:cryptData rootPath:path];
+
   if (instance == nil) {
+    // Check if instanceId is invalid
+    if ([instanceId length] == 0) {
+      throw std::runtime_error("Failed to create MMKV instance! `id` cannot be empty!");
+    }
+
+    // Check if encryptionKey is invalid
+    if (cryptData != nil && [cryptData length] > 16) {
+      throw std::runtime_error("Failed to create MMKV instance! `encryptionKey` cannot be longer than 16 bytes!");
+    }
+
+    // Check if path is invalid
+    NSFileManager* fileManager = [[NSFileManager alloc] init];
+    bool pathExists = [fileManager fileExistsAtPath:path isDirectory:nil];
+    if (!pathExists) {
+      throw std::runtime_error("Failed to create MMKV instance! The given Storage Path does not exist!");
+    }
+
     throw std::runtime_error("Failed to create MMKV instance!");
   }
 }
@@ -28,6 +46,7 @@ std::vector<jsi::PropNameID> MmkvHostObject::getPropertyNames(jsi::Runtime& rt)
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("delete")));
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("getAllKeys")));
   result.push_back(jsi::PropNameID::forUtf8(rt, std::string("deleteAll")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("recrypt")));
   return result;
 }
 
@@ -73,7 +92,7 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
       if (!arguments[0].isString()) throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
 
       auto keyName = convertJSIStringToNSString(runtime, arguments[0].getString(runtime));
-      auto value = [instance getBoolForKey:keyName];
+      bool value = [instance getBoolForKey:keyName];
       return jsi::Value(value);
     });
   }
@@ -114,7 +133,7 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
       return jsi::Value(value);
     });
   }
-  
+
   if (propName == "contains") {
     // MMKV.contains(key: string)
     return jsi::Function::createFromHostFunction(runtime,
@@ -125,13 +144,13 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
                                                         const jsi::Value* arguments,
                                                         size_t count) -> jsi::Value {
       if (!arguments[0].isString()) throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
-      
+
       auto keyName = convertJSIStringToNSString(runtime, arguments[0].getString(runtime));
       bool containsKey = [instance containsKey:keyName];
       return jsi::Value(containsKey);
     });
   }
-  
+
   if (propName == "delete") {
     // MMKV.delete(key: string)
     return jsi::Function::createFromHostFunction(runtime,
@@ -142,7 +161,7 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
                                                         const jsi::Value* arguments,
                                                         size_t count) -> jsi::Value {
       if (!arguments[0].isString()) throw jsi::JSError(runtime, "First argument ('key') has to be of type string!");
-      
+
       auto keyName = convertJSIStringToNSString(runtime, arguments[0].getString(runtime));
       [instance removeValueForKey:keyName];
       return jsi::Value::undefined();
@@ -177,5 +196,29 @@ jsi::Value MmkvHostObject::get(jsi::Runtime& runtime, const jsi::PropNameID& pro
     });
   }
 
+  if (propName == "recrypt") {
+    // MMKV.recrypt(key)
+    return jsi::Function::createFromHostFunction(runtime,
+                                                 jsi::PropNameID::forAscii(runtime, funcName),
+                                                 0,
+                                                 [this](jsi::Runtime& runtime,
+                                                        const jsi::Value& thisValue,
+                                                        const jsi::Value* arguments,
+                                                        size_t count) -> jsi::Value {
+      if (arguments[0].isUndefined()) {
+        // reset encryption key to "no encryption"
+        [instance reKey:nil];
+      } else if (arguments[0].isString()) {
+        // reKey(..) with new encryption-key
+        NSString* encryptionKey = convertJSIStringToNSString(runtime, arguments[0].getString(runtime));
+        NSData* encryptionKeyBytes = [encryptionKey dataUsingEncoding:NSUTF8StringEncoding];
+        [instance reKey:encryptionKeyBytes];
+      } else {
+        throw jsi::JSError(runtime, "First argument ('encryptionKey') has to be of type string (or undefined)!");
+      }
+      return jsi::Value::undefined();
+    });
+  }
+
   return jsi::Value::undefined();
 }