Pickler derivation

.scalafix.conf

@@ -1,3 +1,4 @@
 OrganizeImports {
   groupedImports = Merge
+  removeUnused = false
 }

build.sbt

@@ -67,7 +67,7 @@ val commonSettings = commonSmlBuildSettings ++ ossPublishSettings ++ Seq(
   }.value,
   mimaPreviousArtifacts := Set.empty, // we only use MiMa for `core` for now, using enableMimaSettings
   ideSkipProject := (scalaVersion.value == scala2_12) ||
-    (scalaVersion.value == scala3) ||
+    (scalaVersion.value == scala2_13) ||
     thisProjectRef.value.project.contains("Native") ||
     thisProjectRef.value.project.contains("JS"),
   bspEnabled := !ideSkipProject.value,
@@ -179,6 +179,7 @@ lazy val rawAllAggregates = core.projectRefs ++
   zioMetrics.projectRefs ++
   json4s.projectRefs ++
   playJson.projectRefs ++
+  picklerJson.projectRefs ++
   sprayJson.projectRefs ++
   uPickleJson.projectRefs ++
   tethysJson.projectRefs ++
@@ -861,6 +862,19 @@ lazy val uPickleJson: ProjectMatrix = (projectMatrix in file("json/upickle"))
   )
   .dependsOn(core)
 
+lazy val picklerJson: ProjectMatrix = (projectMatrix in file("json/pickler"))
+  .settings(commonSettings)
+  .settings(
+    name := "tapir-json-pickler",
+    libraryDependencies ++= Seq(
+      "com.lihaoyi" %%% "upickle" % Versions.upickle,
+      scalaTest.value % Test
+    )
+  )
+  .jvmPlatform(scalaVersions = List(scala3))
+  .jsPlatform(scalaVersions = List(scala3))
+  .dependsOn(core % "compile->compile;test->test")
+
 lazy val tethysJson: ProjectMatrix = (projectMatrix in file("json/tethys"))
   .settings(commonSettings)
   .settings(
@@ -2043,9 +2057,12 @@ lazy val examples3: ProjectMatrix = (projectMatrix in file("examples3"))
   )
   .jvmPlatform(scalaVersions = List(scala3))
   .dependsOn(
+    circeJson,
     http4sServer,
+    nettyServer,
+    picklerJson,
+    sttpClient,
     swaggerUiBundle,
-    circeJson
   )
 
 //TODO this should be invoked by compilation process, see #https://github.com/scalameta/mdoc/issues/355

core/src/main/scala-3/sttp/tapir/macros/SchemaMacros.scala

@@ -199,6 +199,7 @@ private[tapir] object SchemaCompanionMacros {
       case Block(List(defdef), _)      => resolveFunctionName(defdef)
       case DefDef(_, _, _, Some(body)) => resolveFunctionName(body)
       case Apply(fun, _)               => resolveFunctionName(fun)
+      case Ident(str)                  => str
       case Select(_, kind)             => kind
     }
 

doc/endpoint/json.md

@@ -1,34 +1,40 @@
 # Working with JSON
 
 Json values are supported through codecs, which encode/decode values to json strings. Most often, you'll be using a
-third-party library to perform the actual json parsing/printing. See below for the list of supported libraries. 
+third-party library to perform the actual json parsing/printing. See below for the list of supported libraries.
 
-All the integrations, when imported into scope, define `jsonBody[T]` and `jsonQuery[T]` methods. 
+All the integrations, when imported into scope, define `jsonBody[T]` and `jsonQuery[T]` methods.
 
-Instead of providing the json codec as an implicit value, this method depends on library-specific implicits being in 
-scope, and basing on these values creates a json codec. The derivation also requires 
-an implicit `Schema[T]` instance, which can be automatically derived. For more details see sections on 
-[schema derivation](schemas.md) and on supporting [custom types](customtypes.md) in general. Such a design provides 
+Instead of providing the json codec as an implicit value, this method depends on library-specific implicits being in
+scope, and basing on these values creates a json codec. The derivation also requires
+an implicit `Schema[T]` instance, which can be automatically derived. For more details see sections on
+[schema derivation](schemas.md) and on supporting [custom types](customtypes.md) in general. Such a design provides
 better error reporting, in case one of the components required to create the json codec is missing.
 
 ```eval_rst
 .. note::
 
   Note that the process of deriving schemas, and deriving library-specific json encoders and decoders is entirely
-  separate. The first is controlled by tapir, the second - by the json library. Any customisation, e.g. for field
-  naming or inheritance strategies, must be done separately for both derivations.
+  separate. The first is controlled by tapir, the second - by the json library, unless you use the Pickler module mentioned below. 
+  Otherwise, any customisation, e.g. for field naming or inheritance strategies, must be done separately for both derivations.
 ```
 
+## Pickler
+
+Alternatively, instead of deriving schemas and json codecs separately, you can use the [tapir-pickler](pickler.md) module,
+which takes care of both derivation in a consistent way, keeping possibility to customize both with a common configuration API.
+
+
 ## Implicit json codecs
 
-If you have a custom, implicit `Codec[String, T, Json]` instance, you should use the `customCodecJsonBody[T]` method instead. 
-This description of endpoint input/output, instead of deriving a codec basing on other library-specific implicits, uses 
+If you have a custom, implicit `Codec[String, T, Json]` instance, you should use the `customCodecJsonBody[T]` method instead.
+This description of endpoint input/output, instead of deriving a codec basing on other library-specific implicits, uses
 the json codec that is in scope.
 
 ## JSON as string
 
 If you'd like to work with JSON bodies in a serialised `String` form, instead of integrating on a higher level using
