full reborn

features/auth/client/build.gradle

@@ -0,0 +1,18 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+}
+
+apply from: "$mppProjectWithSerializationPresetPath"
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api project(":postssystem.features.common.client")
+                api project(":postssystem.features.auth.common")
+            }
+        }
+    }
+}

features/auth/client/src/commonMain/kotlin/dev/inmo/postssystem/features/auth/client/ClientAuthFeature.kt

@@ -0,0 +1,55 @@
+package dev.inmo.postssystem.features.auth.client
+
+import dev.inmo.postssystem.features.auth.common.*
+import dev.inmo.postssystem.features.users.common.User
+import dev.inmo.micro_utils.ktor.client.UnifiedRequester
+import dev.inmo.micro_utils.ktor.common.buildStandardUrl
+import io.ktor.client.HttpClient
+import io.ktor.client.request.HttpRequestBuilder
+import kotlinx.serialization.builtins.nullable
+
+class ClientAuthFeature(
+    private val requester: UnifiedRequester,
+    baseUrl: String
+) : AuthFeature {
+    private val rootUrl = buildStandardUrl(baseUrl.dropLastWhile { it == '/' }, authRootPathPart)
+    private val fullAuthPath = buildStandardUrl(
+        rootUrl,
+        authAuthPathPart
+    )
+    private val fullRefreshPath = buildStandardUrl(
+        rootUrl,
+        authRefreshPathPart
+    )
+    private val fullGetMePath = buildStandardUrl(
+        rootUrl,
+        authGetMePathPart
+    )
+
+    constructor(client: HttpClient, rootUrl: String): this(
+        UnifiedRequester(client),
+        rootUrl
+    )
+
+    override suspend fun auth(creds: AuthCreds): AuthTokenInfo? = requester.unipost(
+        fullAuthPath,
+        AuthCreds.serializer() to creds,
+        AuthTokenInfo.serializer().nullable
+    )
+
+    override suspend fun refresh(refresh: RefreshToken): AuthTokenInfo? = requester.unipost(
+        fullRefreshPath,
+        RefreshToken.serializer() to refresh,
+        AuthTokenInfo.serializer().nullable
+    )
+
+    override suspend fun getMe(authToken: AuthToken): User? = requester.unipost(
+        fullGetMePath,
+        AuthToken.serializer() to authToken,
+        User.serializer().nullable
+    )
+
+    fun isAuthRequest(builder: HttpRequestBuilder): Boolean = builder.url.buildString().let {
+        it == fullAuthPath || it == fullRefreshPath
+    }
+}

features/auth/client/src/commonMain/kotlin/dev/inmo/postssystem/features/auth/client/ClientCookiesConfigurator.kt

@@ -0,0 +1,112 @@
+package dev.inmo.postssystem.features.auth.client
+
+import dev.inmo.postssystem.features.auth.common.*
+import dev.inmo.postssystem.features.users.common.User
+import dev.inmo.micro_utils.common.*
+import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
+import io.ktor.client.HttpClientConfig
+import io.ktor.client.features.cookies.*
+import io.ktor.client.features.expectSuccess
+import io.ktor.client.request.*
+import io.ktor.client.statement.HttpReceivePipeline
+import io.ktor.client.statement.HttpResponse
+import io.ktor.http.*
+import kotlinx.coroutines.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+object AuthUnavailableException : Exception()
+
+fun HttpClientConfig<*>.installClientAuthenticator(
+    baseUrl: String,
+    scope: CoroutineScope,
+    initialAuthKey: Either<AuthKey, AuthTokenInfo>,
+    onAuthKeyUpdated: suspend (AuthTokenInfo) -> Unit,
+    onUserRetrieved: suspend (User?) -> Unit,
+    onAuthKeyInvalidated: suspend () -> Unit
+) {
+//    install(Logging) {
+//        logger = Logger.DEFAULT
+//        level = LogLevel.HEADERS
+//    }
+    install(HttpCookies) {
+        // Will keep an in-memory map with all the cookies from previous requests.
+        storage = AcceptAllCookiesStorage()
+    }
+
+    val authMutex = Mutex()
+    var currentRefreshToken: RefreshToken? = null
+    initialAuthKey.onFirst {
+        currentRefreshToken = it as? RefreshToken
+    }.onSecond {
+        currentRefreshToken = it.refresh
+    }
+    val creds = initialAuthKey.t1 as? AuthCreds
+    var userRefreshJob: Job? = null
+
+    install("Auth Token Refresher") {
+        val clientAuthFeature = ClientAuthFeature(this, baseUrl)
+        fun refreshUser(newTokenInfo: AuthTokenInfo) {
+            userRefreshJob ?.cancel()
+            userRefreshJob = scope.launchSafelyWithoutExceptions {
+                onUserRetrieved(clientAuthFeature.getMe(newTokenInfo.token))
+            }
+        }
+        initialAuthKey.onSecond { refreshUser(it) }
+
+        suspend fun refreshToken() {
+            val capturedRefresh = currentRefreshToken
+
+            runCatching {
+                when {
+                    capturedRefresh == null && creds == null -> throw AuthUnavailableException
+                    capturedRefresh != null -> {
+                        currentRefreshToken = null
+                        val newTokenInfo = clientAuthFeature.refresh(capturedRefresh)
+                        currentRefreshToken = newTokenInfo ?.refresh
+                        if (newTokenInfo == null) {
+                            refreshToken()
+                        } else {
+                            onAuthKeyUpdated(newTokenInfo)
+                            refreshUser(newTokenInfo)
+                        }
+                    }
+                    creds != null -> {
+                        val newAuthTokenInfo = clientAuthFeature.auth(creds)
+
+                        if (newAuthTokenInfo != null) {
+                            onAuthKeyUpdated(newAuthTokenInfo)
+                            refreshUser(newAuthTokenInfo)
+                            currentRefreshToken = newAuthTokenInfo.refresh
+                        }
+                    }
+                }
+            }.onFailure {
+                onAuthKeyInvalidated()
+            }
+        }
+
+        sendPipeline.intercept(HttpSendPipeline.State) {
+            if (!context.url.buildString().startsWith(baseUrl) || clientAuthFeature.isAuthRequest(context)) {
+                return@intercept
+            }
+            context.expectSuccess = false
+            if (authMutex.isLocked) {
+                authMutex.withLock { /* do nothing, just wait while mutex will be freed */ }
+            }
+        }
+
+        receivePipeline.intercept(HttpReceivePipeline.Before) {
+            if (
+                context.request.url.toString().startsWith(baseUrl)
+                && context.response.status == HttpStatusCode.Unauthorized
+            ) {
+                authMutex.withLock { refreshToken() }
+                val newResponse = context.client ?.request<HttpResponse>{
+                    takeFrom(context.request)
+                } ?: return@intercept
+                proceedWith(newResponse)
+            }
+        }
+    }
+}

