task: allow custom configuration of Http client

Author: jwilkinson87

build.gradle.kts

@@ -21,6 +21,7 @@ dependencies {
     implementation(libs.ktor.client.cio)
     implementation(libs.ktor.serialization.kotlinx.json)
     implementation(libs.ktor.client.content.negotiation)
+    implementation(libs.ktor.logging.plugin)
     implementation(libs.jetbrains.kotlinx.serialization.json)
     implementation(libs.jsonapi.converter)
 

gradle/libs.versions.toml

@@ -10,6 +10,7 @@ ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
 ktor-client-cio = { module = "io.ktor:ktor-client-cio", version.ref = "ktor" }
 ktor-client-content-negotiation = { module = "io.ktor:ktor-client-content-negotiation", version.ref = "ktor" }
 ktor-serialization-kotlinx-json = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" }
+ktor-logging-plugin = { module = "io.ktor:ktor-client-logging", version.ref = "ktor" }
 ktor-client-mock = { module = "io.ktor:ktor-client-mock", version.ref = "ktor" }
 kotlin-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect", version.ref = "kotlin" }
 jetbrains-kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinSerialization" }

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

@@ -7,9 +7,18 @@ import io.ktor.client.*
  * The facade object through which interaction with the API occurs.
  */
 object Api {
-    var sessionToken: String? = null
+    private var sessionToken: String? = null
+    var httpClient: HttpClient = KtorClientFactory.create()
+    private set
 
-    val httpClient: HttpClient by lazy {
-        KtorClientFactory.create(sessionToken)
+    fun withHttpClientConfig(config: HttpClientConfig<*>.() -> Unit) {
+        httpClient = KtorClientFactory.create(
+            configBlock = config
+        )
+    }
+
+    fun applySessionToken(newSessionToken: String) {
+        sessionToken = newSessionToken
+        httpClient = KtorClientFactory.createWithExistingConfig(httpClient, sessionToken)
     }
 }

src/main/kotlin/com/ctrlhub/core/http/KtorClientFactory.kt

@@ -2,6 +2,7 @@ package com.ctrlhub.core.http
 
 import com.ctrlhub.core.Config
 import io.ktor.client.HttpClient
+import io.ktor.client.HttpClientConfig
 import io.ktor.client.engine.cio.CIO
 import io.ktor.client.plugins.UserAgent
 import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
@@ -10,34 +11,41 @@ import io.ktor.http.HttpHeaders
 import io.ktor.serialization.kotlinx.json.json
 import io.ktor.util.appendIfNameAbsent
 import kotlinx.serialization.json.Json
+import java.util.concurrent.atomic.AtomicReference
 
 /**
  * A wrapper around the Ktor client. This allows default configuration
  * to be applied that is specific to the Ctrl Hub API, but is also flexible
  * in that an existing Ktor client can be passed, and config is applied to that.
  */
 object KtorClientFactory {
-    private lateinit var httpClient: HttpClient
-
-    fun create(sessionToken: String?): HttpClient {
-        if (!this::httpClient.isInitialized) {
-            val httpClient = HttpClient(CIO)
-            this.httpClient = configureHttpClient(httpClient, baseUrl = Config.apiBaseUrl, sessionToken = sessionToken)
-        }
-
-        return this.httpClient
+    // Function to create an HttpClient with configuration and optional session token
+    fun create(
+        httpClient: HttpClient = HttpClient(CIO),
+        sessionToken: String? = null,
+        configBlock: HttpClientConfig<*>.() -> Unit = {}
+    ): HttpClient {
+        return configureHttpClient(httpClient, sessionToken, configBlock)
     }
 
-    fun create(httpClient: HttpClient): HttpClient {
-        this.httpClient = httpClient
-        return configureHttpClient(httpClient, Config.apiBaseUrl)
+    // Function to create a new HttpClient based on an existing HttpClient configuration
+    fun createWithExistingConfig(
+        existingClient: HttpClient,
+        sessionToken: String? = null
+    ): HttpClient {
+        return configureHttpClient(existingClient, sessionToken)  // Reapply session token while retaining existing config
     }
 
-    private fun configureHttpClient(baseClient: HttpClient, baseUrl: String, sessionToken: String? = null): HttpClient {
+    // Function to configure the HttpClient
+    private fun configureHttpClient(
+        baseClient: HttpClient,
+        sessionToken: String? = null,
+        configBlock: HttpClientConfig<*>.() -> Unit = {}
+    ): HttpClient {
         return baseClient.config {
             defaultRequest {
-                url(baseUrl)
-                sessionToken?.let { headers.append("X-Session-Token", it) }
+                url(Config.apiBaseUrl)
+                sessionToken?.let { headers.append("X-Session-Token", it) } // Apply session token if present
                 headers.appendIfNameAbsent(HttpHeaders.ContentType, "application/json")
             }
             expectSuccess = true
@@ -50,6 +58,7 @@ object KtorClientFactory {
             install(UserAgent) {
                 agent = Config.userAgent
             }
+            configBlock()  // Apply additional user-defined config
         }
     }
 }

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

@@ -21,9 +21,12 @@ abstract class Router(protected val httpClient: HttpClient) {
         }
     }
 
-    protected suspend inline fun <reified T> performPost(endpoint: String, body: T): HttpResponse {
+    protected suspend inline fun <reified T> performPost(endpoint: String, body: T, queryString: Map<String, String> = emptyMap()): HttpResponse {
         return httpClient.post(endpoint) {
             contentType(ContentType.Application.Json)
+            url {
+                queryString.forEach { key, value -> parameters.append(key, value) }
+            }
             setBody(body)
         }
     }