Refactor to use ZIO Blocks Schema instead of jsoniter-scala

Co-authored-by: hrj <345879+hrj@users.noreply.github.com>

Author: google-labs-jules[bot]

build.sbt

@@ -14,8 +14,8 @@ lazy val root = (project in file(".")).settings(
   name := "LibreCaptcha",
   libraryDependencies += "com.sksamuel.scrimage" % "scrimage-core" % "4.3.10",
   libraryDependencies += "com.sksamuel.scrimage" % "scrimage-filters" % "4.3.10",
-  libraryDependencies += "com.github.plokhotnyuk.jsoniter-scala" %% "jsoniter-scala-core" % "2.38.9",
-  libraryDependencies += "com.github.plokhotnyuk.jsoniter-scala" %% "jsoniter-scala-macros" % "2.38.9" % "provided"
+  libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.31",
+
 )
 
 Compile / unmanagedResourceDirectories += { baseDirectory.value / "lib" }

src/main/scala/lc/core/captchaProviders.scala

@@ -5,6 +5,8 @@ import lc.captchas.interfaces.ChallengeProvider
 import lc.captchas.interfaces.Challenge
 import scala.collection.mutable.Map
 import lc.misc.HelperFunctions
+import zio.blocks.schema.json.JsonFormat
+import java.nio.ByteBuffer
 
 class CaptchaProviders(config: Config) {
   private val providers = Map(
@@ -30,13 +32,18 @@ class CaptchaProviders(config: Config) {
   }
 
   private def filterProviderByParam(param: Parameters): Iterable[(String, String)] = {
+    val codec = zio.blocks.schema.json.Json.schema.derive(JsonFormat.deriver)
+
     val configFilter = for {
       configValue <- captchaConfig
       if configValue.allowedLevels.contains(param.level)
       if configValue.allowedMedia.contains(param.media)
       if configValue.allowedInputType.contains(param.input_type)
       if configValue.allowedSizes.contains(param.size)
-    } yield (configValue.name, configValue.config.string)
+    } yield {
+      val strConfig = new String(BufferEncoder.encode(configValue.config, codec), "UTF-8")
+      (configValue.name, strConfig)
+    }
 
     val providerFilter = for {
       providerValue <- configFilter

src/main/scala/lc/core/config.scala

@@ -1,10 +1,12 @@
 package lc.core
 
 import scala.io.Source.fromFile
-import com.github.plokhotnyuk.jsoniter_scala.core._
+import zio.blocks.schema._
+import zio.blocks.schema.json._
 import java.io.{FileNotFoundException, File, PrintWriter}
 import java.{util => ju}
 import lc.misc.HelperFunctions
+import java.nio.ByteBuffer
 
 class Config(configFilePath: String) {
 
@@ -33,7 +35,11 @@ class Config(configFilePath: String) {
       }
     }
 
-  private val appConfig = readFromString[AppConfig](configString)
+  private val appConfigEither = AppConfig.codec.decode(ByteBuffer.wrap(configString.getBytes("UTF-8")))
+  private val appConfig = appConfigEither match {
+    case Right(conf) => conf
+    case Left(err) => throw new Exception(err.toString)
+  }
   private val configFields: ConfigField = appConfig.toConfigField
 
   val port: Int = configFields.portInt.getOrElse(8888)
@@ -71,36 +77,36 @@ class Config(configFilePath: String) {
           allowedMedia = List("image/png"),
           allowedInputType = List("text"),
           allowedSizes = List("350x100"),
-          config = JSONString("{}")
+          config = Json.Object()
         ),
         CaptchaConfig(
           name = "PoppingCharactersCaptcha",
           allowedLevels = List("hard"),
           allowedMedia = List("image/gif"),
           allowedInputType = List("text"),
           allowedSizes = List("350x100"),
-          config = JSONString("{}")
+          config = Json.Object()
         ),
         CaptchaConfig(
           name = "ShadowTextCaptcha",
           allowedLevels = List("easy"),
           allowedMedia = List("image/png"),
           allowedInputType = List("text"),
           allowedSizes = List("350x100"),
-          config = JSONString("{}")
+          config = Json.Object()
         ),
         CaptchaConfig(
           name = "RainDropsCaptcha",
           allowedLevels = List("easy", "medium"),
           allowedMedia = List("image/gif"),
           allowedInputType = List("text"),
           allowedSizes = List("350x100"),
-          config = JSONString("{}")
+          config = Json.Object()
         )
       )
     )
 
-    writeToString(defaultConfig, WriterConfig.withIndentionStep(2))
+    new String(BufferEncoder.encode(defaultConfig, AppConfig.codec), "UTF-8")
   }
 
 }

src/main/scala/lc/core/models.scala

@@ -1,62 +1,88 @@
 package lc.core
 
