Use URLBuilder instead of Url in mappers and HttpFetcher

README.md

@@ -337,7 +337,7 @@ The underlying disk cache is based on coil's multiplatform `DiskLruCache` implem
 
 ```kotlin
 KamelConfig {
-    httpFetcher {
+    httpUrlFetcher {
         // The size of the cache can be defined in bytes. Or DefaultHttpCacheSize (10 MiB) can be used. 
         httpCache(DefaultHttpCacheSize)
     }

kamel-core/src/appleMain/kotlin/io/kamel/core/fetcher/FileUrlFetcher.kt

@@ -10,17 +10,17 @@ import kotlinx.coroutines.flow.Flow
 import kotlin.reflect.KClass
 
 /**
- * Fetcher that fetches [ByteReadChannel] from the localhost using [Url].
+ * Fetcher that fetches [ByteReadChannel] from the localhost using [URLBuilder].
  */
-internal actual val FileUrlFetcher = object : Fetcher<Url> {
-    override val inputDataKClass: KClass<Url> = Url::class
+internal actual val FileUrlFetcher = object : Fetcher<URLBuilder> {
+    override val inputDataKClass: KClass<URLBuilder> = URLBuilder::class
 
     override val source: DataSource = DataSource.Disk
 
-    override val Url.isSupported: Boolean
+    override val URLBuilder.isSupported: Boolean
         get() = protocol.name == "file"
 
-    override fun fetch(data: Url, resourceConfig: ResourceConfig): Flow<Resource<ByteReadChannel>> {
+    override fun fetch(data: URLBuilder, resourceConfig: ResourceConfig): Flow<Resource<ByteReadChannel>> {
         return FileFetcher.fetch(File(data.encodedPath), resourceConfig)
     }
-}
+}

kamel-core/src/appleMain/kotlin/io/kamel/core/mapper/Mappers.kt

@@ -5,21 +5,21 @@ import io.kamel.core.utils.URL
 import io.ktor.http.*
 import kotlin.reflect.KClass
 
-internal actual val URLMapper: Mapper<URL, Url> = object : Mapper<URL, Url> {
+internal actual val URLMapper: Mapper<URL, URLBuilder> = object : Mapper<URL, URLBuilder> {
     override val inputKClass: KClass<URL>
         get() = URL::class
-    override val outputKClass: KClass<Url>
-        get() = Url::class
+    override val outputKClass: KClass<URLBuilder>
+        get() = URLBuilder::class
 
-    override fun map(input: URL): Url = StringMapper.map(input.absoluteString()!!)
+    override fun map(input: URL): URLBuilder = StringMapper.map(input.absoluteString()!!)
 }
 
 
-internal actual val URIMapper: Mapper<URI, Url> = object : Mapper<URI, Url> {
+internal actual val URIMapper: Mapper<URI, URLBuilder> = object : Mapper<URI, URLBuilder> {
     override val inputKClass: KClass<URI>
         get() = URI::class
-    override val outputKClass: KClass<Url>
-        get() = Url::class
+    override val outputKClass: KClass<URLBuilder>
+        get() = URLBuilder::class
 
-    override fun map(input: URI): Url = StringMapper.map(input.str)
+    override fun map(input: URI): URLBuilder = StringMapper.map(input.str)
 }

kamel-core/src/commonJvmMain/kotlin/io/kamel/core/fetcher/FileUrlFetcher.commonJvm.kt

@@ -10,17 +10,17 @@ import java.io.File
 import kotlin.reflect.KClass
 
 /**
- * Fetcher that fetches [ByteReadChannel] from the localhost using [Url].
+ * Fetcher that fetches [ByteReadChannel] from the localhost using [URLBuilder].
  */
-internal actual val FileUrlFetcher = object : Fetcher<Url> {
-    override val inputDataKClass: KClass<Url> = Url::class
+internal actual val FileUrlFetcher = object : Fetcher<URLBuilder> {
+    override val inputDataKClass: KClass<URLBuilder> = URLBuilder::class
 
     override val source: DataSource = DataSource.Disk
 
-    override val Url.isSupported: Boolean
+    override val URLBuilder.isSupported: Boolean
         get() = protocol.name == "file"
 
-    override fun fetch(data: Url, resourceConfig: ResourceConfig): Flow<Resource<ByteReadChannel>> {
-        return FileFetcher.fetch(File(data.toURI()), resourceConfig)
+    override fun fetch(data: URLBuilder, resourceConfig: ResourceConfig): Flow<Resource<ByteReadChannel>> {
+        return FileFetcher.fetch(File(data.build().toURI()), resourceConfig)
     }
-}
+}

kamel-core/src/commonJvmMain/kotlin/io/kamel/core/mapper/JvmMappers.kt

@@ -5,20 +5,20 @@ import io.kamel.core.utils.URL
 import io.ktor.http.*
 import kotlin.reflect.KClass
 
-internal actual val URLMapper: Mapper<URL, Url> = object : Mapper<URL, Url> {
+internal actual val URLMapper: Mapper<URL, URLBuilder> = object : Mapper<URL, URLBuilder> {
     override val inputKClass: KClass<URL>
         get() = URL::class
-    override val outputKClass: KClass<Url>
-        get() = Url::class
+    override val outputKClass: KClass<URLBuilder>
+        get() = URLBuilder::class
 
-    override fun map(input: URL): Url = Url(input.toURI())
+    override fun map(input: URL): URLBuilder = URLBuilder().takeFrom(input)
 }
 
-internal actual val URIMapper: Mapper<URI, Url> = object : Mapper<URI, Url> {
+internal actual val URIMapper: Mapper<URI, URLBuilder> = object : Mapper<URI, URLBuilder> {
     override val inputKClass: KClass<URI>
         get() = URI::class
-    override val outputKClass: KClass<Url>
-        get() = Url::class
+    override val outputKClass: KClass<URLBuilder>
+        get() = URLBuilder::class
 
-    override fun map(input: URI): Url = Url(input)
+    override fun map(input: URI): URLBuilder = URLBuilder().takeFrom(input)
 }

kamel-core/src/commonMain/kotlin/io/kamel/core/config/KamelConfigBuilder.kt

@@ -76,7 +76,7 @@ public class KamelConfigBuilder {
 }
 
 /**
- * Adds a Http [Url] fetcher to the [KamelConfigBuilder] using the specified [client].
+ * Adds a Http [URLBuilder] fetcher to the [KamelConfigBuilder] using the specified [client].
  */
 public fun KamelConfigBuilder.httpUrlFetcher(client: HttpClient): Unit = fetcher(HttpUrlFetcher(client))
 
@@ -87,7 +87,7 @@ public fun KamelConfigBuilder.httpUrlFetcher(client: HttpClient): Unit = fetcher
 public fun KamelConfigBuilder.httpFetcher(client: HttpClient): Unit = fetcher(HttpUrlFetcher(client))
 
 /**
- * Adds a Http [Url] fetcher to the [KamelConfigBuilder] using the specified [engine]
+ * Adds a Http [URLBuilder] fetcher to the [KamelConfigBuilder] using the specified [engine]
  * and an optional [block] for configuring this client.
  */
 public fun KamelConfigBuilder.httpUrlFetcher(
@@ -96,15 +96,15 @@ public fun KamelConfigBuilder.httpUrlFetcher(
 ): Unit = fetcher(HttpUrlFetcher(HttpClient(engine, block)))
 
 /**
- * Adds a Http [Url] fetcher to the [KamelConfigBuilder] by loading an [HttpClientEngine] from [ServiceLoader]
+ * Adds a Http [URLBuilder] fetcher to the [KamelConfigBuilder] by loading an [HttpClientEngine] from [ServiceLoader]
  * and an optional [block] for configuring this client.
  */
 public fun KamelConfigBuilder.httpUrlFetcher(
     block: HttpClientConfig<*>.() -> Unit = {}
 ): Unit = fetcher(HttpUrlFetcher(HttpClient(block)))
 
 /**
- * Adds a Localhost [Url] fetcher to the [KamelConfigBuilder].
+ * Adds a Localhost [URLBuilder] fetcher to the [KamelConfigBuilder].
  */
 public fun KamelConfigBuilder.fileUrlFetcher(): Unit = fetcher(FileUrlFetcher)
 
@@ -114,17 +114,17 @@ public fun KamelConfigBuilder.fileUrlFetcher(): Unit = fetcher(FileUrlFetcher)
 public fun KamelConfigBuilder.fileFetcher(): Unit = fetcher(FileFetcher)
 
 /**
- * Adds a [String] to [Url] mapper to the [KamelConfigBuilder].
+ * Adds a [String] to [URLBuilder] mapper to the [KamelConfigBuilder].
  */
 public fun KamelConfigBuilder.stringMapper(): Unit = mapper(StringMapper)
 
 /**
- * Adds a [URI] to [Url] mapper to the [KamelConfigBuilder].
+ * Adds a [URI] to [URLBuilder] mapper to the [KamelConfigBuilder].
  */
 public fun KamelConfigBuilder.uriMapper(): Unit = mapper(URIMapper)
 
 /**
- * Adds a [URL] to [Url] mapper to the [KamelConfigBuilder].
+ * Adds a [URL] to [URLBuilder] mapper to the [KamelConfigBuilder].
  */
 public fun KamelConfigBuilder.urlMapper(): Unit = mapper(URLMapper)
 
@@ -147,4 +147,4 @@ public fun KamelConfigBuilder.takeFrom(config: KamelConfig): KamelConfigBuilder
     config.mappers.values.flatten().forEach { mapper(it) }
 
     return this
-}
+}

kamel-core/src/commonMain/kotlin/io/kamel/core/fetcher/FileUrlFetcher.kt

@@ -4,6 +4,6 @@ import io.ktor.http.*
 import io.ktor.utils.io.*
 
 /**
- * Fetcher that fetches [ByteReadChannel] from the localhost using [Url].
+ * Fetcher that fetches [ByteReadChannel] from the localhost using [URLBuilder].
  */
-internal expect val FileUrlFetcher: Fetcher<Url>
+internal expect val FileUrlFetcher: Fetcher<URLBuilder>

kamel-core/src/commonMain/kotlin/io/kamel/core/fetcher/HttpFetcher.kt → kamel-core/src/commonMain/kotlin/io/kamel/core/fetcher/HttpUrlFetcher.kt

@@ -14,19 +14,20 @@ import kotlinx.coroutines.flow.channelFlow
 import kotlin.reflect.KClass
 
 /**
- * Fetcher that fetches [ByteReadChannel] from network using [Url].
+ * Fetcher that fetches [ByteReadChannel] from network using [URLBuilder].
  */
-internal class HttpUrlFetcher(private val client: HttpClient) : Fetcher<Url> {
+internal class HttpUrlFetcher(private val client: HttpClient) : Fetcher<URLBuilder> {
 
-    override val inputDataKClass: KClass<Url> = Url::class
+    override val inputDataKClass: KClass<URLBuilder> = URLBuilder::class
 
     override val source: DataSource = DataSource.Network
 
-    override val Url.isSupported: Boolean
+    override val URLBuilder.isSupported: Boolean
         get() = protocol.name == "https" || protocol.name == "http"
 
     override fun fetch(
-        data: Url, resourceConfig: ResourceConfig
+        data: URLBuilder,
+        resourceConfig: ResourceConfig
     ): Flow<Resource<ByteReadChannel>> = channelFlow {
         val response = client.request {
             onDownload { bytesSentTotal, contentLength ->
@@ -36,10 +37,10 @@ internal class HttpUrlFetcher(private val client: HttpClient) : Fetcher<Url> {
                 if (progress != null) send(Resource.Loading(progress, source))
             }
             takeFrom(resourceConfig.requestData)
-            url(data)
+            url.takeFrom(data)
         }
         val bytes = response.bodyAsChannel()
         send(Resource.Success(bytes, source))
     }
 
-}
+}

kamel-core/src/commonMain/kotlin/io/kamel/core/mapper/Mappers.kt

@@ -5,26 +5,26 @@ import io.kamel.core.utils.URL
 import io.ktor.http.*
 import kotlin.reflect.KClass
 
-internal val StringMapper: Mapper<String, Url> = object : Mapper<String, Url> {
+internal val StringMapper: Mapper<String, URLBuilder> = object : Mapper<String, URLBuilder> {
     override val inputKClass: KClass<String>
         get() = String::class
-    override val outputKClass: KClass<Url>
-        get() = Url::class
+    override val outputKClass: KClass<URLBuilder>
+        get() = URLBuilder::class
 
-    override fun map(input: String): Url {
+    override fun map(input: String): URLBuilder {
         val regex = Regex("^file:/+(?!/)")
         return if (regex.containsMatchIn(input)) {
             // Replace 'file:/' or `file:///` with 'file:///' using regex
             // https://youtrack.jetbrains.com/issue/KTOR-6709