-one of the libraries mentioned below, you should use the `stringJsonBody` input/output. Note that in this case, the 
+one of the libraries mentioned below, you should use the `stringJsonBody` input/output. Note that in this case, the
 serialising/deserialising of the body must be part of the [server logic](../server/logic.md).
 
 A schema can be provided in this case as well:
@@ -54,8 +60,8 @@ Next, import the package (or extend the `TapirJsonCirce` trait, see [MyTapir](..
 import sttp.tapir.json.circe._
 ```
 
-The above import brings into scope the `jsonBody[T]` body input/output description, which creates a codec, given an 
-in-scope circe `Encoder`/`Decoder` and a `Schema`. Circe includes a couple of approaches to generating encoders/decoders 
+The above import brings into scope the `jsonBody[T]` body input/output description, which creates a codec, given an
+in-scope circe `Encoder`/`Decoder` and a `Schema`. Circe includes a couple of approaches to generating encoders/decoders
 (manual, semi-auto and auto), so you may choose whatever suits you.
 
 Note that when using Circe's auto derivation, any encoders/decoders for custom types must be in scope as well.
@@ -75,7 +81,7 @@ val bookInput: EndpointIO[Book] = jsonBody[Book]
 
 ### Configuring the circe printer
 
-Circe lets you select an instance of `io.circe.Printer` to configure the way JSON objects are rendered. By default 
+Circe lets you select an instance of `io.circe.Printer` to configure the way JSON objects are rendered. By default
 Tapir uses `Printer.nospaces`, which would render:
 
 ```scala mdoc:compile-only
@@ -90,10 +96,10 @@ Json.obj(
 as
 
 ```json
-{"key1":"present","key2":null}
+{ "key1": "present", "key2": null }
 ```
 
-Suppose we would instead want to omit `null`-values from the object and pretty-print it. You can configure this by 
+Suppose we would instead want to omit `null`-values from the object and pretty-print it. You can configure this by
 overriding the `jsonPrinter` in `tapir.circe.json.TapirJsonCirce`:
 
 ```scala mdoc:compile-only
@@ -110,7 +116,7 @@ import MyTapirJsonCirce._
 Now the above JSON object will render as
 
 ```json
-{"key1":"present"}
+{ "key1": "present" }
 ```
 
 ## µPickle
@@ -148,6 +154,8 @@ Like Circe, µPickle allows you to control the rendered json output. Please see
 
 For more examples, including making a custom encoder/decoder, see [TapirJsonuPickleTests.scala](https://github.com/softwaremill/tapir/blob/master/json/upickle/src/test/scala/sttp/tapir/json/upickle/TapirJsonuPickleTests.scala)
 
+Check also the [tapir-pickler](pickler.md) module, which offers a high-level Pickler representation using uPickle underneath. This representation allows more flexible customiozation and takes care of generating both schemas and json codecs, which are kept in sync.
+
 ## Play JSON
 
 To use [Play JSON](https://github.com/playframework/play-json) add the following dependency to your project:
@@ -162,7 +170,7 @@ Next, import the package (or extend the `TapirJsonPlay` trait, see [MyTapir](../
 import sttp.tapir.json.play._
 ```
 
-Play JSON requires `Reads` and `Writes` implicit values in scope for each type you want to serialize. 
+Play JSON requires `Reads` and `Writes` implicit values in scope for each type you want to serialize.
 
 ## Spray JSON
 
@@ -178,7 +186,7 @@ Next, import the package (or extend the `TapirJsonSpray` trait, see [MyTapir](..
 import sttp.tapir.json.spray._
 ```
 
-Spray JSON requires a `JsonFormat` implicit value in scope for each type you want to serialize. 
+Spray JSON requires a `JsonFormat` implicit value in scope for each type you want to serialize.
 
 ## Tethys JSON
 
@@ -194,7 +202,7 @@ Next, import the package (or extend the `TapirJsonTethys` trait, see [MyTapir](.
 import sttp.tapir.json.tethysjson._
 ```
 
-Tethys JSON requires `JsonReader` and `JsonWriter` implicit values in scope for each type you want to serialize. 
+Tethys JSON requires `JsonReader` and `JsonWriter` implicit values in scope for each type you want to serialize.
 
 ## Jsoniter Scala
 
@@ -210,7 +218,7 @@ Next, import the package (or extend the `TapirJsonJsoniter` trait, see [MyTapir]
 import sttp.tapir.json.jsoniter._
 ```
 
-Jsoniter Scala requires `JsonValueCodec` implicit value in scope for each type you want to serialize. 
+Jsoniter Scala requires `JsonValueCodec` implicit value in scope for each type you want to serialize.
 
 ## Json4s
 
@@ -250,6 +258,7 @@ To use [zio-json](https://github.com/zio/zio-json), add the following dependency
 ```scala
 "com.softwaremill.sttp.tapir" %% "tapir-json-zio" % "@VERSION@"
 ```
+
 Next, import the package (or extend the `TapirJsonZio` trait, see [MyTapir](../mytapir.md) and add `TapirJsonZio` instead of `TapirCirceJson`):
 
 ```scala mdoc:compile-only
@@ -291,9 +300,9 @@ when these methods are called.
 
 ## Optional json bodies
 
-When the body is specified as an option, e.g. `jsonBody[Option[Book]]`, an empty body will be decoded as `None`. 
+When the body is specified as an option, e.g. `jsonBody[Option[Book]]`, an empty body will be decoded as `None`.
 
-This is implemented by passing `null` to the json-library-specific decoder, when the schema specifies that the value is 
+This is implemented by passing `null` to the json-library-specific decoder, when the schema specifies that the value is
 optional, and the body is empty.
 
 ## Next