Interceptors content negotiation

apispec/openapi-model/src/main/scala/sttp/tapir/openapi/OpenAPI.scala

@@ -60,18 +60,18 @@ case class Components(
 
 // todo: $ref
 case class PathItem(
-    summary: Option[String],
-    description: Option[String],
-    get: Option[Operation],
-    put: Option[Operation],
-    post: Option[Operation],
-    delete: Option[Operation],
-    options: Option[Operation],
-    head: Option[Operation],
-    patch: Option[Operation],
-    trace: Option[Operation],
-    servers: List[Server],
-    parameters: List[ReferenceOr[Parameter]]
+    summary: Option[String] = None,
+    description: Option[String] = None,
+    get: Option[Operation] = None,
+    put: Option[Operation] = None,
+    post: Option[Operation] = None,
+    delete: Option[Operation] = None,
+    options: Option[Operation] = None,
+    head: Option[Operation] = None,
+    patch: Option[Operation] = None,
+    trace: Option[Operation] = None,
+    servers: List[Server] = List.empty,
+    parameters: List[ReferenceOr[Parameter]] = List.empty
 ) {
   def mergeWith(other: PathItem): PathItem = {
     PathItem(
@@ -93,32 +93,32 @@ case class PathItem(
 
 // todo: external docs, callbacks, security
 case class Operation(
-    tags: List[String],
-    summary: Option[String],
-    description: Option[String],
+    tags: List[String] = List.empty,
+    summary: Option[String] = None,
+    description: Option[String] = None,
     operationId: String,
-    parameters: List[ReferenceOr[Parameter]],
-    requestBody: Option[ReferenceOr[RequestBody]],
-    responses: ListMap[ResponsesKey, ReferenceOr[Response]],
-    deprecated: Option[Boolean],
-    security: List[SecurityRequirement],
-    servers: List[Server]
+    parameters: List[ReferenceOr[Parameter]] = List.empty,
+    requestBody: Option[ReferenceOr[RequestBody]] = None,
+    responses: ListMap[ResponsesKey, ReferenceOr[Response]] = ListMap.empty,
+    deprecated: Option[Boolean] = None,
+    security: List[SecurityRequirement] = List.empty,
+    servers: List[Server] = List.empty
 )
 
 case class Parameter(
     name: String,
     in: ParameterIn.ParameterIn,
-    description: Option[String],
-    required: Option[Boolean],
-    deprecated: Option[Boolean],
-    allowEmptyValue: Option[Boolean],
-    style: Option[ParameterStyle.ParameterStyle],
-    explode: Option[Boolean],
-    allowReserved: Option[Boolean],
+    description: Option[String] = None,
+    required: Option[Boolean] = None,
+    deprecated: Option[Boolean] = None,
+    allowEmptyValue: Option[Boolean] = None,
+    style: Option[ParameterStyle.ParameterStyle] = None,
+    explode: Option[Boolean] = None,
+    allowReserved: Option[Boolean] = None,
     schema: ReferenceOr[Schema],
-    example: Option[ExampleValue],
-    examples: ListMap[String, ReferenceOr[Example]],
-    content: ListMap[String, MediaType]
+    example: Option[ExampleValue] = None,
+    examples: ListMap[String, ReferenceOr[Example]] = ListMap.empty,
+    content: ListMap[String, MediaType] = ListMap.empty
 )
 
 object ParameterIn extends Enumeration {
@@ -145,47 +145,52 @@ object ParameterStyle extends Enumeration {
 case class RequestBody(description: Option[String], content: ListMap[String, MediaType], required: Option[Boolean])
 
 case class MediaType(
-    schema: Option[ReferenceOr[Schema]],
-    example: Option[ExampleValue],
-    examples: ListMap[String, ReferenceOr[Example]],
-    encoding: ListMap[String, Encoding]
+    schema: Option[ReferenceOr[Schema]] = None,
+    example: Option[ExampleValue] = None,
+    examples: ListMap[String, ReferenceOr[Example]] = ListMap.empty,
+    encoding: ListMap[String, Encoding] = ListMap.empty
 )
 
 case class Encoding(
-    contentType: Option[String],
-    headers: ListMap[String, ReferenceOr[Header]],
-    style: Option[ParameterStyle.ParameterStyle],
-    explode: Option[Boolean],
-    allowReserved: Option[Boolean]
+    contentType: Option[String] = None,
+    headers: ListMap[String, ReferenceOr[Header]] = ListMap.empty,
+    style: Option[ParameterStyle.ParameterStyle] = None,
+    explode: Option[Boolean] = None,
+    allowReserved: Option[Boolean] = None
 )
 
 sealed trait ResponsesKey
 case object ResponsesDefaultKey extends ResponsesKey
 case class ResponsesCodeKey(code: Int) extends ResponsesKey
 
 // todo: links
-case class Response(description: String, headers: ListMap[String, ReferenceOr[Header]], content: ListMap[String, MediaType]) {
+case class Response(
+    description: String,
+    headers: ListMap[String, ReferenceOr[Header]] = ListMap.empty,
+    content: ListMap[String, MediaType] = ListMap.empty
+)
 
-  def merge(other: Response): Response =
-    Response(
-      description,
-      headers ++ other.headers,
-      content ++ other.content
-    )
+object Response {
+  val Empty: Response = Response("", ListMap.empty, ListMap.empty)
 }
 
-case class Example(summary: Option[String], description: Option[String], value: Option[ExampleValue], externalValue: Option[String])
+case class Example(
+    summary: Option[String] = None,
+    description: Option[String] = None,
+    value: Option[ExampleValue] = None,
+    externalValue: Option[String] = None
+)
 
 case class Header(
-    description: Option[String],
-    required: Option[Boolean],
-    deprecated: Option[Boolean],
-    allowEmptyValue: Option[Boolean],
-    style: Option[ParameterStyle.ParameterStyle],
-    explode: Option[Boolean],
-    allowReserved: Option[Boolean],
-    schema: Option[ReferenceOr[Schema]],
-    example: Option[ExampleValue],
-    examples: ListMap[String, ReferenceOr[Example]],
-    content: ListMap[String, MediaType]
+    description: Option[String] = None,
+    required: Option[Boolean] = None,
+    deprecated: Option[Boolean] = None,
+    allowEmptyValue: Option[Boolean] = None,
+    style: Option[ParameterStyle.ParameterStyle] = None,
+    explode: Option[Boolean] = None,
+    allowReserved: Option[Boolean] = None,
+    schema: Option[ReferenceOr[Schema]] = None,
+    example: Option[ExampleValue] = None,
+    examples: ListMap[String, ReferenceOr[Example]] = ListMap.empty,
+    content: ListMap[String, MediaType] = ListMap.empty
 )

client/play-client/src/main/scala/sttp/tapir/client/play/EndpointToPlayClient.scala

@@ -1,16 +1,11 @@
 package sttp.tapir.client.play
 
-import java.io.{ByteArrayInputStream, File, InputStream}
-import java.nio.ByteBuffer
-import java.nio.file.Files
-import java.util.function.Supplier
-
 import play.api.libs.ws.DefaultBodyReadables._
 import play.api.libs.ws.DefaultBodyWritables._
 import play.api.libs.ws._
 import sttp.capabilities.Streams
 import sttp.capabilities.akka.AkkaStreams
-import sttp.model.Method
+import sttp.model.{HeaderNames, MediaType, Method}
 import sttp.tapir.Codec.PlainCodec
 import sttp.tapir.internal.{CombineParams, Params, ParamsAsAny, RichEndpointInput, RichEndpointOutput, SplitParams}
 import sttp.tapir.{
@@ -26,6 +21,10 @@ import sttp.tapir.{
   StreamBodyIO
 }
 
+import java.io.{ByteArrayInputStream, File, InputStream}
+import java.nio.ByteBuffer
+import java.nio.file.Files
+import java.util.function.Supplier
 import scala.collection.Seq
 
 private[play] class EndpointToPlayClient(clientOptions: PlayClientOptions, ws: StandaloneWSClient) {
@@ -95,15 +94,49 @@ private[play] class EndpointToPlayClient(clientOptions: PlayClientOptions, ws: S
           case EndpointIO.FixedHeader(_, codec, _)         => codec.decode(())
           case EndpointIO.Empty(codec, _)                  => codec.decode(())
           case EndpointOutput.OneOf(mappings, codec) =>
-            mappings
-              .find(mapping => mapping.statusCode.isEmpty || mapping.statusCode.contains(code)) match {
-              case Some(mapping) =>
-                getOutputParams(mapping.output, body, headers, code, statusText).flatMap(p => codec.decode(p.asAny))
+            val mappingsForStatus = mappings collect {
+              case m if m.statusCode.isEmpty || m.statusCode.contains(code) => m
+            }
+
+            val contentType = headers
+              .get(HeaderNames.ContentType)
+              .map { h => MediaType.parse(h.head) }
+
+            def applyMapping(m: EndpointOutput.StatusMapping[_]) =
+              getOutputParams(m.output, body, headers, code, statusText).flatMap(p => codec.decode(p.asAny))
+
+            contentType match {
               case None =>
-                DecodeResult.Error(
-                  statusText,
-                  new IllegalArgumentException(s"Cannot find mapping for status code ${code} in outputs $output")
-                )
+                val firstNonBodyMapping = mappingsForStatus.find(_.output.traverseOutputs {
+                  case _ @(EndpointIO.Body(_, _, _) | EndpointIO.StreamBodyWrapper(_)) => Vector(false)
+                  case _                                                               => Vector(true)
+                } forall (_ == true))
+
+                firstNonBodyMapping
+                  .orElse(mappingsForStatus.headOption)
+                  .map(applyMapping)
+                  .getOrElse(
+                    DecodeResult
+                      .Error(statusText, new IllegalArgumentException(s"Cannot find mapping for status code $code in outputs $output"))
+                  )
+
+              case Some(Right(content)) =>
+                val bodyMappingForStatus = mappingsForStatus collectFirst {
+                  case m if m.output.hasBodyMatchingContent(content) => m
+                }
+
+                bodyMappingForStatus
+                  .orElse(mappingsForStatus.headOption)
+                  .map(applyMapping)
+                  .getOrElse(
+                    DecodeResult
+                      .Error(
+                        statusText,
+                        new IllegalArgumentException(s"Cannot find mapping for status code $code and content $content in outputs $output")
+                      )
+                  )
+
+              case Some(Left(_)) => DecodeResult.Error(statusText, new IllegalArgumentException("Unable to parse Content-Type header"))
             }
 
           case EndpointIO.MappedPair(wrapped, codec) =>

client/sttp-client/src/main/scala/sttp/tapir/client/sttp/EndpointToSttpClient.scala

@@ -1,15 +1,16 @@
 package sttp.tapir.client.sttp
 
-import java.io.ByteArrayInputStream
-import java.nio.ByteBuffer
 import sttp.capabilities.Streams
 import sttp.client3._
-import sttp.model.{HeaderNames, Method, Part, ResponseMetadata, StatusCode, Uri}
+import sttp.model._
 import sttp.tapir.Codec.PlainCodec
 import sttp.tapir._
 import sttp.tapir.internal._
 import sttp.ws.WebSocket
 
+import java.io.ByteArrayInputStream
+import java.nio.ByteBuffer
+
 private[sttp] class EndpointToSttpClient[R](clientOptions: SttpClientOptions, wsToPipe: WebSocketToPipe[R]) {
   def toSttpRequest[O, E, I](e: Endpoint[I, E, O, R], baseUri: Option[Uri]): I => Request[DecodeResult[Either[E, O]], R] = { params =>
     val (uri, req1) =
@@ -62,15 +63,51 @@ private[sttp] class EndpointToSttpClient[R](clientOptions: SttpClientOptions, ws
           case EndpointIO.FixedHeader(_, codec, _)         => codec.decode(())
           case EndpointIO.Empty(codec, _)                  => codec.decode(())
           case EndpointOutput.OneOf(mappings, codec) =>
-            mappings
-              .find(mapping => mapping.statusCode.isEmpty || mapping.statusCode.contains(meta.code)) match {
-              case Some(mapping) =>
-                getOutputParams(mapping.output, body, meta).flatMap(p => codec.decode(p.asAny))
+            val mappingsForStatus = mappings collect {
+              case m if m.statusCode.isEmpty || m.statusCode.contains(meta.code) => m
+            }
+
+            val contentType = meta
+              .header(HeaderNames.ContentType)
+              .map(MediaType.parse)
+
+            def applyMapping(m: EndpointOutput.StatusMapping[_]) = getOutputParams(m.output, body, meta).flatMap(p => codec.decode(p.asAny))
+
+            contentType match {
               case None =>
-                DecodeResult.Error(
-                  meta.statusText,
-                  new IllegalArgumentException(s"Cannot find mapping for status code ${meta.code} in outputs $output")
-                )
+                val firstNonBodyMapping = mappingsForStatus.find(_.output.traverseOutputs {
+                  case _ @(EndpointIO.Body(_, _, _) | EndpointIO.StreamBodyWrapper(_)) => Vector(false)
+                  case _                                                               => Vector(true)
+                } forall (_ == true))
+
+                firstNonBodyMapping
+                  .orElse(mappingsForStatus.headOption)
+                  .map(applyMapping)
+                  .getOrElse(
+                    DecodeResult.Error(
+                      meta.statusText,
+                      new IllegalArgumentException(s"Cannot find mapping for status code ${meta.code} in outputs $output")
+                    )
+                  )
+
+              case Some(Right(content)) =>
+                val bodyMappingForStatus = mappingsForStatus collectFirst {
+                  case m if m.output.hasBodyMatchingContent(content) => m
+                }
+
+                bodyMappingForStatus
+                  .orElse(mappingsForStatus.headOption)
+                  .map(applyMapping)
+                  .getOrElse(
+                    DecodeResult.Error(
+                      meta.statusText,
+                      new IllegalArgumentException(
+                        s"Cannot find mapping for status code ${meta.code} and content $content in outputs $output"
+                      )
+                    )
+                  )
+
+              case Some(Left(_)) => DecodeResult.Error(meta.statusText, new IllegalArgumentException("Unable to parse Content-Type header"))
             }
 
           case EndpointIO.MappedPair(wrapped, codec)     => getOutputParams(wrapped, body, meta).flatMap(p => codec.decode(p.asAny))