-            Url(input.replaceFirst(regex, "file:///"))
+            URLBuilder(input.replaceFirst(regex, "file:///"))
         } else {
             // If input does not match regex and does not start with '/', use it as is
-            Url(input)
+            URLBuilder(input)
         }
     }
 
 }
 
-internal expect val URLMapper: Mapper<URL, Url>
+internal expect val URLMapper: Mapper<URL, URLBuilder>
 
-internal expect val URIMapper: Mapper<URI, Url>
+internal expect val URIMapper: Mapper<URI, URLBuilder>

kamel-core/src/commonTest/kotlin/io/kamel/core/config/DefaultRequestConfigTest.kt

@@ -0,0 +1,43 @@
+package io.kamel.core.config
+
+import io.kamel.core.fetcher.HttpUrlFetcher
+import io.kamel.core.loadImageBitmapResource
+import io.ktor.client.*
+import io.ktor.client.engine.mock.*
+import io.ktor.client.plugins.*
+import io.ktor.http.*
+import kotlinx.coroutines.flow.toList
+import kotlinx.coroutines.test.runTest
+import kotlin.coroutines.EmptyCoroutineContext
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class DefaultRequestConfigTest {
+
+    @Test
+    fun testDefaultRequestWithURLBuilder() = runTest {
+        var url = ""
+        KamelConfig {
+            stringMapper()
+            fakeImageBitmapDecoder()
+            fetcher(
+                HttpUrlFetcher(
+                    HttpClient(
+                        MockEngine { request ->
+                            url = request.url.toString()
+                            respondError(HttpStatusCode.NotFound)
+                        }
+                    ) {
+                        defaultRequest {
+                            url("https://kamel.media")
+                        }
+                    })
+            )
+        }.loadImageBitmapResource(
+            data = URLBuilder("image.jpg"),
+            resourceConfig = ResourceConfigBuilder(EmptyCoroutineContext).build()
+        ).toList()
+        assertEquals("https://kamel.media/image.jpg", url)
+    }
+
+}

