Keep access to plugin generated serializer when mark class with @Serializable(with = MySerializer)

[ikarenkov]

What is your use-case and why do you need this feature?

When we write custom serializer for class, which contains plugin generated serializer inside, we cannot use with parameter of @Serializable because on this case, plugin serializer will not be generated.

In this case we have to manually use custom serializer in all case when we want to use our class serialization, because we cannot use @Serializable(with = MySerializer) instead.

In my case I'm trying to deserialize enum with generated serializer and if I get exception I catch it and return default value. It also can be used for some data transformations during decoding or encoding.

Describe the solution you'd like

It would be nice to have ability to generate and use plugin serializer when use class annotation @Serializable(with = MySerializer). For example, we can add extra parameter generateSerializer for @Serializable or use one more annotation to let plugin know, that we still need serializer. Generated serializer can have another name, for example generatedSerializer().

[bartvanheukelom]

Supposedly, with @Serializer you can generate a separate serializer for any class. Maybe you could use that?

[dimsuz]

I'd like this to be implemented too. I will describe my use case.

I want to deserialize json:

{
   "entryAction": "actionId",
   "customerRefs": "ref1",
   "allRefs": [ "ref1" ]
}

But in some cases it could be an object (don't ask why!) with additional optional fields:

{
   "entryAction": { "id": "actionId", "type": "basic" },
   "customerRefs": { "id": "ref1", "expired": false },
   "allRefs": [ { "id": "ref1", "expired": false } ]
}

What I'd like to do is this:

@Serializable(with = ActionSerializer::class)
data class Action(val id: String, val type: String?)

@Serializable(with = RefSerializer::class)
data class Ref(val id: String, val expired: Boolean?)

class ActionSerializer : KSerializer<Action> {
  fun deserialize(decoder): Action {
    return try { 
      Action(decoder.decodeString())
    } catch (...) {
      Action.DEFAULT_SERIALIZER.deserialize(decoder) // <-- (!!)
    }
  }

// similar implementation for RefSerializer

Notice that in this approach I automatically get deserialization of allRefs property — both in "array of strings" and "array of object cases". But nothing like DEFAULT_SERIALIZER available.

I.e. for each value type ("action" and "ref" above) the cases I have:

• "key": "value"
• "key": { "id": "value", "optionalFields" ... }
• "key": [ "value1", "value2" ]
• "key": [ { "id": "value1", "optionalFields" ... }, { "id": "value1", "optionalFields" ... } ]

If above serializer was possible I would write one serializer per object type and get all 4 cases covered.
Currently I have to have:

• Serializer for "single" case where only one value possible in deserialized object: val key: Something
• JsonTransformingSerializer where deserialized object accepts val key: List<Something>

When there are a lot of such props in json it gets tedious having to write similar pairs of serializers for each value type, moreover they share some bits of implementation which makes it error prone to maintain...

[dimsuz]

Oh, wait. @Serializer seems to fit this usecase!

I hope it will make it out of experimental state then 🙂

[Ayfri]

Any update now ?

[sandwwraith]

@Ayfri No updates, but given the demand for this feature, it's definitely on our table