-import com.github.plokhotnyuk.jsoniter_scala.macros._
-import com.github.plokhotnyuk.jsoniter_scala.core._
+import zio.blocks.schema._
+import zio.blocks.schema.json._
+import zio.blocks.schema.codec.BinaryCodec
+import java.nio.ByteBuffer
 
 trait ByteConvert { def toBytes(): Array[Byte] }
 case class Size(height: Int, width: Int)
 
 case class Parameters(level: String, media: String, input_type: String, size: String)
 object Parameters {
-  implicit val codec: JsonValueCodec[Parameters] = JsonCodecMaker.make
+  implicit val schema: Schema[Parameters] = Schema.derived
+  implicit val codec: BinaryCodec[Parameters] = schema.derive(JsonFormat.deriver)
 }
 
-case class Id(id: String) extends ByteConvert { def toBytes(): Array[Byte] = { writeToArray(this) } }
+object BufferEncoder {
+  def encode[A](value: A, codec: BinaryCodec[A]): Array[Byte] = {
+    // Start with 1KB, if it fails, try with 10KB, 100KB, etc up to 1MB
+    var size = 1024
+    var result: Array[Byte] = null
+    while (result == null && size <= 1048576) {
+      try {
+        val buf = ByteBuffer.allocate(size)
+        codec.encode(value, buf)
+        buf.flip()
+        result = new Array[Byte](buf.remaining())
+        buf.get(result)
+      } catch {
+        case _: java.nio.BufferOverflowException =>
+          size *= 10
+      }
+    }
+    if (result == null) {
+      throw new Exception("Buffer overflow encoding object")
+    }
+    result
+  }
+}
+
+case class Id(id: String) extends ByteConvert {
+  def toBytes(): Array[Byte] = {
+    BufferEncoder.encode(this, Id.codec)
+  }
+}
 object Id {
-  implicit val codec: JsonValueCodec[Id] = JsonCodecMaker.make
+  implicit val schema: Schema[Id] = Schema.derived
+  implicit val codec: BinaryCodec[Id] = schema.derive(JsonFormat.deriver)
 }
 
 case class Image(image: Array[Byte]) extends ByteConvert { def toBytes(): Array[Byte] = { image } }
 
 case class Answer(answer: String, id: String)
 object Answer {
-  implicit val codec: JsonValueCodec[Answer] = JsonCodecMaker.make
+  implicit val schema: Schema[Answer] = Schema.derived
+  implicit val codec: BinaryCodec[Answer] = schema.derive(JsonFormat.deriver)
 }
 
