Chaining codecs

[kamilkloch]

In this api: https://www.bitstamp.net/api/#tag/Orders/operation/OpenLimitSellOrder
a 200 respose can be of 2 unrelated shapes: successful response, or a (business) error response.
The most straightforward way to model it is via Either[ErrorResponse, BuySellOrderResponse].
Unfortunately, currently there is no possibility to derive codec for Either[A, B] given codecs for A and B, or to chain codecs via fallbackTo.

Arguably, such functionalliy drastically lowers the bar for writing custom codecs. Sometimes, a small performance penalty in exchange for easy code is the price the user agrees to pay. And, for ultimate performance, there always remains an option to write a custom low-level codec.

Relates to #1139, #1269

[kamilkloch]

Hello Andriy, I paste a real-life example, from https://www.bitstamp.net/websocket/v2/.
Two different messages with the same value of event discriminator. Secondary discriminator does not exist.
Writing a manual codec is quite tedious and error-prone in this scenario. Instead, one could write codec1.fallbackTo(codec2).

{
  "data": {
    "id": 422221002,
    "amount": "20.00000000",
    "price": "0.67539",
    "microtimestamp": "1748338297534000",
    "fee": "0.05403",
    "order_id": 1882125610500098,
    "trade_account_id": 0,
    "side": "buy"
  },
  "channel": "private-my_trades_adaeur-5333168",
  "event": "trade"
}

{
  "data": {
    "id": 422242895,
    "timestamp": "1748351018",
    "amount": 0.000443,
    "amount_str": "0.00044300",
    "price": 109637,
    "price_str": "109637",
    "type": 0,
    "microtimestamp": "1748351018686000",
    "buy_order_id": 1882177716342784,
    "sell_order_id": 1882177713135617
  },
  "channel": "live_trades_btcusd",
  "event": "trade"
}

[kamilkloch]

As for the example above, it is my strong belief that a user must not be forced to writing such code for the sake of performance. Compare that to codec1.fallbackTo(codec2).

  private val privateTradeCodec = JsonCodecMaker.make[PrivateTrade](codecMakerConfig)
  private val tradeCodec = JsonCodecMaker.make[Trade](codecMakerConfig)  
  private val discriminatorCodec = JsonCodecMaker.make[BitstampWsMessage](codecMakerConfig.withDiscriminatorFieldName(Some("event")))

  given JsonValueCodec[BitstampWsMessage] = new JsonValueCodec[BitstampWsMessage] {
    override def decodeValue(in: JsonReader, default: BitstampWsMessage): BitstampWsMessage = {
      in.setMark()
      if (in.isNextToken('{')) {
        if (in.skipToKey("event")) {
          val event = in.readString(null)
          in.rollbackToMark()
          
          if (event == "trade") {
            // Need to check channel to distinguish Trade vs PrivateTrade
            in.setMark()
            println("1")
            if (in.isNextToken('{')) {
              if (in.skipToKey("channel")) {
                val channel = in.readString(null)
                in.rollbackToMark()

                if (channel.startsWith("private-my_trades")) {
                  privateTradeCodec.decodeValue(in, null)
                } else {
                  tradeCodec.decodeValue(in, null)
                }
              } else {
                in.resetMark()
                in.requiredFieldError("channel")
              }
            } else {
              in.resetMark()
              in.readNullOrTokenError(default, '{')
            }
          } else {
            discriminatorCodec.decodeValue(in, default)
          }
        } else {
          in.resetMark() 
          in.requiredFieldError("event")
        }
      } else {
        in.resetMark()
        in.readNullOrTokenError(default, '{')
      }
    }

    override def encodeValue(x: BitstampWsMessage, out: JsonWriter): Unit = x match {
      case x: PrivateTrade => privateTradeCodec.encodeValue(x, out)
      case x: Trade => tradeCodec.encodeValue(x, out)
      case _ => discriminatorCodec.encodeValue(x, out)
    }

    override def nullValue: BitstampWsMessage = null
  }

[jozic]

Is writing a custom code that delegates to other two codecs (like try first or else second) an option?
It won't be performant but seems like it's not an issue in this case. And it shouldn't be as involved as writing if using low level API.

[kamilkloch]

Is writing a custom code that delegates to other two codecs (like try first or else second) an option? It won't be performant but seems like it's not an issue in this case. And it shouldn't be as involved as writing if using low level API.

This would open the possibility to easily hack codec for Either, union types, sealed trait given leaf codecs etc.