fix(auth-storage): Thread safety

data/persistence/build.gradle.kts

@@ -52,6 +52,7 @@ kotlin {
         val commonMain by getting {
             dependencies {
                 implementation(libs.multiplatform.settings)
+                implementation(libs.kotlinx.coroutines.core)
                 implementation(libs.kotlinx.serialization.json)
                 implementation(libs.io.insert.koin.core)
             }

data/persistence/src/commonMain/kotlin/social/androiddev/common/persistence/localstorage/DodoAuthStorage.kt

@@ -29,5 +29,5 @@ interface DodoAuthStorage {
     /**
      * Get the Access token for @param server
      */
-    fun getAccessToken(server: String): String?
+    suspend fun getAccessToken(server: String): String?
 }

data/persistence/src/commonMain/kotlin/social/androiddev/common/persistence/localstorage/DodoAuthStorageImpl.kt

@@ -12,15 +12,17 @@ package social.androiddev.common.persistence.localstorage
 import com.russhwolf.settings.Settings
 import com.russhwolf.settings.get
 import com.russhwolf.settings.set
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.builtins.ListSerializer
 import kotlinx.serialization.json.Json
 
 internal class DodoAuthStorageImpl(
     private val settings: Settings,
-    private val json: Json
+    private val json: Json,
+    private val lock: Mutex = Mutex()
 ) : DodoAuthStorage {
-
     override var currentDomain: String?
         get() = settings[KEY_DOMAIN_CACHE]
         set(value) {
@@ -31,29 +33,31 @@ internal class DodoAuthStorageImpl(
      * The user can set up multiple accounts on their device. So we
      * key the AccessToken by the unique server/domain
      */
-    private var diskCache: Map<String, AccessToken>
+    private var diskCache: LinkedHashMap<String, AccessToken>
         get() {
             return settings
                 .getStringOrNull(KEY_ACCESS_TOKENS_CACHE)
                 ?.let { str ->
                     json.decodeFromString(ListSerializer(AccessToken.serializer()), str)
-                        .associateBy { it.server }
+                        .associateByTo(linkedMapOf()) { it.server }
                 }
-                ?: mutableMapOf()
+                ?: linkedMapOf()
         }
         set(value) {
             val list = value.map { it.value }
             settings[KEY_ACCESS_TOKENS_CACHE] =
                 json.encodeToString(ListSerializer(AccessToken.serializer()), list)
         }
+    private val memCache: LinkedHashMap<String, AccessToken> by lazy { diskCache }
 
-    private val memCache: MutableMap<String, AccessToken> by lazy { diskCache.toMutableMap() }
-
-    override fun getAccessToken(server: String): String? = memCache[server]?.token
+    override suspend fun getAccessToken(server: String): String? =
+        lock.withLock { memCache[server]?.token }
 
     override suspend fun saveAccessToken(server: String, token: String) {
-        memCache[server] = AccessToken(token = token, server = server)
-        diskCache = memCache
+        lock.withLock {
+            memCache[server] = AccessToken(token = token, server = server)
+            diskCache = memCache
+        }
     }
 
     private companion object {