app: prevent concurrent sqlite3 access

js/app/app.config.ts

···
   return config;
 };
 
+export const withoutNotificationsIOS: ConfigPlugin = (config) => {
+  config = withEntitlementsPlist(config, (config) => {
+    delete config.modResults["aps-environment"];
+    return config;
+  });
+  return config;
+};
+
 const withConsistentVersionNumber = (
   config,
   { version }: { version: string },
···
               "@react-native-firebase/messaging",
               [withNotificationsIOS, {}],
             ]
-          : ["expo-dev-launcher"]),
+          : ["expo-dev-launcher", withoutNotificationsIOS]),
       ],
       experiments: {
         typedRoutes: true,

js/app/storage/lock.tsx

···
+type Cont = () => void;
+
+export class Lock {
+  private readonly queue: Cont[] = [];
+  private acquired = false;
+
+  public async acquire(): Promise<void> {
+    if (!this.acquired) {
+      this.acquired = true;
+    } else {
+      return new Promise<void>((resolve, _) => {
+        this.queue.push(resolve);
+      });
+    }
+  }
+
+  public async release(): Promise<void> {
+    if (this.queue.length === 0 && this.acquired) {
+      this.acquired = false;
+      return;
+    }
+
+    const continuation = this.queue.shift();
+    return new Promise((res: Cont) => {
+      continuation!();
+      res();
+    });
+  }
+
+  public async critical<T>(task: () => Promise<T>) {
+    await this.acquire();
+    try {
+      return await task();
+    } finally {
+      await this.release();
+    }
+  }
+}

js/app/storage/storage.native.tsx

···
 import Storage from "expo-sqlite/kv-store";
 import { AQStorage } from "./storage.shared";
+import { Lock } from "./lock";
+
+// Needed because concurrent calls seem to return with a locked database
+const lock = new Lock();
 
 export default class NativeStorage implements AQStorage {
   async getItem(key: string): Promise<string | null> {
-    const value = await Storage.getItem(key);
-    return value ?? null;
+    return lock.critical(async () => {
+      try {
+        const value = await Storage.getItem(key);
+        return value ?? null;
+      } catch (e) {
+        console.error(`error in NativeStorage.getItem: ${e}`);
+        throw e;
+      }
+    });
   }
 
   async setItem(key: string, value: string): Promise<void> {
-    await Storage.setItem(key, value);
+    return lock.critical(async () => {
+      try {
+        await Storage.setItem(key, value);
+      } catch (e) {
+        console.error(`error in NativeStorage.setItem: ${e}`);
+        throw e;
+      }
+    });
   }
 
   async removeItem(key: string): Promise<void> {
-    await Storage.removeItem(key);
+    return lock.critical(async () => {
+      try {
+        await Storage.removeItem(key);
+      } catch (e) {
+        console.error(`error in NativeStorage.removeItem: ${e}`);
+        throw e;
+      }
+    });
   }
 }