Schema based header codecs, unified with query codecs (#3232)

Fix for publish CI job
zio · Jan 9, 2025 · 3fb0959 · 3fb0959
1 parent 267c6ce
commit 3fb0959
Show file tree

Hide file tree

Showing 28 changed files with 1,641 additions and 586 deletions.
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -196,6 +196,10 @@ jobs:
           tar xf targets.tar
           rm targets.tar
 
+      - uses: coursier/setup-action@v1
+        with:
+          apps: sbt
+
       - name: Release
         env:
           PGP_PASSPHRASE: ${{ secrets.PGP_PASSPHRASE }}

diff --git a/build.sbt b/build.sbt
@@ -58,6 +58,7 @@ ThisBuild / githubWorkflowTargetTags ++= Seq("v*")
 ThisBuild / githubWorkflowPublishTargetBranches += RefPredicate.StartsWith(Ref.Tag("v"))
 ThisBuild / githubWorkflowPublish       :=
   Seq(
+    WorkflowStep.Use(UseRef.Public("coursier", "setup-action", "v1"), Map("apps" -> "sbt")),
     WorkflowStep.Sbt(
       List("ci-release"),
       name = Some("Release"),

diff --git a/zio-http-benchmarks/src/main/scala/zhttp.benchmarks/ServerInboundHandlerBenchmark.scala b/zio-http-benchmarks/src/main/scala/zhttp.benchmarks/ServerInboundHandlerBenchmark.scala
@@ -18,7 +18,7 @@ class ServerInboundHandlerBenchmark {
   private val largeString = random.alphanumeric.take(100000).mkString
 
   private val baseUrl = "http://localhost:8080"
-  private val headers = Headers(Header.ContentType(MediaType.text.`plain`).untyped)
+  private val headers = Headers(Header.ContentType(MediaType.text.`plain`))
 
   private val arrayEndpoint = "array"
   private val arrayResponse = ZIO.succeed(

diff --git a/zio-http-cli/src/main/scala/zio/http/endpoint/cli/CliEndpoint.scala b/zio-http-cli/src/main/scala/zio/http/endpoint/cli/CliEndpoint.scala
@@ -1,7 +1,6 @@
 package zio.http.endpoint.cli
 
 import zio.http._
-import zio.http.codec.HttpCodec.Query.QueryType
 import zio.http.codec._
 import zio.http.endpoint._
 
@@ -112,13 +111,11 @@ private[cli] object CliEndpoint {
         }
         CliEndpoint(body = HttpOptions.Body(name, codec.defaultMediaType, codec.defaultSchema) :: List())
 
-      case HttpCodec.Header(name, textCodec, _) if textCodec.isInstanceOf[TextCodec.Constant] =>
-        CliEndpoint(headers =
-          HttpOptions.HeaderConstant(name, textCodec.asInstanceOf[TextCodec.Constant].string) :: List(),
-        )
-      case HttpCodec.Header(name, textCodec, _)                                               =>
-        CliEndpoint(headers = HttpOptions.Header(name, textCodec) :: List())
-      case HttpCodec.Method(codec, _)                                                         =>
+      case HttpCodec.Header(headerType, _)  =>
+        CliEndpoint(headers = HttpOptions.Header(headerType.name, TextCodec.string) :: List())
+      case HttpCodec.HeaderCustom(codec, _) =>
+        ??? // todo
+      case HttpCodec.Method(codec, _)       =>
         codec.asInstanceOf[SimpleCodec[_, _]] match {
           case SimpleCodec.Specified(method: Method) =>
             CliEndpoint(methods = method)
@@ -128,22 +125,16 @@ private[cli] object CliEndpoint {
       case HttpCodec.Path(pathCodec, _) =>
         CliEndpoint(url = HttpOptions.Path(pathCodec) :: List())
 
-      case HttpCodec.Query(queryType, _) =>
-        queryType match {
-          case QueryType.Primitive(name, codec)     =>
-            CliEndpoint(url = HttpOptions.Query(name, codec) :: List())
-          case record @ QueryType.Record(_)         =>
-            val queryOptions = record.fieldAndCodecs.map { case (field, codec) =>
-              HttpOptions.Query(field.name, codec)
-            }
-            CliEndpoint(url = queryOptions.toList)
-          case QueryType.Collection(_, elements, _) =>
-            val queryOptions =
-              HttpOptions.Query(elements.name, elements.codec)
-            CliEndpoint(url = queryOptions :: List())
-        }
-
-      case HttpCodec.Status(_, _) => CliEndpoint.empty
+      case HttpCodec.Query(codec, _) =>
+        if (codec.isPrimitive)
+          CliEndpoint(url = HttpOptions.Query(codec) :: List())
+        else if (codec.isRecord)
+          CliEndpoint(url = codec.recordFields.map { case (_, codec) =>
+            HttpOptions.Query(codec)
+          }.toList)
+        else
+          CliEndpoint(url = HttpOptions.Query(codec) :: List())
+      case HttpCodec.Status(_, _)    => CliEndpoint.empty
 
     }
   }

diff --git a/zio-http-cli/src/main/scala/zio/http/endpoint/cli/HttpOptions.scala b/zio-http-cli/src/main/scala/zio/http/endpoint/cli/HttpOptions.scala
@@ -11,6 +11,7 @@ import zio.schema._
 import zio.schema.annotation.description
 
 import zio.http._
+import zio.http.codec.HttpCodec.SchemaCodec
 import zio.http.codec._
 
 /*
@@ -264,10 +265,9 @@ private[cli] object HttpOptions {
 
   }
 
-  final case class Query(override val name: String, codec: BinaryCodecWithSchema[_], doc: Doc = Doc.empty)
-      extends URLOptions {
+  final case class Query(codec: SchemaCodec[_], doc: Doc = Doc.empty) extends URLOptions {
     self =>
-
+    override val name       = codec.name.get
     override val tag        = "?" + name
     def options: Options[_] = optionsFromSchema(codec)(name)
 
@@ -293,7 +293,7 @@ private[cli] object HttpOptions {
 
   }
 
-  private[cli] def optionsFromSchema[A](codec: BinaryCodecWithSchema[A]): String => Options[A] =
+  private[cli] def optionsFromSchema[A](codec: SchemaCodec[A]): String => Options[A] =
     codec.schema match {
       case Schema.Primitive(standardType, _) =>
         standardType match {

diff --git a/zio-http-cli/src/test/scala/zio/http/endpoint/cli/CliSpec.scala b/zio-http-cli/src/test/scala/zio/http/endpoint/cli/CliSpec.scala
@@ -27,7 +27,7 @@ object CliSpec extends ZIOSpecDefault {
 
   val bodyStream = ContentCodec.contentStream[BigInt]("bodyStream")
 
-  val headerCodec = HttpCodec.Header("header", TextCodec.string)
+  val headerCodec = HttpCodec.headerAs[String]("header")
 
   val path1 = PathCodec.bool("path1")
 

diff --git a/zio-http-cli/src/test/scala/zio/http/endpoint/cli/CommandGen.scala b/zio-http-cli/src/test/scala/zio/http/endpoint/cli/CommandGen.scala
@@ -47,20 +47,20 @@ object CommandGen {
       case _: HttpOptions.Constant => false
       case _                       => true
     }.map {
-      case HttpOptions.Path(pathCodec, _)    =>
-        pathCodec.segments.toList.flatMap { case segment =>
+      case HttpOptions.Path(pathCodec, _)                   =>
+        pathCodec.segments.toList.flatMap { segment =>
           getSegment(segment) match {
             case (_, "")           => Nil
             case (name, "boolean") => s"[${getName(name, "")}]" :: Nil
             case (name, codec)     => s"${getName(name, "")} $codec" :: Nil
           }
         }
-      case HttpOptions.Query(name, codec, _) =>
-        getType(codec) match {
-          case ""    => s"[${getName(name, "")}]" :: Nil
-          case codec => s"${getName(name, "")} $codec" :: Nil
+      case HttpOptions.Query(codec, _) if codec.isPrimitive =>
+        getType(codec.schema) match {
+          case ""  => s"[${getName(codec.name.get, "")}]" :: Nil
+          case tpy => s"${getName(codec.name.get, "")} $tpy" :: Nil
         }
-      case _                                 => Nil
+      case _                                                => Nil
     }.foldRight(List[String]())(_ ++ _)
 
     val headersOptions = cliEndpoint.headers.filter {
@@ -121,8 +121,8 @@ object CommandGen {
       case _                      => ""
     }
 
-  def getType[A](codec: BinaryCodecWithSchema[A]): String =
-    codec.schema match {
+  def getType[A](schema: Schema[A]): String =
+    schema match {
       case Schema.Primitive(standardType, _) =>
         standardType match {
           case StandardType.UnitType           => ""

diff --git a/zio-http-cli/src/test/scala/zio/http/endpoint/cli/EndpointGen.scala b/zio-http-cli/src/test/scala/zio/http/endpoint/cli/EndpointGen.scala
@@ -5,7 +5,9 @@ import zio.test._
 
 import zio.schema.Schema
 
+import zio.http.Header.HeaderType
 import zio.http._
+import zio.http.codec.HttpCodec.SchemaCodec
 import zio.http.codec._
 import zio.http.endpoint._
 import zio.http.endpoint.cli.AuxGen._
@@ -78,7 +80,7 @@ object EndpointGen {
   lazy val anyHeader: Gen[Any, CliReprOf[Codec[_]]] =
     Gen.alphaNumericStringBounded(1, 30).zip(anyTextCodec).map { case (name, codec) =>
       CliRepr(
-        HttpCodec.Header(name, codec),
+        HttpCodec.Header(Header.Custom(name, "").headerType), // todo use schema bases header
         codec match {
           case TextCodec.Constant(value) => CliEndpoint(headers = HttpOptions.HeaderConstant(name, value) :: Nil)
           case _                         => CliEndpoint(headers = HttpOptions.Header(name, codec) :: Nil)
@@ -102,10 +104,10 @@ object EndpointGen {
   lazy val anyQuery: Gen[Any, CliReprOf[Codec[_]]] =
     Gen.alphaNumericStringBounded(1, 30).zip(anyStandardType).map { case (name, schema0) =>
       val schema = schema0.asInstanceOf[Schema[Any]]
-      val codec  = BinaryCodecWithSchema(TextBinaryCodec.fromSchema(schema), schema)
+      val codec  = SchemaCodec(Some(name), schema)
       CliRepr(
-        HttpCodec.Query(HttpCodec.Query.QueryType.Primitive(name, codec)),
-        CliEndpoint(url = HttpOptions.Query(name, codec) :: Nil),
+        HttpCodec.Query(codec),
+        CliEndpoint(url = HttpOptions.Query(codec) :: Nil),
       )
     }
 

diff --git a/zio-http-cli/src/test/scala/zio/http/endpoint/cli/OptionsGen.scala b/zio-http-cli/src/test/scala/zio/http/endpoint/cli/OptionsGen.scala
@@ -7,6 +7,7 @@ import zio.test.Gen
 import zio.schema.Schema
 
 import zio.http._
+import zio.http.codec.HttpCodec.SchemaCodec
 import zio.http.codec._
 import zio.http.endpoint.cli.AuxGen._
 import zio.http.endpoint.cli.CliRepr._
@@ -32,10 +33,10 @@ object OptionsGen {
       .optionsFromTextCodec(textCodec)(name)
       .map(value => textCodec.encode(value))
 
-  def encodeOptions[A](name: String, codec: BinaryCodecWithSchema[A]): Options[String] =
+  def encodeOptions[A](name: String, codec: SchemaCodec[A]): Options[String] =
     HttpOptions
       .optionsFromSchema(codec)(name)
-      .map(value => codec.codec(CodecConfig.defaultConfig).encode(value).asString)
+      .map(value => codec.stringCodec.encode(value))
 
   lazy val anyBodyOption: Gen[Any, CliReprOf[Options[Retriever]]] =
     Gen
@@ -83,14 +84,12 @@ object OptionsGen {
         },
       Gen
         .alphaNumericStringBounded(1, 30)
-        .zip(anyStandardType.map { s =>
-          val schema = s.asInstanceOf[Schema[Any]]
-          BinaryCodecWithSchema(TextBinaryCodec.fromSchema(schema), schema)
-        })
-        .map { case (name, codec) =>
+        .zip(anyStandardType)
+        .map { case (name, schema) =>
+          val codec = SchemaCodec(Some(name), schema)
           CliRepr(
             encodeOptions(name, codec),
-            CliEndpoint(url = HttpOptions.Query(name, codec) :: Nil),
+            CliEndpoint(url = HttpOptions.Query(codec) :: Nil),
           )
         },
     )

diff --git a/zio-http-gen/src/test/scala/zio/http/gen/scala/CodeGenSpec.scala b/zio-http-gen/src/test/scala/zio/http/gen/scala/CodeGenSpec.scala
@@ -155,7 +155,7 @@ object CodeGenSpec extends ZIOSpecDefault {
           Endpoint(Method.GET / "api" / "v1" / "users")
             .header(HeaderCodec.accept)
             .header(HeaderCodec.contentType)
-            .header(HeaderCodec.name[String]("Token"))
+            .header(HeaderCodec.headerAs[String]("Token"))
         val openAPI  = OpenAPIGen.fromEndpoints(endpoint)
 
         codeGenFromOpenAPI(openAPI) { testDir =>