KTOR-1689 Create client ContentNegotiation feature

Author: rsinukov1

build.gradle.kts

@@ -117,7 +117,8 @@ val disabledExplicitApiModeProjects = listOf(
     "ktor-client-json-tests",
     "ktor-server-test-host",
     "ktor-server-test-suites",
-    "ktor-server-tests"
+    "ktor-server-tests",
+    "ktor-client-content-negotiation-tests",
 )
 
 apply(from = "gradle/compatibility.gradle")

gradle/compatibility.gradle

@@ -6,6 +6,7 @@ apiValidation {
         'ktor-client-tests',
         'ktor-client-js',
         'ktor-client-json-tests',
+        'ktor-client-content-negotiation-tests',
         'ktor-client',
         'ktor-client-features',
         'ktor-server-test-suites',
@@ -27,6 +28,7 @@ apiValidation {
         project(":ktor-io"),
         project(":ktor-server"),
         project(":ktor-features"),
+        project(":ktor-shared"),
     ]
 
     while (!queue.isEmpty()) {

ktor-client/ktor-client-core/api/ktor-client-core.api

@@ -892,15 +892,15 @@ public final class io/ktor/client/request/HttpRequestBuilder : io/ktor/http/Http
 	public final fun build ()Lio/ktor/client/request/HttpRequestData;
 	public final fun getAttributes ()Lio/ktor/util/Attributes;
 	public final fun getBody ()Ljava/lang/Object;
-	public final fun getBodyType ()Lkotlin/reflect/KType;
+	public final fun getBodyType ()Lio/ktor/util/reflect/TypeInfo;
 	public final fun getCapabilityOrNull (Lio/ktor/client/engine/HttpClientEngineCapability;)Ljava/lang/Object;
 	public final fun getExecutionContext ()Lkotlinx/coroutines/Job;
 	public fun getHeaders ()Lio/ktor/http/HeadersBuilder;
 	public final fun getMethod ()Lio/ktor/http/HttpMethod;
 	public final fun getUrl ()Lio/ktor/http/URLBuilder;
 	public final fun setAttributes (Lkotlin/jvm/functions/Function1;)V
 	public final fun setBody (Ljava/lang/Object;)V
-	public final fun setBodyType (Lkotlin/reflect/KType;)V
+	public final fun setBodyType (Lio/ktor/util/reflect/TypeInfo;)V
 	public final fun setCapability (Lio/ktor/client/engine/HttpClientEngineCapability;Ljava/lang/Object;)V
 	public final fun setMethod (Lio/ktor/http/HttpMethod;)V
 	public final fun takeFrom (Lio/ktor/client/request/HttpRequestBuilder;)Lio/ktor/client/request/HttpRequestBuilder;

ktor-client/ktor-client-core/common/src/io/ktor/client/call/TypeInfo.kt

@@ -80,7 +80,7 @@ public class HttpSend(
                 check(content is OutgoingContent) {
                     """
 |Fail to serialize body. Content has type: ${content::class}, but OutgoingContent expected.
-|If you expect serialized body, please check that you have installed the corresponding feature(like `Json`) and set `Content-Type` header."""
+|If you expect serialized body, please check that you have installed the corresponding feature(like `ContentNegotiation`) and set `Content-Type` header."""
                         .trimMargin()
                 }
                 context.setBody(content)

ktor-client/ktor-client-core/common/src/io/ktor/client/features/HttpSend.kt

@@ -12,6 +12,7 @@ import io.ktor.http.*
 import io.ktor.http.content.*
 import io.ktor.util.*
 import io.ktor.util.date.*
+import io.ktor.util.reflect.*
 import io.ktor.utils.io.*
 import kotlinx.coroutines.*
 import kotlin.coroutines.*
@@ -78,7 +79,7 @@ public class HttpRequestBuilder : HttpMessageBuilder {
     /**
      * The [KType] of [body] for this request. Null for default types that don't need serialization.
      */
-    public var bodyType: KType?
+    public var bodyType: TypeInfo?
         get() = attributes.getOrNull(BodyTypeAttributeKey)
         @InternalAPI set(value) {
             if (value != null) {
@@ -144,7 +145,7 @@ public class HttpRequestBuilder : HttpMessageBuilder {
         body = builder.body
         bodyType = builder.bodyType
         url.takeFrom(builder.url)
-        url.encodedPath = if (url.encodedPath.isBlank()) "/" else url.encodedPath
+        url.encodedPath = url.encodedPath.ifBlank { "/" }
         headers.appendAll(builder.headers)
         attributes.putAll(builder.attributes)
 

ktor-client/ktor-client-core/common/src/io/ktor/client/request/HttpRequest.kt

@@ -7,36 +7,25 @@ package io.ktor.client.request
 import io.ktor.client.utils.*
 import io.ktor.http.content.*
 import io.ktor.util.*
-import io.ktor.utils.io.*
+import io.ktor.util.reflect.*
 import kotlin.native.concurrent.*
-import kotlin.reflect.*
 
 @SharedImmutable
-internal val BodyTypeAttributeKey: AttributeKey<KType> = AttributeKey("BodyTypeAttributeKey")
-
-@PublishedApi
-@OptIn(ExperimentalStdlibApi::class)
-internal inline fun <reified T : Any> tryGetType(ignored: T): KType? = try {
-    // We need to wrap getting type in try catch because of KT-42913
-    typeOf<T>()
-} catch (_: Throwable) {
-    null
-}
+internal val BodyTypeAttributeKey: AttributeKey<TypeInfo> = AttributeKey("BodyTypeAttributeKey")
 
 public inline fun <reified T> HttpRequestBuilder.setBody(body: T) {
     when (body) {
         null -> {
             this.body = EmptyContent
+            bodyType = null
         }
-        is String,
-        is OutgoingContent,
-        is ByteArray,
-        is ByteReadChannel -> {
+        is OutgoingContent -> {
             this.body = body
+            bodyType = null
         }
         else -> {
             this.body = body
-            bodyType = tryGetType(body)
+            bodyType = typeInfo<T>()
         }
     }
 }

ktor-client/ktor-client-core/common/src/io/ktor/client/request/RequestBody.kt

@@ -0,0 +1,27 @@
+public final class io/ktor/client/features/ContentConverterException : java/lang/Exception {
+	public fun <init> (Ljava/lang/String;)V
+}
+
+public final class io/ktor/client/features/ContentNegotiation {
+	public static final field Feature Lio/ktor/client/features/ContentNegotiation$Feature;
+}
+
+public final class io/ktor/client/features/ContentNegotiation$Config : io/ktor/shared/serialization/Configuration {
+	public fun <init> ()V
+	public final fun register (Lio/ktor/http/ContentType;Lio/ktor/shared/serialization/ContentConverter;Lio/ktor/http/ContentTypeMatcher;Lkotlin/jvm/functions/Function1;)V
+	public fun register (Lio/ktor/http/ContentType;Lio/ktor/shared/serialization/ContentConverter;Lkotlin/jvm/functions/Function1;)V
+}
+
+public final class io/ktor/client/features/ContentNegotiation$Feature : io/ktor/client/features/HttpClientFeature {
+	public fun getKey ()Lio/ktor/util/AttributeKey;
+	public fun install (Lio/ktor/client/features/ContentNegotiation;Lio/ktor/client/HttpClient;)V
+	public synthetic fun install (Ljava/lang/Object;Lio/ktor/client/HttpClient;)V
+	public fun prepare (Lkotlin/jvm/functions/Function1;)Lio/ktor/client/features/ContentNegotiation;
+	public synthetic fun prepare (Lkotlin/jvm/functions/Function1;)Ljava/lang/Object;
+}
+
+public final class io/ktor/client/features/JsonContentTypeMatcher : io/ktor/http/ContentTypeMatcher {
+	public static final field INSTANCE Lio/ktor/client/features/JsonContentTypeMatcher;
+	public fun contains (Lio/ktor/http/ContentType;)Z
+}
+

ktor-client/ktor-client-features/ktor-client-content-negotiation/api/ktor-client-content-negotiation.api

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2014-2020 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+description = "Ktor client Content Negotiation support"
+
+val ideaActive: Boolean by project.extra
+
+plugins {
+    id("kotlinx-serialization")
+}
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api(project(":ktor-shared:ktor-shared-serialization"))
+            }
+        }
+    }
+}

ktor-client/ktor-client-features/ktor-client-content-negotiation/build.gradle.kts

@@ -0,0 +1,132 @@
+/*
+ * Copyright 2014-2021 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package io.ktor.client.features
+
+import io.ktor.client.*
+import io.ktor.client.request.*
+import io.ktor.client.statement.*
+import io.ktor.client.utils.*
+import io.ktor.http.*
+import io.ktor.shared.serialization.*
+import io.ktor.util.*
+import io.ktor.utils.io.*
+import io.ktor.utils.io.charsets.*
+
+/**
+ * [HttpClient] feature that serializes/de-serializes custom objects
+ * to request and from response bodies using a [ContentConverter]
+ * to Content-Type and Accept headers.
+ */
+public class ContentNegotiation internal constructor(
+    internal val registrations: List<Config.ConverterRegistration>
+) {
+
+    /**
+     * [ContentNegotiation] configuration that is used during installation
+     */
+    public class Config : Configuration {
+
+        internal class ConverterRegistration(
+            val converter: ContentConverter,
+            val contentTypeToSend: ContentType,
+            val contentTypeMatcher: ContentTypeMatcher,
+        )
+
+        internal val registrations = mutableListOf<ConverterRegistration>()
+
+        /**
+         * Registers a [contentType] to a specified [converter] with an optional [configuration] script for converter
+         */
+        public override fun <T : ContentConverter> register(
+            contentType: ContentType,
+            converter: T,
+            configuration: T.() -> Unit
+        ) {
+            val matcher = when (contentType) {
+                ContentType.Application.Json -> JsonContentTypeMatcher
+                else -> defaultMatcher(contentType)
+            }
+            register(contentType, converter, matcher, configuration)
+        }
+
+        /**
+         * Registers a [contentTypeToSend] and [contentTypeMatcher] to a specified [converter] with
+         * an optional [configuration] script for converter
+         */
+        public fun <T : ContentConverter> register(
+            contentTypeToSend: ContentType,
+            converter: T,
+            contentTypeMatcher: ContentTypeMatcher,
+            configuration: T.() -> Unit
+        ) {
+            val registration = ConverterRegistration(
+                converter.apply(configuration),
+                contentTypeToSend,
+                contentTypeMatcher
+            )
+            registrations.add(registration)
+        }
+
+        private fun defaultMatcher(pattern: ContentType): ContentTypeMatcher = object : ContentTypeMatcher {
+            override fun contains(contentType: ContentType): Boolean = contentType.match(pattern)
+        }
+    }
+
+    /**
+     * Companion object for feature installation
+     */
+    public companion object Feature : HttpClientFeature<Config, ContentNegotiation> {
+        public override val key: AttributeKey<ContentNegotiation> = AttributeKey("ContentNegotiation")
+
+        override fun prepare(block: Config.() -> Unit): ContentNegotiation {
+            val config = Config().apply(block)
+            return ContentNegotiation(config.registrations)
+        }
+
+        override fun install(feature: ContentNegotiation, scope: HttpClient) {
+            scope.requestPipeline.intercept(HttpRequestPipeline.Transform) { payload ->
+                val registrations = feature.registrations
+                registrations.forEach { context.accept(it.contentTypeToSend) }
+
+                val contentType = context.contentType() ?: return@intercept
+                context.headers.remove(HttpHeaders.ContentType)
+
+                if (payload is Unit || payload is EmptyContent) {
+                    proceedWith(EmptyContent)
+                    return@intercept
+                }
+                val registration = registrations
+                    .firstOrNull { it.contentTypeMatcher.contains(contentType) } ?: return@intercept
+
+                val serializedContent = registration.converter.serialize(
+                    contentType,
+                    contentType.charset() ?: Charsets.UTF_8,
+                    context.bodyType!!,
+                    payload
+                ) ?: throw ContentConverterException(
+                    "Can't convert $payload with contentType $contentType using converter ${registration.converter}"
+                )
+
+                proceedWith(serializedContent)
+            }
+
+            scope.responsePipeline.intercept(HttpResponsePipeline.Transform) { (info, body) ->
+                if (body !is ByteReadChannel) return@intercept
+
+                val contentType = context.response.contentType() ?: return@intercept
+                val registrations = feature.registrations
+                val registration = registrations
+                    .firstOrNull { it.contentTypeMatcher.contains(contentType) } ?: return@intercept
+
+                val parsedBody = registration.converter
+                    .deserialize(context.request.headers.suitableCharset(), info, body) ?: return@intercept
+                val response = HttpResponseContainer(info, parsedBody)
+                proceedWith(response)
+            }
+        }
+    }
+}
+
+public class ContentConverterException(message: String) : Exception(message)

ktor-client/ktor-client-features/ktor-client-content-negotiation/common/src/io/ktor/client/features/ContentNegotiation.kt

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2014-2020 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package io.ktor.client.features
+
+import io.ktor.http.*
+
+/**
+ * Matcher that accepts all extended json content types
+ */
+public object JsonContentTypeMatcher : ContentTypeMatcher {
+    override fun contains(contentType: ContentType): Boolean {
+        if (contentType.match(ContentType.Application.Json)) {
+            return true
+        }
+
+        val value = contentType.withoutParameters().toString()
+        return value.startsWith("application/") && value.endsWith("+json")
+    }
+}