kamel-core/src/commonTest/kotlin/io/kamel/core/config/KamelConfigUtilsTest.kt

@@ -30,21 +30,21 @@ class KamelConfigUtilsTest {
     fun testMapStringInput() {
         val result = config.mapInput(TestStringUrl, String::class)
 
-        assertTrue(result is Url)
+        assertTrue(result is URLBuilder)
     }
 
     @Test
     fun testMapURLInput() {
         val result = config.mapInput(createURL(TestStringUrl), URL::class)
 
-        assertTrue(result is Url)
+        assertTrue(result is URLBuilder)
     }
 
     @Test
     fun testMapURIInput() {
         val result = config.mapInput(createURI(TestStringUrl), URI::class)
 
-        assertTrue(result is Url)
+        assertTrue(result is URLBuilder)
     }
 
     @Test
@@ -60,12 +60,12 @@ class KamelConfigUtilsTest {
             stringMapper()
         }
         val result = twoMappersConfig.mapInput(TestStringUrl, String::class)
-        assertTrue(result is Url)
+        assertTrue(result is URLBuilder)
     }
 
     @Test
     fun testFindHttpUrlFetcher() {
-        val fetcher = config.findFetcherFor(Url(TestStringUrl))
+        val fetcher = config.findFetcherFor(URLBuilder(TestStringUrl))
 
         assertTrue { fetcher is HttpUrlFetcher }
     }