Deserialize empty string as null with kotlinx.serialization

Question

I'm writing a client for a third-party REST API that returns JSON with a variety of alternative values instead of proper null or omitting the property entirely if null. Depending on the entity or even property in question, null could be represented by either null, "", "0" or 0.

It's easy enough to make a custom serializer, e.g. something like this works fine:

@Serializable
data class Task(
    
    val id: String,
    
    @Serializable(with = EmptyStringAsNullSerializer::class)
    val parentID: String?
)

object EmptyStringAsNullSerializer : KSerializer<String?> {

    private val delegate = String.serializer().nullable

    override val descriptor: SerialDescriptor =
        PrimitiveSerialDescriptor("EmptyStringAsNull", PrimitiveKind.STRING)

    override fun serialize(encoder: Encoder, value: String?) {
        when (value) {
            null -> encoder.encodeString("")
            else -> encoder.encodeString(value)
        }
    }

    override fun deserialize(decoder: Decoder): String {
        return delegate.deserialize(decoder) ?: ""
    }
}

fun main() {
    val json = """
        {
            "id": "37883993",
            "parentID": ""
        }
    """.trimIndent()
    val task = Json.decodeFromString(json)
    println(task)
}

But annotating many properties like this is a bit ugly/noisy. And I'd also like to use inline/value classes for strong typing, like this:

@Serializable
data class Task(
    val id: ID,
    val parentID: ID?
    /* .... */
) {

    @JvmInline
    @Serializable
    value class ID(val value: String)
}

This means that in addition to annotating these properties I also need a custom serializer for each of them. I tried some generic/parameters-based solution that can work for all cases like this:

open class BoxedNullAsAlternativeValue<T, V>(
        private val delegate: KSerializer<T>,
        private val boxedNullValue: T,
        private val unboxer: (T) -> V
    ) : KSerializer<T> {

        private val unboxedNullValue by lazy { unboxer.invoke(boxedNullValue) }

        override val descriptor: SerialDescriptor =
            PrimitiveSerialDescriptor(this::class.simpleName!!, PrimitiveKind.STRING)

        override fun serialize(encoder: Encoder, value: T) {
            when (value) {
                null -> delegate.serialize(encoder, boxedNullValue)
                else -> delegate.serialize(encoder, value)
            }
        }

        override fun deserialize(decoder: Decoder): T {
            @Suppress("UNCHECKED_CAST")
            return when (val boxedValue = delegate.deserialize(decoder)) {
                boxedNullValue -> null as T
                else -> boxedValue
            }
        }
    }

But that doesn't work because @Serializable(with = ...) expects a static class reference as argument, so it can't have parameters or generics. Which means I'd still need a concrete object for each inline/value type:

@Serializable
data class Task(
    val id: ID,  // <-- missing serializer because custom serializer is of type ID? for parentID
    val parentID: ID?
) {

    @JvmInline
    @Serializable(with = IDSerializer::class)
    value class ID(val value: String)
}

internal object IDSerializer : BoxedNullAsAlternativeValue<Task.ID?, String>(
        delegate = Task.ID.serializer().nullable,   // <--- circular reference
        boxedNullValue = Task.ID(""),
        unboxer = { it.value }
    )

That doesn't work because there is no longer a generic delegate like StringSerializer and using Task.ID.serializer() would mean the delegate would be the custom serializer itself, so a circular reference. It also fails to compile because one usage of the ID value class is nullable and the other not, so I would need nullable + non-nullable variants of the custom serializer and I would need to annotate each property individually again, which is noisy.

I tried writing a JsonTransformingSerializer but those need to be passed at the use site where encoding/decoding happens, which means I'd need to write one for the entire Task class, e.g. Json.decodeFromString(TaskJsonTransformingSerializer, json) and then also for all other entities of the api.

I found this feature request for handling empty strings as null, but it doesn't appear to be implemented and I need it for other values like 0 and "0" too.

Question

Using kotlinx.serialization and if necessary ktor 2, how to deserialize values like "", "0" and 0 as null for inline/values classes, considering that:

• Properties of the same (value) type can be nullable and non-nullable in the same class, but I'd like to avoid having to annotate each property individually
• I'd like a solution that is as generic as possible, i.e. not needing a concrete serializer for each value class
• It needs to work both ways, i.e. deserializing and serializing

I read in the documentation that serializing is done in 2 distinct phases: breaking down a complex object to it's constituent primitives (serializing) --> writing the primitives as JSON or any other format (encoding). Or in reverse: decoding -> deserializing;

Ideally I'd let the compiler generate serializers for each value class, but annotate each of them with a reference to one of three value transformers (one each for "", "0" and 0) that sit in between the two phases, inspects the primitive value and replaces it when necessary.

I've been at this for quite some time, so any suggestions would be much appreciated.