Fix ClassCastException for hierarchical enum JSON encoding (#668)

- Add constructEnumCase helper to handle both CaseClass0 and Enum case schemas
- Update caseMap and jsonFieldDecoder to use type-safe case construction
- Add regression tests for hierarchical sealed trait enums

Fixes #668

Author: SolariSystems

zio-schema-json/shared/src/main/scala/zio/schema/codec/JsonCodec.scala

@@ -636,11 +636,27 @@ JsonCodec.Configuration makes it now possible to configure en-/decoding of empty
           }
       }
 
+    private def constructEnumCase[Z, A](case_ : Schema.Case[Z, A]): Z =
+      case_.schema match {
+        case cc: Schema.CaseClass0[A] =>
+          case_.construct(cc.defaultConstruct())
+        case e: Schema.Enum[A] =>
+          e.defaultValue match {
+            case Right(v) => case_.construct(v)
+            case Left(err) =>
+              throw new RuntimeException(s"Cannot construct enum case ${case_.id}: $err")
+          }
+        case other =>
+          throw new RuntimeException(
+            s"Unsupported case schema type for ${case_.id}: ${other.getClass.getSimpleName}"
+          )
+      }
+
     private def caseMap[Z](schema: Schema.Enum[Z], cfg: Configuration): Map[Z, String] =
       schema.nonTransientCases
         .map(
           case_ =>
-            case_.schema.asInstanceOf[Schema.CaseClass0[Z]].defaultConstruct() ->
+            constructEnumCase(case_) ->
               format(case_.caseName, cfg)
         )
         .toMap
@@ -936,7 +952,7 @@ JsonCodec.Configuration makes it now possible to configure en-/decoding of empty
               new JsonFieldDecoder[Z] {
                 private[this] val stringMatrix = new StringMatrix(caseNameAliases.keys.toArray)
                 private[this] val cases = caseNameAliases.values.map { case_ =>
-                  case_.schema.asInstanceOf[Schema.CaseClass0[Any]].defaultConstruct()
+                  constructEnumCase(case_)
                 }.toArray.asInstanceOf[Array[Z]]
 
                 override def unsafeDecodeField(trace: List[JsonError], in: String): Z = {
@@ -951,7 +967,7 @@ JsonCodec.Configuration makes it now possible to configure en-/decoding of empty
 
                 caseNameAliases.foreach {
                   case (name, case_) =>
-                    cases.put(name, case_.schema.asInstanceOf[Schema.CaseClass0[Z]].defaultConstruct())
+                    cases.put(name, constructEnumCase(case_))
                 }
 
                 override def unsafeDecodeField(trace: List[JsonError], in: String): Z = {

zio-schema-json/shared/src/test/scala/zio/schema/codec/JsonCodecSpec668.scala

@@ -0,0 +1,77 @@
+package zio.schema.codec
+
+import zio.schema._
+import zio.test._
+
+/**
+ * Regression test for issue #668:
+ * JSON codec built from auto-derived schema fails for enumeration with intermediate type
+ *
+ * The bug occurred when encoding hierarchical sealed trait enums where intermediate
+ * types exist (e.g., Animal > Mammal > Bison). The JsonCodec was incorrectly assuming
+ * all enum cases have CaseClass0 schemas, but intermediate sealed traits have Enum schemas.
+ */
+object JsonCodecSpec668 extends ZIOSpecDefault {
+
+  // Reproducer from issue #668
+  sealed trait Animal
+  object Animal {
+    sealed trait Mammal extends Animal
+    case object Bison extends Mammal
+
+    implicit val schema: Schema[Animal] = DeriveSchema.gen[Animal]
+  }
+
+  // Additional test case with deeper hierarchy
+  sealed trait Vehicle
+  object Vehicle {
+    sealed trait LandVehicle extends Vehicle
+    sealed trait Car extends LandVehicle
+    case object Sedan extends Car
+    case object Truck extends LandVehicle
+
+    implicit val schema: Schema[Vehicle] = DeriveSchema.gen[Vehicle]
+  }
+
+  def spec = suite("JsonCodec Issue #668 - Hierarchical Enums")(
+    test("should encode case object from intermediate sealed trait") {
+      val codec = JsonCodec.jsonCodec(Animal.schema)
+      val value: Animal = Animal.Bison
+
+      for {
+        encoded <- codec.encoder.encode(value)
+        decoded <- codec.decoder.decode(encoded)
+      } yield assertTrue(decoded == value)
+    },
+
+    test("should encode deeply nested enum hierarchy") {
+      val codec = JsonCodec.jsonCodec(Vehicle.schema)
+      val sedan: Vehicle = Vehicle.Sedan
+      val truck: Vehicle = Vehicle.Truck
+
+      for {
+        encodedSedan <- codec.encoder.encode(sedan)
+        decodedSedan <- codec.decoder.decode(encodedSedan)
+        encodedTruck <- codec.encoder.encode(truck)
+        decodedTruck <- codec.decoder.decode(encodedTruck)
+      } yield assertTrue(
+        decodedSedan == sedan,
+        decodedTruck == truck
+      )
+    },
+
+    test("should handle round-trip encoding/decoding") {
+      val codec = JsonCodec.jsonCodec(Animal.schema)
+      val value: Animal = Animal.Bison
+
+      for {
+        json <- codec.encoder.encode(value)
+        result <- codec.decoder.decode(json)
+        reencoded <- codec.encoder.encode(result)
+      } yield assertTrue(
+        result == value,
+        reencoded == json
+      )
+    }
+  )
+}