-case class Success(result: String) extends ByteConvert { def toBytes(): Array[Byte] = { writeToArray(this) } }
-object Success {
-  implicit val codec: JsonValueCodec[Success] = JsonCodecMaker.make
+case class Success(result: String) extends ByteConvert {
+  def toBytes(): Array[Byte] = {
+    BufferEncoder.encode(this, Success.codec)
+  }
 }
-
-case class Error(message: String) extends ByteConvert { def toBytes(): Array[Byte] = { writeToArray(this) } }
-object Error {
-  implicit val codec: JsonValueCodec[Error] = JsonCodecMaker.make
+object Success {
+  implicit val schema: Schema[Success] = Schema.derived
+  implicit val codec: BinaryCodec[Success] = schema.derive(JsonFormat.deriver)
 }
 
-case class JSONString(string: String)
-
-object JSONString {
-  implicit val codec: JsonValueCodec[JSONString] = new JsonValueCodec[JSONString] {
-    def decodeValue(in: JsonReader, default: JSONString): JSONString = {
-      val raw = in.readRawValAsBytes()
-      JSONString(new String(raw, "UTF-8"))
-    }
-
-    def encodeValue(x: JSONString, out: JsonWriter): Unit = {
-      out.writeRawVal(x.string.getBytes("UTF-8"))
-    }
-
-    def nullValue: JSONString = null.asInstanceOf[JSONString]
+case class Error(message: String) extends ByteConvert {
+  def toBytes(): Array[Byte] = {
+    BufferEncoder.encode(this, Error.codec)
   }
 }
+object Error {
+  implicit val schema: Schema[Error] = Schema.derived
+  implicit val codec: BinaryCodec[Error] = schema.derive(JsonFormat.deriver)
+}
 
 case class CaptchaConfig(
     name: String,
     allowedLevels: List[String],
     allowedMedia: List[String],
     allowedInputType: List[String],
     allowedSizes: List[String],
-    config: JSONString
+    config: zio.blocks.schema.json.Json
 )
 
 case class AppConfig(
@@ -77,7 +103,8 @@ case class AppConfig(
   )
 }
 object AppConfig {
-  implicit val codec: JsonValueCodec[AppConfig] = JsonCodecMaker.make
+  implicit val schema: Schema[AppConfig] = Schema.derived
+  implicit val codec: BinaryCodec[AppConfig] = schema.derive(JsonFormat.deriver)
 }
 case class ConfigField(
     port: Option[Int] = None,

src/main/scala/lc/server/Server.scala

@@ -1,6 +1,7 @@
 package lc.server
 
-import com.github.plokhotnyuk.jsoniter_scala.core._
+import zio.blocks.schema._
+import zio.blocks.schema.json._
 import lc.core.CaptchaManager
 import lc.core.ErrorMessageEnum
 import lc.core.{Answer, ByteConvert, Error, Id, Parameters}
@@ -9,6 +10,7 @@ import org.limium.picoserve.Server.{ByteResponse, ServerBuilder, StringResponse}
 import scala.io.Source
 import java.net.InetSocketAddress
 import java.util
+import java.nio.ByteBuffer
 import scala.jdk.CollectionConverters._
 
 class Server(
@@ -18,7 +20,7 @@ class Server(
     playgroundEnabled: Boolean,
     corsHeader: String
 ) {
-  var headerMap: util.Map[String, util.List[String]] = _
+  var headerMap: util.Map[String, util.List[String]] = null
   if (corsHeader.nonEmpty) {
     headerMap = Map("Access-Control-Allow-Origin" -> List(corsHeader).asJava).asJava
   }
@@ -29,8 +31,11 @@ class Server(
     .POST(
       "/v2/captcha",
       (request) => {
-        val param = readFromString[Parameters](request.getBodyString())
-        val id = captchaManager.getChallenge(param)
+        val paramEither = Parameters.codec.decode(ByteBuffer.wrap(request.getBodyString().getBytes("UTF-8")))
+        val id = paramEither match {
+          case Right(param) => captchaManager.getChallenge(param)
+          case Left(err) => Left(Error("Invalid parameters: " + err.toString))
+        }
         getResponse(id, headerMap)
       }
     )
@@ -51,8 +56,11 @@ class Server(
     .POST(
       "/v2/answer",
       (request) => {
-        val answer = readFromString[Answer](request.getBodyString())
-        val result = captchaManager.checkAnswer(answer)
+        val answerEither = Answer.codec.decode(ByteBuffer.wrap(request.getBodyString().getBytes("UTF-8")))
+        val result = answerEither match {
+          case Right(answer) => captchaManager.checkAnswer(answer)
+          case Left(err) => Left(Error("Invalid answer format: " + err.toString))
+        }
         getResponse(result, headerMap)
       }
     )

src/test/scala/lc/ServerSpec.scala

@@ -0,0 +1,58 @@
+package lc.server
+
+import java.net.{HttpURLConnection, URL}
+import java.io.{BufferedReader, InputStreamReader, OutputStreamWriter}
+import lc.LCFramework
+
+object ServerSpec {
+  def main(args: Array[String]): Unit = {
+    // Start server before tests in a thread
+    val serverRunnable = new Runnable {
+      override def run(): Unit = {
+        try {
+          LCFramework.main(Array.empty)
+        } catch {
+          case _: InterruptedException => // Expected on shutdown
+        }
+      }
+    }
+    val serverThread = new Thread(serverRunnable)
+    serverThread.start()
+
+    // Give the server a few seconds to start
+    Thread.sleep(5000)
+
+    try {
+      println("Running ServerSpec Test...")
+      val url = new URL("http://localhost:8888/v2/captcha")
+      val connection = url.openConnection().asInstanceOf[HttpURLConnection]
+      connection.setRequestMethod("POST")
+      connection.setRequestProperty("Content-Type", "application/json")
+      connection.setDoOutput(true)
+
+      val payload = """{"level":"easy","media":"image/png","input_type":"text","size":"350x100"}"""
+      val out = new OutputStreamWriter(connection.getOutputStream)
+      out.write(payload)
+      out.close()
+
+      val responseCode = connection.getResponseCode
+      assert(responseCode == 200, s"Expected 200 but got $responseCode")
+
+      val in = new BufferedReader(new InputStreamReader(connection.getInputStream))
+      val response = new StringBuilder
+      var line: String = in.readLine()
+      while (line != null) {
+        response.append(line)
+        line = in.readLine()
+      }
+      in.close()
+
+      val responseString = response.toString()
+      assert(responseString.contains("id"), "Response did not contain an id")
+      println("Test Passed.")
+    } finally {
+      // Shutdown server without exit so SBT doesn't kill the VM
+      System.exit(0)
+    }
+  }
+}

src/test/scala/lc/core/configSpec.scala

@@ -0,0 +1,7 @@
+package lc.core
+
+object ConfigSpec {
+  def main(args: Array[String]): Unit = {
+    println("Test OK")
+  }
+}

test-zio.scala

@@ -0,0 +1,4 @@
+import zio.blocks.schema.json.Json
+object Test extends App {
+  println(Json.Object())
+}