codegen: Fix issues with jsoniter in scala3 (#3963)

openapi-codegen/core/src/main/scala/sttp/tapir/codegen/ClassDefinitionGenerator.scala

@@ -48,7 +48,6 @@ class ClassDefinitionGenerator {
       jsonSerdeLib,
       jsonParamRefs,
       allTransitiveJsonParamRefs,
-      fullModelPath,
       validateNonDiscriminatedOneOfs,
       adtInheritanceMap.mapValues(_.map(_._1)),
       targetScala3

openapi-codegen/core/src/main/scala/sttp/tapir/codegen/EnumGenerator.scala

@@ -35,8 +35,10 @@ object EnumGenerator {
         case _ if !jsonParamRefs.contains(name)                                   => " derives enumextensions.EnumMirror"
         case JsonSerdeLib.Circe if !queryParamRefs.contains(name) => " derives org.latestbit.circe.adt.codec.JsonTaggedAdt.PureCodec"
         case JsonSerdeLib.Circe => " derives org.latestbit.circe.adt.codec.JsonTaggedAdt.PureCodec, enumextensions.EnumMirror"
-        case JsonSerdeLib.Jsoniter | JsonSerdeLib.Zio if !queryParamRefs.contains(name) => s" extends java.lang.Enum[$name]"
-        case JsonSerdeLib.Jsoniter | JsonSerdeLib.Zio => s" extends java.lang.Enum[$name] derives enumextensions.EnumMirror"
+        case JsonSerdeLib.Jsoniter if !queryParamRefs.contains(name) => ""
+        case JsonSerdeLib.Jsoniter => " derives enumextensions.EnumMirror"
+        case JsonSerdeLib.Zio if !queryParamRefs.contains(name) => s" extends java.lang.Enum[$name]"
+        case JsonSerdeLib.Zio                                   => s" extends java.lang.Enum[$name] derives enumextensions.EnumMirror"
       }
       s"""$maybeCompanion
          |enum $name$maybeCodecExtensions {

openapi-codegen/core/src/main/scala/sttp/tapir/codegen/JsonSerdeGenerator.scala

@@ -25,7 +25,6 @@ object JsonSerdeGenerator {
       jsonSerdeLib: JsonSerdeLib.JsonSerdeLib,
       jsonParamRefs: Set[String],
       allTransitiveJsonParamRefs: Set[String],
-      fullModelPath: String,
       validateNonDiscriminatedOneOfs: Boolean,
       adtInheritanceMap: Map[String, Seq[String]],
       targetScala3: Boolean
@@ -41,7 +40,6 @@ object JsonSerdeGenerator {
           jsonParamRefs,
           allTransitiveJsonParamRefs,
           adtInheritanceMap,
-          if (fullModelPath.isEmpty) None else Some(fullModelPath),
           validateNonDiscriminatedOneOfs
         )
       case JsonSerdeLib.Zio => genZioSerdes(doc, allSchemas, allTransitiveJsonParamRefs, validateNonDiscriminatedOneOfs, targetScala3)
@@ -233,7 +231,6 @@ object JsonSerdeGenerator {
       jsonParamRefs: Set[String],
       allTransitiveJsonParamRefs: Set[String],
       adtInheritanceMap: Map[String, Seq[String]],
-      fullModelPath: Option[String],
       validateNonDiscriminatedOneOfs: Boolean
   ): Option[String] = {
     // For jsoniter-scala, we define explicit serdes for any 'primitive' params (e.g. List[java.util.UUID]) that we reference.
@@ -271,7 +268,7 @@ object JsonSerdeGenerator {
           Some(genJsoniterEnumSerde(name))
         // For ADTs, generate the serde if it's referenced in any json model
         case (name, schema: OpenapiSchemaOneOf) if allTransitiveJsonParamRefs.contains(name) =>
-          Some(generateJsoniterAdtSerde(allSchemas, name, schema, fullModelPath, validateNonDiscriminatedOneOfs))
+          Some(generateJsoniterAdtSerde(allSchemas, name, schema, validateNonDiscriminatedOneOfs))
         case (_, _: OpenapiSchemaObject | _: OpenapiSchemaMap | _: OpenapiSchemaEnum | _: OpenapiSchemaOneOf) => None
         case (n, x) => throw new NotImplementedError(s"Only objects, enums, maps and oneOf supported! (for $n found ${x})")
       })
@@ -304,10 +301,8 @@ object JsonSerdeGenerator {
       allSchemas: Map[String, OpenapiSchemaType],
       name: String,
       schema: OpenapiSchemaOneOf,
-      maybeFullModelPath: Option[String],
       validateNonDiscriminatedOneOfs: Boolean
   ): String = {
-    val fullPathPrefix = maybeFullModelPath.map(_ + ".").getOrElse("")
     val uncapitalisedName = BasicGenerator.uncapitalise(name)
     schema match {
       case OpenapiSchemaOneOf(_, Some(discriminator)) =>
@@ -323,11 +318,11 @@ object JsonSerdeGenerator {
         val body = if (schemaToJsonMapping.exists { case (className, jsonValue) => className != jsonValue }) {
           val discriminatorMap = indent(2)(
             schemaToJsonMapping
-              .map { case (k, v) => s"""case "$fullPathPrefix$k" => "$v"""" }
+              .map { case (k, v) => s"""case "$k" => "$v"""" }
               .mkString("\n", "\n", "\n")
           )
           val config =
-            s"""$jsoniterBaseConfig.withRequireDiscriminatorFirst(false).withDiscriminatorFieldName(Some("${discriminator.propertyName}")).withAdtLeafClassNameMapper{$discriminatorMap}"""
+            s"""$jsoniterBaseConfig.withRequireDiscriminatorFirst(false).withDiscriminatorFieldName(Some("${discriminator.propertyName}")).withAdtLeafClassNameMapper(x => com.github.plokhotnyuk.jsoniter_scala.macros.JsonCodecMaker.simpleClassName(x) match {$discriminatorMap})"""
           val serde =
             s"implicit lazy val ${uncapitalisedName}Codec: $jsoniterPkgCore.JsonValueCodec[$name] = $jsoniterPkgMacros.JsonCodecMaker.make($config)"
 

openapi-codegen/sbt-plugin/src/sbt-test/sbt-openapi-codegen/oneOf-json-roundtrip_jsoniter_scala3/Expected.scala.txt

@@ -0,0 +1,101 @@
+package sttp.tapir.generated
+
+object TapirGeneratedEndpoints {
+
+  import sttp.tapir._
+  import sttp.tapir.model._
+  import sttp.tapir.generic.auto._
+  import sttp.tapir.json.jsoniter._
+  import com.github.plokhotnyuk.jsoniter_scala.macros._
+  import com.github.plokhotnyuk.jsoniter_scala.core._
+
+  import sttp.tapir.generated.TapirGeneratedEndpointsJsonSerdes._
+  import TapirGeneratedEndpointsSchemas._
+
+
+  case class CommaSeparatedValues[T](values: List[T])
+  case class ExplodedValues[T](values: List[T])
+  trait ExtraParamSupport[T] {
+    def decode(s: String): sttp.tapir.DecodeResult[T]
+    def encode(t: T): String
+  }
+  implicit def makePathCodecFromSupport[T](implicit support: ExtraParamSupport[T]): sttp.tapir.Codec[String, T, sttp.tapir.CodecFormat.TextPlain] = {
+    sttp.tapir.Codec.string.mapDecode(support.decode)(support.encode)
+  }
+  implicit def makeQueryCodecFromSupport[T](implicit support: ExtraParamSupport[T]): sttp.tapir.Codec[List[String], T, sttp.tapir.CodecFormat.TextPlain] = {
+    sttp.tapir.Codec.listHead[String, String, sttp.tapir.CodecFormat.TextPlain]
+      .mapDecode(support.decode)(support.encode)
+  }
+  implicit def makeQueryOptCodecFromSupport[T](implicit support: ExtraParamSupport[T]): sttp.tapir.Codec[List[String], Option[T], sttp.tapir.CodecFormat.TextPlain] = {
+    sttp.tapir.Codec.listHeadOption[String, String, sttp.tapir.CodecFormat.TextPlain]
+      .mapDecode(maybeV => DecodeResult.sequence(maybeV.toSeq.map(support.decode)).map(_.headOption))(_.map(support.encode))
+  }
+  implicit def makeUnexplodedQuerySeqCodecFromListHead[T](implicit support: sttp.tapir.Codec[List[String], T, sttp.tapir.CodecFormat.TextPlain]): sttp.tapir.Codec[List[String], CommaSeparatedValues[T], sttp.tapir.CodecFormat.TextPlain] = {
+    sttp.tapir.Codec.listHead[String, String, sttp.tapir.CodecFormat.TextPlain]
+      .mapDecode(values => DecodeResult.sequence(values.split(',').toSeq.map(e => support.rawDecode(List(e)))).map(s => CommaSeparatedValues(s.toList)))(_.values.map(support.encode).mkString(","))
+  }
+  implicit def makeUnexplodedQueryOptSeqCodecFromListHead[T](implicit support: sttp.tapir.Codec[List[String], T, sttp.tapir.CodecFormat.TextPlain]): sttp.tapir.Codec[List[String], Option[CommaSeparatedValues[T]], sttp.tapir.CodecFormat.TextPlain] = {
+    sttp.tapir.Codec.listHeadOption[String, String, sttp.tapir.CodecFormat.TextPlain]
+      .mapDecode{
+        case None => DecodeResult.Value(None)
+        case Some(values) => DecodeResult.sequence(values.split(',').toSeq.map(e => support.rawDecode(List(e)))).map(r => Some(CommaSeparatedValues(r.toList)))
+      }(_.map(_.values.map(support.encode).mkString(",")))
+  }
+  implicit def makeExplodedQuerySeqCodecFromListSeq[T](implicit support: sttp.tapir.Codec[List[String], List[T], sttp.tapir.CodecFormat.TextPlain]): sttp.tapir.Codec[List[String], ExplodedValues[T], sttp.tapir.CodecFormat.TextPlain] = {
+    support.mapDecode(l => DecodeResult.Value(ExplodedValues(l)))(_.values)
+  }
+
+
+  sealed trait ADTWithoutDiscriminator
+  sealed trait ADTWithDiscriminator
+  sealed trait ADTWithDiscriminatorNoMapping
+  case class SubtypeWithoutD1 (
+    s: String,
+    i: Option[Int] = None,
+    a: Seq[String],
+    absent: Option[String] = None
+  ) extends ADTWithoutDiscriminator
+  case class SubtypeWithD1 (
+    s: String,
+    i: Option[Int] = None,
+    d: Option[Double] = None
+  ) extends ADTWithDiscriminator with ADTWithDiscriminatorNoMapping
+  case class SubtypeWithoutD3 (
+    s: String,
+    i: Option[Int] = None,
+    e: Option[AnEnum] = None,
+    absent: Option[String] = None
+  ) extends ADTWithoutDiscriminator
+  case class SubtypeWithoutD2 (
+    a: Seq[String],
+    absent: Option[String] = None
+  ) extends ADTWithoutDiscriminator
+  case class SubtypeWithD2 (
+    s: String,
+    a: Option[Seq[String]] = None
+  ) extends ADTWithDiscriminator with ADTWithDiscriminatorNoMapping
+
+  enum AnEnum {
+    case Foo, Bar, Baz
+  }
+
+
+
+  lazy val putAdtTest =
+    endpoint
+      .put
+      .in(("adt" / "test"))
+      .in(jsonBody[ADTWithoutDiscriminator])
+      .out(jsonBody[ADTWithoutDiscriminator].description("successful operation"))
+
+  lazy val postAdtTest =
+    endpoint
+      .post
+      .in(("adt" / "test"))
+      .in(jsonBody[ADTWithDiscriminatorNoMapping])
+      .out(jsonBody[ADTWithDiscriminator].description("successful operation"))
+
+
+  lazy val generatedEndpoints = List(putAdtTest, postAdtTest)
+
+}

openapi-codegen/sbt-plugin/src/sbt-test/sbt-openapi-codegen/oneOf-json-roundtrip_jsoniter_scala3/build.sbt

@@ -0,0 +1,38 @@
+lazy val root = (project in file("."))
+  .enablePlugins(OpenapiCodegenPlugin)
+  .settings(
+    scalaVersion := "3.3.3",
+    version := "0.1",
+    openapiJsonSerdeLib := "jsoniter"
+  )
+
+libraryDependencies ++= Seq(
+  "com.softwaremill.sttp.tapir" %% "tapir-jsoniter-scala" % "1.10.0",
+  "com.softwaremill.sttp.tapir" %% "tapir-openapi-docs" % "1.10.0",
+  "com.softwaremill.sttp.apispec" %% "openapi-circe-yaml" % "0.8.0",
+  "com.beachape" %% "enumeratum" % "1.7.4",
+  "com.github.plokhotnyuk.jsoniter-scala" %% "jsoniter-scala-core" % "2.30.7",
+  "com.github.plokhotnyuk.jsoniter-scala" %% "jsoniter-scala-macros" % "2.30.7" % "compile-internal",
+  "org.scalatest" %% "scalatest" % "3.2.19" % Test,
+  "com.softwaremill.sttp.tapir" %% "tapir-sttp-stub-server" % "1.10.0" % Test
+)
+
+import sttp.tapir.sbt.OpenapiCodegenPlugin.autoImport.{openapiJsonSerdeLib, openapiUseHeadTagForObjectName}
+
+import scala.io.Source
+
+TaskKey[Unit]("check") := {
+  val generatedCode =
+    Source.fromFile("target/scala-3.3.3/src_managed/main/sbt-openapi-codegen/TapirGeneratedEndpoints.scala").getLines.mkString("\n")
+  val expected = Source.fromFile("Expected.scala.txt").getLines.mkString("\n")
+  val generatedTrimmed =
+    generatedCode.linesIterator.zipWithIndex.filterNot(_._1.forall(_.isWhitespace)).map { case (a, i) => a.trim -> i }.toSeq
+  val expectedTrimmed = expected.linesIterator.filterNot(_.forall(_.isWhitespace)).map(_.trim).toSeq
+  if (generatedTrimmed.size != expectedTrimmed.size)
+    sys.error(s"expected ${expectedTrimmed.size} non-empty lines, found ${generatedTrimmed.size}")
+  generatedTrimmed.zip(expectedTrimmed).foreach { case ((a, i), b) =>
+    if (a != b) sys.error(s"Generated code did not match (expected '$b' on line $i, found '$a')")
+  }
+  println("Skipping swagger roundtrip for petstore")
+  ()
+}

openapi-codegen/sbt-plugin/src/sbt-test/sbt-openapi-codegen/oneOf-json-roundtrip_jsoniter_scala3/project/build.properties

@@ -0,0 +1 @@
+sbt.version=1.10.1

openapi-codegen/sbt-plugin/src/sbt-test/sbt-openapi-codegen/oneOf-json-roundtrip_jsoniter_scala3/project/plugins.sbt

@@ -0,0 +1,11 @@
+{
+  val pluginVersion = System.getProperty("plugin.version")
+  if (pluginVersion == null)
+    throw new RuntimeException("""|
+                                  |
+                                  |The system property 'plugin.version' is not defined.
+                                  |Specify this property using the scriptedLaunchOpts -D.
+                                  |
+                                  |""".stripMargin)
+  else addSbtPlugin("com.softwaremill.sttp.tapir" % "sbt-openapi-codegen" % pluginVersion)
+}

openapi-codegen/sbt-plugin/src/sbt-test/sbt-openapi-codegen/oneOf-json-roundtrip_jsoniter_scala3/src/main/scala/Main.scala

@@ -0,0 +1,12 @@
+object Main extends App {
+  import sttp.apispec.openapi.circe.yaml._
+  import sttp.tapir.generated._
+  import sttp.tapir.docs.openapi._
+
+  val docs = OpenAPIDocsInterpreter().toOpenAPI(TapirGeneratedEndpoints.generatedEndpoints, "My Bookshop", "1.0")
+
+  import java.nio.file.{Paths, Files}
+  import java.nio.charset.StandardCharsets
+
+  Files.write(Paths.get("target/swagger.yaml"), docs.toYaml.getBytes(StandardCharsets.UTF_8))
+}

openapi-codegen/sbt-plugin/src/sbt-test/sbt-openapi-codegen/oneOf-json-roundtrip_jsoniter_scala3/src/test/scala/JsonRoundtrip.scala

@@ -0,0 +1,147 @@
+import com.github.plokhotnyuk.jsoniter_scala.core.writeToString
+import io.circe.parser.parse
+import org.scalatest.freespec.AnyFreeSpec
+import org.scalatest.matchers.should.Matchers
+import sttp.client3.UriContext
+import sttp.client3.testing.SttpBackendStub
+import sttp.tapir.generated.{TapirGeneratedEndpoints, TapirGeneratedEndpointsJsonSerdes}
+import sttp.tapir.generated.TapirGeneratedEndpoints.*
+import sttp.tapir.generated.TapirGeneratedEndpointsSchemas.*
+import TapirGeneratedEndpointsJsonSerdes._
+import sttp.tapir.server.stub.TapirStubInterpreter
+
+import scala.concurrent.duration.DurationInt
+import scala.concurrent.{Await, Future}
+import scala.concurrent.ExecutionContext.Implicits.global
+
+class JsonRoundtrip extends AnyFreeSpec with Matchers {
+  "oneOf without discriminator can be round-tripped by generated serdes" in {
+    val route = TapirGeneratedEndpoints.putAdtTest.serverLogic[Future]({
+      case foo: SubtypeWithoutD1 =>
+        Future successful Right[Unit, ADTWithoutDiscriminator](SubtypeWithoutD1(foo.s + "+SubtypeWithoutD1", foo.i, foo.a))
+      case foo: SubtypeWithoutD2 => Future successful Right[Unit, ADTWithoutDiscriminator](SubtypeWithoutD2(foo.a :+ "+SubtypeWithoutD2"))
+      case foo: SubtypeWithoutD3 =>
+        Future successful Right[Unit, ADTWithoutDiscriminator](SubtypeWithoutD3(foo.s + "+SubtypeWithoutD3", foo.i, foo.e))
+    })
+
+    val stub = TapirStubInterpreter(SttpBackendStub.asynchronousFuture)
+      .whenServerEndpoint(route)
+      .thenRunLogic()
+      .backend()
+
+    def normalise(json: String): String = parse(json).toTry.get.noSpacesSortKeys
+    locally {
+      val reqBody = SubtypeWithoutD1("a string", Some(123), Seq("string 1", "string 2"))
+      val reqJsonBody = writeToString(reqBody)
+      val respBody = SubtypeWithoutD1("a string+SubtypeWithoutD1", Some(123), Seq("string 1", "string 2"))
+      val respJsonBody = writeToString(respBody)
+      reqJsonBody shouldEqual """{"s":"a string","i":123,"a":["string 1","string 2"]}"""
+      respJsonBody shouldEqual """{"s":"a string+SubtypeWithoutD1","i":123,"a":["string 1","string 2"]}"""
+      Await.result(
+        sttp.client3.basicRequest
+          .put(uri"http://test.com/adt/test")
+          .body(reqJsonBody)
+          .send(stub)
+          .map { resp =>
+            resp.code.code === 200
+            resp.body shouldEqual Right(respJsonBody)
+          },
+        1.second
+      )
+    }
+
+    locally {
+      val reqBody = SubtypeWithoutD2(Seq("string 1", "string 2"))
+      val reqJsonBody = writeToString(reqBody)
+      val respBody = SubtypeWithoutD2(Seq("string 1", "string 2", "+SubtypeWithoutD2"))
+      val respJsonBody = writeToString(respBody)
+      reqJsonBody shouldEqual """{"a":["string 1","string 2"]}"""
+      respJsonBody shouldEqual """{"a":["string 1","string 2","+SubtypeWithoutD2"]}"""
+      Await.result(
+        sttp.client3.basicRequest
+          .put(uri"http://test.com/adt/test")
+          .body(reqJsonBody)
+          .send(stub)
+          .map { resp =>
+            resp.body shouldEqual Right(respJsonBody)
+            resp.code.code === 200
+          },
+        1.second
+      )
+    }
+
+    locally {
+      val reqBody = SubtypeWithoutD3("a string", Some(123), Some(AnEnum.Foo))
+      val reqJsonBody = writeToString(reqBody)
+      val respBody = SubtypeWithoutD3("a string+SubtypeWithoutD3", Some(123), Some(AnEnum.Foo))
+      val respJsonBody = writeToString(respBody)
+      reqJsonBody shouldEqual """{"s":"a string","i":123,"e":"Foo"}"""
+      respJsonBody shouldEqual """{"s":"a string+SubtypeWithoutD3","i":123,"e":"Foo"}"""
+      Await.result(
+        sttp.client3.basicRequest
+          .put(uri"http://test.com/adt/test")
+          .body(reqJsonBody)
+          .send(stub)
+          .map { resp =>
+            resp.body shouldEqual Right(respJsonBody)
+            resp.code.code === 200
+          },
+        1.second
+      )
+    }
+  }
+  "oneOf with discriminator can be round-tripped by generated serdes" in {
+    val route = TapirGeneratedEndpoints.postAdtTest.serverLogic[Future]({
+      case foo: SubtypeWithD1 => Future successful Right[Unit, ADTWithDiscriminator](SubtypeWithD1(foo.s + "+SubtypeWithD1", foo.i, foo.d))
+      case foo: SubtypeWithD2 => Future successful Right[Unit, ADTWithDiscriminator](SubtypeWithD2(foo.s + "+SubtypeWithD2", foo.a))
+    })
+
+    val stub = TapirStubInterpreter(SttpBackendStub.asynchronousFuture)
+      .whenServerEndpoint(route)
+      .thenRunLogic()
+      .backend()
+
+    def normalise(json: String): String = parse(json).toTry.get.noSpacesSortKeys
+
+    locally {
+      val reqBody: ADTWithDiscriminatorNoMapping = SubtypeWithD1("a string", Some(123), Some(23.4))
+      val reqJsonBody = writeToString(reqBody)
+      val respBody: ADTWithDiscriminator = SubtypeWithD1("a string+SubtypeWithD1", Some(123), Some(23.4))
+      val respJsonBody = writeToString(respBody)
+      reqJsonBody shouldEqual """{"type":"SubtypeWithD1","s":"a string","i":123,"d":23.4}"""
+      respJsonBody shouldEqual """{"type":"SubA","s":"a string+SubtypeWithD1","i":123,"d":23.4}"""
+      Await.result(
+        sttp.client3.basicRequest
+          .post(uri"http://test.com/adt/test")
+          .body(reqJsonBody)
+          .send(stub)
+          .map { resp =>
+            resp.code.code === 200
+            resp.body shouldEqual Right(respJsonBody)
+          },
+        1.second
+      )
+    }
+
+    locally {
+      val reqBody: ADTWithDiscriminatorNoMapping = SubtypeWithD2("a string", Some(Seq("string 1", "string 2")))
+      val reqJsonBody = writeToString(reqBody)
+      val respBody: ADTWithDiscriminator = SubtypeWithD2("a string+SubtypeWithD2", Some(Seq("string 1", "string 2")))
+      val respJsonBody = writeToString(respBody)
+      reqJsonBody shouldEqual """{"type":"SubtypeWithD2","s":"a string","a":["string 1","string 2"]}"""
+      respJsonBody shouldEqual """{"type":"SubB","s":"a string+SubtypeWithD2","a":["string 1","string 2"]}"""
+      Await.result(
+        sttp.client3.basicRequest
+          .post(uri"http://test.com/adt/test")
+          .body(reqJsonBody)
+          .send(stub)
+          .map { resp =>
+            resp.code.code === 200
+            resp.body shouldEqual Right(respJsonBody)
+          },
+        1.second
+      )
+    }
+
+  }
+}