chore: Migrate AsyncStorage to mmkv

android/gradle.properties

@@ -48,4 +48,5 @@ hermesEnabled=true
 # TODO: explain following config options
 android.disableResourceValidation=true
 android.enableDexingArtifactTransform.desugaring=false
+# will be able to get rid of this after migration to mmkv (from AsyncStorage)
 AsyncStorage_db_size_in_MB=10

app/core/Authentication/Authentication.test.ts

@@ -1,4 +1,4 @@
-import AsyncStorage from '@react-native-async-storage/async-storage';
+import AsyncStorage from '../../store/async-storage-wrapper';
 import {
   BIOMETRY_CHOICE_DISABLED,
   TRUE,
@@ -27,7 +27,7 @@ describe('Authentication', () => {
   });
 
   afterEach(() => {
-    AsyncStorage.clear();
+    AsyncStorage.clearAll();
     jest.restoreAllMocks();
   });
 

app/store/async-storage-wrapper.js

@@ -1,34 +1,49 @@
 import ReadOnlyNetworkStore from '../util/test/network-store';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import { isE2E } from '../util/test/utils';
+import { MMKV } from 'react-native-mmkv';
 
 /**
  * Wrapper class for AsyncStorage.
+ * (Will want to eventuall re-name since no longer async once migratted to mmkv)
  */
 class AsyncStorageWrapper {
   constructor() {
     /**
      * The underlying storage implementation.
      * Use `ReadOnlyNetworkStore` in test mode otherwise use `AsyncStorage`.
      */
-    this.storage = isE2E ? ReadOnlyNetworkStore : AsyncStorage;
+    this.storage = isE2E ? ReadOnlyNetworkStore : new MMKV();
   }
 
   async getItem(key) {
     try {
-      return await this.storage.getItem(key);
+      // asyncStorage returns null for no value
+      // mmkv returns undefined for no value
+      // therefore must return null if no value is found
+      // to keep app behavior consistent
+      let value = (await this.storage.getString(key)) || null;
+      if (!value) {
+        const asyncStorageValue = await AsyncStorage.getItem(key);
+        if (asyncStorageValue) {
+          value = asyncStorageValue;
+          this.storage.set(key, value);
+        }
+      }
+      return value;
     } catch (error) {
       if (isE2E) {
         // Fall back to AsyncStorage in test mode if ReadOnlyNetworkStore fails
-        return AsyncStorage.getItem(key);
+        return await AsyncStorage.getItem(key);
       }
       throw error;
     }
   }
 
   async setItem(key, value) {
     try {
-      return await this.storage.setItem(key, value);
+      const response = await this.storage.set(key, value);
+      return response;
     } catch (error) {
       if (isE2E) {
         // Fall back to AsyncStorage in test mode if ReadOnlyNetworkStore fails
@@ -40,7 +55,8 @@ class AsyncStorageWrapper {
 
   async removeItem(key) {
     try {
-      return await this.storage.removeItem(key);
+      const response = await this.storage.delete(key);
+      return response;
     } catch (error) {
       if (isE2E) {
         // Fall back to AsyncStorage in test mode if ReadOnlyNetworkStore fails
@@ -49,6 +65,10 @@ class AsyncStorageWrapper {
       throw error;
     }
   }
+
+  async clearAll() {
+    await this.storage.clearAll();
+  }
 }
 
 export default new AsyncStorageWrapper();

app/store/migrations/049.test.ts

@@ -0,0 +1,31 @@
+import migrate, { storage as mmkvStorage } from './049';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+const asyncStorageItems: { [key: string]: string } = {
+  valueA: 'a',
+  valueB: 'true',
+  valueC: 'myValue',
+};
+
+describe('Migration #49', () => {
+  it('migrates asyncStorage values to mmkv ', async () => {
+    // set asyncStorageItems to AsyncStorage
+    for (const key in asyncStorageItems) {
+      await AsyncStorage.setItem(key, asyncStorageItems[key]);
+    }
+
+    await migrate({});
+
+    // make sure all AsyncStorage items are removed
+    const keys = await AsyncStorage.getAllKeys();
+    // loop through all AsyncStorage keys and make sure empty
+    for (const key of keys) {
+      expect(await AsyncStorage.getItem(key)).toBeNull();
+    }
+
+    // now check that all MMKV values match original AsyncStorage values
+    for (const key in asyncStorageItems) {
+      expect(mmkvStorage.getString(key)).toEqual(asyncStorageItems[key]);
+    }
+  });
+});

app/store/migrations/049.ts

@@ -0,0 +1,32 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { MMKV } from 'react-native-mmkv';
+
+export const storage = new MMKV();
+
+export const hasMigratedFromAsyncStorage = storage.getString(
+  'hasMigratedFromAsyncStorage',
+);
+
+export default async function migrate(state: unknown) {
+  const keys = await AsyncStorage.getAllKeys();
+  for (const key of keys) {
+    try {
+      const value = await AsyncStorage.getItem(key);
+
+      if (value != null) {
+        storage.set(key, value);
+      }
+      await AsyncStorage.removeItem(key);
+    } catch (error) {
+      console.error(
+        `Failed to migrate key "${key}" from AsyncStorage to MMKV!`,
+        error,
+      );
+      throw error;
+    }
+  }
+
+  storage.set('hasMigratedFromAsyncStorage', 'true');
+
+  return state;
+}

app/store/migrations/index.ts

@@ -49,6 +49,7 @@ import migration45 from './045';
 import migration46 from './046';
 import migration47 from './047';
 import migration48 from './048';
+import migration49 from './049';
 
 type MigrationFunction = (state: unknown) => unknown;
 type AsyncMigrationFunction = (state: unknown) => Promise<unknown>;
@@ -110,6 +111,7 @@ export const migrationList: MigrationsList = {
   46: migration46,
   47: migration47,
   48: migration48,
+  49: migration49,
 };
 
 // Enable both synchronous and asynchronous migrations

app/util/test/network-store.js

@@ -46,18 +46,18 @@ class ReadOnlyNetworkStore {
   }
 
   // Async Storage
-  async getItem(key) {
+  async getString(key) {
     await this._initIfRequired();
     const value = this._asyncState[key];
     return value !== undefined ? value : null;
   }
 
-  async setItem(key, value) {
+  async set(key, value) {
     await this._initIfRequired();
     this._asyncState[key] = value;
   }
 
-  async removeItem(key) {
+  async delete(key) {
     await this._initIfRequired();
     delete this._asyncState[key];
   }