Add body json en-/decoding (#2287) (#3731)

Author: 987Nabil

docs/reference/body/body.md

@@ -119,6 +119,50 @@ val body = Body.from(person)
 
 In the above example, we used a JSON codec to encode the person object into a body. Similarly, we can use other codecs like Avro, Protobuf, etc.
 
+### From JSON
+
+ZIO HTTP provides convenient methods for creating a `Body` from JSON data using either **zio-schema** or **zio-json** libraries.
+
+#### Using ZIO Schema
+
+To create a JSON body using zio-schema, use the `Body.json` method with an implicit `Schema`:
+
+```scala mdoc:compile-only
+import zio.schema.{DeriveSchema, Schema}
+
+case class Person(name: String, age: Int)
+implicit val schema: Schema[Person] = DeriveSchema.gen[Person]
+
+val person = Person("John", 42)
+val body = Body.json(person)
+```
+
+This method automatically:
+- Encodes the value to JSON using zio-schema's JSON codec
+- Sets the `Content-Type` header to `application/json`
+
+#### Using ZIO JSON
+
+Alternatively, you can create a JSON body using zio-json with the `Body.jsonCodec` method:
+
+```scala mdoc:compile-only
+import zio.json.{DeriveJsonEncoder, JsonEncoder}
+
+case class Person(name: String, age: Int)
+implicit val encoder: JsonEncoder[Person] = DeriveJsonEncoder.gen[Person]
+
+val person = Person("John", 42)
+val body = Body.jsonCodec(person)
+```
+
+This method:
+- Encodes the value to JSON using zio-json's encoder
+- Sets the `Content-Type` header to `application/json`
+
+**When to use which?**
+- Use `Body.json` (zio-schema) when you're already using zio-schema in your project or need advanced schema features
+- Use `Body.jsonCodec` (zio-json) when you prefer zio-json's dedicated JSON library or need fine-grained control over JSON encoding
+
 ### From ZIO Streams
 
 There are several ways to create a `Body` from a ZIO Stream:
@@ -346,6 +390,70 @@ val body          = Body.from(person)
 val decodedPerson = body.to[Person]
 ```
 
+### Decoding JSON Body Content
+
+ZIO HTTP provides convenient methods for decoding JSON body content using either **zio-schema** or **zio-json** libraries.
+
+#### Using ZIO Schema
+
+To decode a JSON body using zio-schema, use the `Body#asJson` method with an implicit `Schema`:
+
+```scala mdoc:compile-only
+import zio.schema.{DeriveSchema, Schema}
+
+case class Person(name: String, age: Int)
+implicit val schema: Schema[Person] = DeriveSchema.gen[Person]
+
+val jsonBody = Body.fromString("""{"name":"John","age":42}""")
+val decodedPerson: Task[Person] = jsonBody.asJson[Person]
+```
+
+This method:
+- Decodes the JSON body content using zio-schema's JSON codec
+- Returns a `Task[A]` that will fail if the JSON is invalid or doesn't match the schema
+
+#### Using ZIO JSON
+
+Alternatively, you can decode a JSON body using zio-json with the `Body#asJsonFromCodec` method:
+
+```scala mdoc:compile-only
+import zio.json.{DeriveJsonDecoder, JsonDecoder}
+
+case class Person(name: String, age: Int)
+implicit val decoder: JsonDecoder[Person] = DeriveJsonDecoder.gen[Person]
+
+val jsonBody = Body.fromString("""{"name":"John","age":42}""")
+val decodedPerson: Task[Person] = jsonBody.asJsonFromCodec[Person]
+```
+
+This method:
+- Decodes the JSON body content using zio-json's decoder
+- Returns a `Task[A]` that will fail if the JSON is invalid or cannot be decoded
+
+**When to use which?**
+- Use `asJson` (zio-schema) when you're already using zio-schema in your project or need schema validation
+- Use `asJsonFromCodec` (zio-json) when you prefer zio-json's dedicated JSON library or need fine-grained control over JSON decoding
+
+**Round-trip Example:**
+
+Here's a complete example showing encoding and decoding with zio-schema:
+
+```scala mdoc:compile-only
+import zio.schema.{DeriveSchema, Schema}
+
+case class Person(name: String, age: Int)
+implicit val schema: Schema[Person] = DeriveSchema.gen[Person]
+
+val program = for {
+  // Create a JSON body
+  person <- ZIO.succeed(Person("Alice", 30))
+  body = Body.json(person)
+  
+  // Decode it back
+  decoded <- body.asJson[Person]
+} yield decoded
+```
+
 ### Retrieving Raw Body Content
 
 We can access the content of the body as an array of bytes or a chunk of bytes. This is useful when dealing with binary data. Here's how you can do it:

zio-http/jvm/src/test/scala/zio/http/BodySpec.scala

@@ -18,16 +18,27 @@ package zio.http
 
 import java.io.File
 
+import zio.json.{DeriveJsonDecoder, DeriveJsonEncoder, JsonDecoder, JsonEncoder}
 import zio.test.Assertion.equalTo
 import zio.test.TestAspect.timeout
 import zio.test._
 import zio.{Scope, durationInt}
 
 import zio.stream.ZStream
 
+import zio.schema.{DeriveSchema, Schema}
+
 object BodySpec extends ZIOHttpSpec {
   private val testFile = new File(getClass.getResource("/TestFile.txt").getPath)
 
+  case class Person(name: String, age: Int)
+
+  object Person {
+    implicit val schema: Schema[Person]       = DeriveSchema.gen[Person]
+    implicit val encoder: JsonEncoder[Person] = DeriveJsonEncoder.gen[Person]
+    implicit val decoder: JsonDecoder[Person] = DeriveJsonDecoder.gen[Person]
+  }
+
   override def spec: Spec[TestEnvironment with Scope, Throwable] =
     suite("BodySpec")(
       suite("outgoing")(
@@ -56,6 +67,93 @@ object BodySpec extends ZIOHttpSpec {
           ),
         ),
       ),
+      suite("json")(
+        suite("Body.json with zio-schema")(
+          test("creates JSON body from case class") {
+            val person = Person("John", 42)
+            val body   = Body.json(person)
+            for {
+              content <- body.asString
+            } yield assertTrue(
+              content.contains("John"),
+              content.contains("42"),
+              body.mediaType.contains(MediaType.application.json),
+            )
+          },
+          test("round-trip encoding and decoding") {
+            val person = Person("Alice", 30)
+            val body   = Body.json(person)
+            for {
+              decoded <- body.asJson[Person]
+            } yield assertTrue(decoded == person)
+          },
+        ),
+        suite("Body.json with zio-json")(
+          test("creates JSON body from case class") {
+            val person = Person("Jane", 25)
+            val body   = Body.jsonCodec(person)
+            for {
+              content <- body.asString
+            } yield assertTrue(
+              content.contains("Jane"),
+              content.contains("25"),
+              body.mediaType.contains(MediaType.application.json),
+            )
+          },
+          test("round-trip encoding and decoding") {
+            val person = Person("Bob", 35)
+            val body   = Body.jsonCodec(person)
+            for {
+              decoded <- body.asJsonFromCodec[Person]
+            } yield assertTrue(decoded == person)
+          },
+        ),
+        suite("Body.asJson with zio-schema")(
+          test("decodes JSON string to case class") {
+            val jsonString = """{"name":"Charlie","age":28}"""
+            val body       = Body.fromString(jsonString)
+            for {
+              decoded <- body.asJson[Person]
+            } yield assertTrue(
+              decoded.name == "Charlie",
+              decoded.age == 28,
+            )
+          },
+          test("fails on invalid JSON") {
+            val invalidJson = """{"name":"Invalid"}"""
+            val body        = Body.fromString(invalidJson)
+            for {
+              result <- body.asJson[Person].exit
+            } yield assertTrue(result.isFailure)
+          },
+        ),
+        suite("Body.asJsonZio with zio-json")(
+          test("decodes JSON string to case class") {
+            val jsonString = """{"name":"David","age":40}"""
+            val body       = Body.fromString(jsonString)
+            for {
+              decoded <- body.asJsonFromCodec[Person]
+            } yield assertTrue(
+              decoded.name == "David",
+              decoded.age == 40,
+            )
+          },
+          test("fails on invalid JSON") {
+            val invalidJson = """{"invalid":"json"}"""
+            val body        = Body.fromString(invalidJson)
+            for {
+              result <- body.asJsonFromCodec[Person].exit
+            } yield assertTrue(result.isFailure)
+          },
+          test("fails on malformed JSON") {
+            val malformedJson = """not valid json"""
+            val body          = Body.fromString(malformedJson)
+            for {
+              result <- body.asJsonFromCodec[Person].exit
+            } yield assertTrue(result.isFailure)
+          },
+        ),
+      ),
       suite("mediaType")(
         test("updates the Body media type with the provided value") {
           val body = Body.fromString("test").contentType(MediaType.text.plain)