features/auth/client/src/commonMain/kotlin/dev/inmo/postssystem/features/auth/client/ui/AuthUIModel.kt

@@ -0,0 +1,8 @@
+package dev.inmo.postssystem.features.auth.client.ui
+
+import dev.inmo.postssystem.features.auth.common.AuthCreds
+import dev.inmo.postssystem.features.common.common.UIModel
+
+interface AuthUIModel : UIModel<AuthUIState> {
+    suspend fun initAuth(serverUrl: String, creds: AuthCreds)
+}

features/auth/client/src/commonMain/kotlin/dev/inmo/postssystem/features/auth/client/ui/AuthUIState.kt

@@ -0,0 +1,20 @@
+package dev.inmo.postssystem.features.auth.client.ui
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+sealed class AuthUIError
+@Serializable
+object ServerUnavailableAuthUIError : AuthUIError()
+@Serializable
+object AuthIncorrectAuthUIError : AuthUIError()
+
+@Serializable
+sealed class AuthUIState
+@Serializable
+data class InitAuthUIState(val showError: AuthUIError? = null) : AuthUIState()
+val DefaultInitAuthUIState = InitAuthUIState()
+@Serializable
+object LoadingAuthUIState : AuthUIState()
+@Serializable
+object AuthorizedAuthUIState : AuthUIState()

features/auth/client/src/commonMain/kotlin/dev/inmo/postssystem/features/auth/client/ui/AuthUIViewModel.kt

@@ -0,0 +1,34 @@
+package dev.inmo.postssystem.features.auth.client.ui
+
+import dev.inmo.postssystem.features.auth.common.AuthCreds
+import dev.inmo.postssystem.features.common.common.UIViewModel
+import dev.inmo.postssystem.features.users.common.Username
+import kotlinx.coroutines.flow.StateFlow
+
+class AuthUIViewModel(
+    private val model: AuthUIModel
+) : UIViewModel<AuthUIState> {
+    override val currentState: StateFlow<AuthUIState>
+        get() = model.currentState
+
+    private fun checkIncomingData(
+        serverUrl: String,
+        username: String,
+        password: String
+    ): Boolean {
+        return serverUrl.isNotBlank() && username.isNotBlank() && password.isNotBlank()
+    }
+
+    suspend fun initAuth(
+        serverUrl: String,
+        username: String,
+        password: String
+    ) {
+        if (checkIncomingData(serverUrl, username, password)) {
+            model.initAuth(
+                serverUrl.takeIf { it.startsWith("http") } ?: "http://$serverUrl",
+                AuthCreds(Username(username), password)
+            )
+        }
+    }
+}

features/auth/client/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="dev.inmo.postssystem.features.auth.client"/>