<@UFT11FKSP> Thoughts on making `ServiceException`...

# kvision

[rocketraman]

@Robert Jaros Thoughts on making ServiceException open so that the client can act based on sub-classes of it?

[Robert Jaros]

The exception type is transferred as a string. Do you know a way to reconstruct the exception on the client side based on the class name?

[Robert Jaros]

Can exceptions be serialized with kotlinx.serialization?

[Robert Jaros]

https://github.com/rjaros/kvision/blob/master/kvision-modules/kvision-common-remote/src/jsMain/kotlin/io/kvision/remote/CallAgent.kt#L93

[rocketraman]

What about creating a type that requires a serializable entity as a parameter? That entity can then be serialized over the wire and reconstructed on the client side. So the client would not act on the exception type itself, but on the wrapped entity.

[Robert Jaros]

Is it possible to require a serializable parameter?

[rocketraman]

Not sure if it can be made a compile-time error, but I don't see it as a big deal if this throws a runtime exception -- its something a user would have to explicitly implement so presumably they've read the docs 🙂

[rocketraman]

Hmm, not sure how we would call serializer() on it though if its just a generic type.

[rocketraman]

I asked a question on #serialization

[Robert Jaros]

Do you know if we can use open polymorphism (https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/polymorphism.md#open-polymorphism) with an open class instead of abstract class on the top of hierarchy?

[Robert Jaros]

It works for me with abstract class but doesn't work with open

[rocketraman]

I thought you could

[Robert Jaros]

Generally I've made some tests and we could serialize/deserialize hierarchy of exceptions but registration in serializers module is required.

[rocketraman]

Nice. Yeah that's what I would expect.

[Robert Jaros]

@Serializable
abstract class MyException(val msg: String): Exception(msg)

@Serializable
@SerialName("mysecond")
class MySecondException : MyException("MySecond")

        val json = Json {
            serializersModule = SerializersModule {
                polymorphic(MyException::class) {
                    subclass(MySecondException::class)
                }
            }
        }
            val e: MyException = MySecondException()
            val serialized = json.encodeToString(e)
            console.log(serialized)
            val deserialized = json.decodeFromString<MyException>(serialized)
            try {
                throw deserialized
            } catch (e: MySecondException) {
                console.log("Cought: ${e.msg}")
            }

[rocketraman]

According to docs:

Serialization can work with arbitrary open classes or abstract classes.

[Robert Jaros]

Unfortunately it doesn't work anymore if I change abstract class MyException to open class.

[Robert Jaros]

Also deserialized exception is somehow "broken". I can read e.msg but e.message property is undefined

[Robert Jaros]

Still it should be possible to support hierarchy of exceptions as long as the user registers all the classes with the new RemoteSerialization.customConfiguration option I've added recently.

[Robert Jaros]

Perhaps it could even work for custom hierarchy without kvision exception at all - I could just try/catch to serialize the backend exception and send serialized form if it can be done, otherwise just send the class name.

[Robert Jaros]

And on the fronted side recreate and throw the serialized exception if it was send from the backend, and if there is none - just create ServiceException or general Exception like before.

[Robert Jaros]

Please fill an issue and I'll try to play with this.

[Robert Jaros]

I'm going to winter holiday next week so probably after I return.

[rocketraman]

https://github.com/rjaros/kvision/issues/354

[rocketraman]

For now, I'm using this workaround. The backend simply instantiates ServiceRpcException instead of ServiceException, and the frontend does RpcError(e) to unwrap the RpcError instance.

@Serializable
sealed class RpcError {
  companion object {
    // used by the frontend e.g. RpcError(e) where e is a ServiceException
    operator fun invoke(serviceException: ServiceException) =
      Json.decodeFromString<RpcError>(serviceException.message!!)
  }

  @Serializable
  object Unauthorized : RpcError()
  // ... as many types as needed ...
  @Serializable
  class UnexpectedError(val errorId: String) : RpcError()
}

object ServiceRpcException {
  // used by the backend e.g. ServiceRpcException(RpcError.Unauthorized)
  operator fun invoke(rpcError: RpcError): ServiceException =
    ServiceException(Json.encodeToString(rpcError))
}