task: add logout support. Remove ktor wrapper.

Author: jwilkinson87

src/main/kotlin/com/ctrlhub/core/Api.kt

@@ -1,16 +1,49 @@
 package com.ctrlhub.core
 
-import com.ctrlhub.core.api.KtorApiClient
 import com.ctrlhub.core.auth.AuthRouter
 import com.ctrlhub.core.iam.IamRouter
+import io.ktor.client.HttpClient
+import io.ktor.client.engine.cio.CIO
+import io.ktor.client.plugins.UserAgent
+import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
+import io.ktor.client.plugins.defaultRequest
+import io.ktor.http.HttpHeaders
+import io.ktor.serialization.kotlinx.json.json
+import io.ktor.util.appendIfNameAbsent
+import kotlinx.serialization.json.Json
 
-class Api private constructor(apiClient: KtorApiClient) {
-    val auth: AuthRouter = AuthRouter(apiClient)
-    val iam: IamRouter = IamRouter(apiClient)
+class Api private constructor(httpClient: HttpClient) {
+    val auth: AuthRouter = AuthRouter(httpClient)
+    val iam: IamRouter = IamRouter(httpClient)
 
     companion object {
         fun create(): Api {
-            return Api(KtorApiClient.create(Config.apiBaseUrl))
+            val httpClient = HttpClient(CIO)
+            return Api(configureHttpClient(httpClient, Config.apiBaseUrl))
+        }
+
+        fun create(httpClient: HttpClient): Api {
+            return Api(configureHttpClient(httpClient, Config.apiBaseUrl))
+        }
+
+        private fun configureHttpClient(baseClient: HttpClient, baseUrl: String? = null): HttpClient {
+            return baseClient.config {
+                baseUrl?.let {
+                    defaultRequest {
+                        url(baseUrl)
+                    }
+                }
+                defaultRequest {
+                    headers.appendIfNameAbsent(HttpHeaders.ContentType, "application/json")
+                }
+                expectSuccess = true
+                install(ContentNegotiation) {
+                    json(Json { ignoreUnknownKeys = true })
+                }
+                install(UserAgent) {
+                    agent = Config.userAgent
+                }
+            }
         }
     }
 }

src/main/kotlin/com/ctrlhub/core/Config.kt

@@ -7,6 +7,7 @@ enum class Environment {
 
 object Config {
     var environment: Environment = Environment.PRODUCTION
+    var userAgent: String = "CtrlHub SDK"
 
     val authBaseUrl: String
         get() = when (environment) {

src/main/kotlin/com/ctrlhub/core/api/KtorApiClient.kt

@@ -3,19 +3,26 @@ package com.ctrlhub.core.auth
 import com.ctrlhub.core.Config
 import com.ctrlhub.core.api.ApiClientException
 import com.ctrlhub.core.api.ApiException
-import com.ctrlhub.core.api.KtorApiClient
 import com.ctrlhub.core.auth.payload.LoginPayload
+import com.ctrlhub.core.auth.payload.LogoutPayload
 import com.ctrlhub.core.auth.response.AuthFlowResponse
 import com.ctrlhub.core.auth.response.CompleteResponse
 import com.ctrlhub.core.router.Router
+import io.ktor.client.HttpClient
 import io.ktor.client.call.*
 import io.ktor.client.plugins.*
+import io.ktor.client.request.delete
+import io.ktor.client.request.get
+import io.ktor.client.request.post
+import io.ktor.client.request.setBody
 import io.ktor.http.*
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
 
-class AuthRouter(apiClient: KtorApiClient) : Router(apiClient = apiClient) {
+class AuthRouter(httpClient: HttpClient) : Router(httpClient = httpClient) {
     suspend fun initiate(): AuthFlowResponse {
         return try {
-            return apiClient.get(url = "${Config.authBaseUrl}/self-service/login/api").body()
+            httpClient.get("${Config.authBaseUrl}/self-service/login/api").body()
         } catch (e: ClientRequestException) {
             throw ApiClientException("Failed to initiate auth", e.response, e)
         } catch (e: Exception) {
@@ -25,7 +32,7 @@ class AuthRouter(apiClient: KtorApiClient) : Router(apiClient = apiClient) {
 
     suspend fun refresh(): AuthFlowResponse {
         return try {
-            return apiClient.get(url = "${Config.authBaseUrl}/self-service/login/api?refresh=true").body()
+            httpClient.get("${Config.authBaseUrl}/self-service/login/api?refresh=true").body()
         } catch (e: ClientRequestException) {
             throw ApiClientException("Failed to initiate auth", e.response, e)
         } catch (e: Exception) {
@@ -35,7 +42,9 @@ class AuthRouter(apiClient: KtorApiClient) : Router(apiClient = apiClient) {
 
     suspend fun complete(flowId: String, payload: LoginPayload): CompleteResponse {
         return try {
-            apiClient.post(url = "${Config.authBaseUrl}/self-service/login?flow=$flowId", body = payload).body()
+            httpClient.post("${Config.authBaseUrl}/self-service/login?flow=$flowId") {
+                setBody(Json.encodeToString(payload))
+            }.body()
         } catch (e: ClientRequestException) {
             if (e.response.status == HttpStatusCode.BadRequest) {
                 val bodyAsString: String = e.response.body()
@@ -49,4 +58,20 @@ class AuthRouter(apiClient: KtorApiClient) : Router(apiClient = apiClient) {
             throw ApiException("Failed to complete auth", e)
         }
     }
+
+    suspend fun logout(sessionToken: String): Boolean {
+        return try {
+            val statusCode = httpClient.delete("${Config.authBaseUrl}/self-service/logout/api") {
+                setBody(Json.encodeToString(LogoutPayload(
+                    sessionToken = sessionToken
+                )))
+            }.status
+
+            statusCode == HttpStatusCode.NoContent
+        } catch (e: ClientRequestException) {
+            false
+        } catch (e: Exception) {
+            throw ApiException("Failed to complete auth", e)
+        }
+    }
 }

src/main/kotlin/com/ctrlhub/core/auth/AuthRouter.kt

@@ -1,10 +1,16 @@
 package com.ctrlhub.core.auth.payload
 
+import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 
 @Serializable
 data class LoginPayload(
     val identifier: String,
     val password: String,
     val method: String
+)
+
+@Serializable
+data class LogoutPayload(
+    @SerialName("session_token") val sessionToken: String
 )

src/main/kotlin/com/ctrlhub/core/auth/payload/AuthPayloads.kt

@@ -1,19 +1,28 @@
 package com.ctrlhub.core.iam
 
+import com.ctrlhub.core.Config
 import com.ctrlhub.core.api.ApiClientException
 import com.ctrlhub.core.api.ApiException
-import com.ctrlhub.core.api.KtorApiClient
 import com.ctrlhub.core.iam.response.User
 import com.ctrlhub.core.router.Router
 import com.github.jasminb.jsonapi.ResourceConverter
+import io.ktor.client.HttpClient
 import io.ktor.client.call.*
 import io.ktor.client.plugins.*
+import io.ktor.client.request.get
+import io.ktor.client.request.header
+import io.ktor.http.headers
 
-class IamRouter(apiClient: KtorApiClient) : Router(apiClient) {
+class IamRouter(httpClient: HttpClient) : Router(httpClient) {
 
     suspend fun whoami(sessionToken: String): User {
         return try {
-            val rawResponse = apiClient.get("/v3/iam/whoami", mapOf("X-Session-Token" to sessionToken))
+            val rawResponse = httpClient.get("${Config.apiBaseUrl}/v3/iam/whoami") {
+                headers {
+                    header("X-Session-Token", sessionToken)
+                }
+            }
+
             val resourceConverter = ResourceConverter(User::class.java)
             val jsonApiResponse = resourceConverter.readDocument<User>(rawResponse.body<ByteArray>(), User::class.java)
 

src/main/kotlin/com/ctrlhub/core/iam/IamRouter.kt

@@ -1,5 +1,5 @@
 package com.ctrlhub.core.router
 
-import com.ctrlhub.core.api.KtorApiClient
+import io.ktor.client.HttpClient
 
-abstract class Router(val apiClient: KtorApiClient)
+abstract class Router(val httpClient: HttpClient)

src/main/kotlin/com/ctrlhub/core/router/Router.kt

@@ -0,0 +1,25 @@
+package com.ctrlhub.core
+
+import io.ktor.client.HttpClient
+import io.ktor.client.plugins.UserAgent
+import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
+import io.ktor.client.plugins.defaultRequest
+import io.ktor.http.HttpHeaders
+import io.ktor.serialization.kotlinx.json.json
+import io.ktor.util.appendIfNameAbsent
+import kotlinx.serialization.json.Json
+
+fun HttpClient.configureForTest(): HttpClient {
+    return this.config {
+        defaultRequest {
+            headers.appendIfNameAbsent(HttpHeaders.ContentType, "application/json")
+        }
+        expectSuccess = true
+        install(ContentNegotiation) {
+            json(Json { ignoreUnknownKeys = true })
+        }
+        install(UserAgent) {
+            agent = Config.userAgent
+        }
+    }
+}