Kotlin - Ktor - How to handle Optional API resource fields in PATCH calls?-CodePudding

When implementing a REST API with Ktor (and Kotlin), it supports the optional field handling of Kotlin. Which works for POST and GET, but what about PATCH (update)?

For example, you have the following resource:

@Serializable
data class MyAddress(
    var line1: String? = null,
    var line2: String? = null,
    var city: String? = null,
    var postal_code: String? = null,
    var state: String? = null,
    var country: String? = null
)

So all MyAddress fields are optional (with a default value).

When you create an address with POST:

   "line1" : "line1",
   "country" : "XX"

and you than want to remove the country with a PATCH:

   "country" : null

the end result of the resource should be:

   "line1" : "line1"

But how can you determine this by parsing the json of the PATCH request? Because there is no way, as far as I know, to determine if it was null by default, or submitted.

Furthermore, the default null value for the MyAddress is required, because else the parsing will not work.

Code example:

import kotlinx.serialization.decodeFromString
import kotlinx.serialization.json.Json

@kotlinx.serialization.Serializable
data class MyAddress(
    var line1: String? = null,
    var line2: String? = null,
    var city: String? = null,
    var postal_code: String? = null,
    var state: String? = null,
    var country: String? = null
)

fun main() {
    val jsonStringPOST = "{\"line1\":\"street\",\"country\":\"GB\"}"
    println("JSON string is: $jsonStringPOST")

    val myAddressPost = Json.decodeFromString<MyAddress>(jsonStringPOST)
    println("MyAddress object: $myAddressPost")

    val jsonStringPATCH = "{\"country\":null}"
    println("JSON string is: $jsonStringPATCH")

    val myAddressPatch = Json.decodeFromString<MyAddress>(jsonStringPATCH)
    println("MyAddress object: $myAddressPatch")
}

I tried to add Optional<String>? as well, but it complains about missing serialization of Optional, and preferably I do not want to make all my data var's Optionals.

Note: I am looking for a more structured solution, that also works with all other resources in the api (10 classes).

CodePudding user response：

You can use a sealed interface for a part of an address to represent undefined value, absence of value, and actual value. For this interface, you need to write a serializer that will encode and decode values accordingly to your logic. I'm not good at the kotlinx.serialization framework so I wrote an example as simple as possible.

import io.ktor.serialization.kotlinx.json.*
import io.ktor.server.application.*
import io.ktor.server.engine.*
import io.ktor.server.netty.*
import io.ktor.server.plugins.contentnegotiation.*
import io.ktor.server.request.*
import io.ktor.server.routing.*
import kotlinx.serialization.*
import kotlinx.serialization.descriptors.PrimitiveKind
import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
import kotlinx.serialization.descriptors.SerialDescriptor
import kotlinx.serialization.encoding.Decoder
import kotlinx.serialization.encoding.Encoder

fun main() {
    embeddedServer(Netty, port = 4444) {
        install(ContentNegotiation) {
            json()
        }

        routing {
            post {
                val address = call.receive<Address>()
                println(address)
            }
        }
    }.start()
}

@Serializable
data class Address(val line1: MyValue = Undefined, val country: MyValue = Undefined)

@Serializable(with = AddressValueSerializer::class)
sealed interface MyValue
object Undefined: MyValue {
    override fun toString(): String = "Undefined"
}
object Absent: MyValue {
    override fun toString(): String = "Absent"
}
class WithValue(val value: String): MyValue {
    override fun toString(): String = value
}

object AddressValueSerializer: KSerializer<MyValue> {
    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("AddressValue", PrimitiveKind.STRING)

    override fun deserialize(decoder: Decoder): MyValue {
        return try {
            WithValue(decoder.decodeString())
        } catch (cause: SerializationException) {
            Absent
        }
    }

    @OptIn(ExperimentalSerializationApi::class)
    override fun serialize(encoder: Encoder, value: MyValue) {
        when (value) {
            is Undefined -> {}
            is Absent -> { encoder.encodeNull() }
            is WithValue -> { encoder.encodeString(value.value) }
        }
    }
}

CodePudding user response：

With some help from medium.com, I came to the following solution:


@Serializable(with = OptionalPropertySerializer::class)
open class OptionalProperty<out T> {

    object NotPresent : OptionalProperty<Nothing>()

    data class Present<T>(val value: T) : OptionalProperty<T>() {
        override fun toString(): String {
            return value.toString()
        }
    }

    fun isPresent() : Boolean {
        return this is Present
    }
    fun isNotPresent(): Boolean {
        return this is NotPresent
    }

    fun isEmpty(): Boolean {
        return (this is Present) && this.value == null
    }
    fun hasValue(): Boolean {
        return (this is Present) && this.value != null
    }

    override fun toString(): String {
        if(this is NotPresent) {
            return "<NotPresent>"
        }
        return super.toString()
    }
}

open class OptionalPropertySerializer<T>(private val valueSerializer: KSerializer<T>) : KSerializer<OptionalProperty<T>> {
     override val descriptor: SerialDescriptor = valueSerializer.descriptor

     override fun deserialize(decoder: Decoder): OptionalProperty<T> =
        OptionalProperty.Present(valueSerializer.deserialize(decoder))

     override fun serialize(encoder: Encoder, value: OptionalProperty<T>) {
        when (value) {
            is OptionalProperty.NotPresent -> {}
            is OptionalProperty.Present -> valueSerializer.serialize(encoder, value.value)
        }
    }
}

@Serializable
private data class MyAddressNew(
    var line1: OptionalProperty<String?> = OptionalProperty.NotPresent,
    var line2: OptionalProperty<String?> = OptionalProperty.NotPresent,
    var city: OptionalProperty<String?> = OptionalProperty.NotPresent,
    var postal_code: OptionalProperty<String?> = OptionalProperty.NotPresent,
    var state: OptionalProperty<String?> = OptionalProperty.NotPresent,
    var country: OptionalProperty<String?> = OptionalProperty.NotPresent,
)


fun main() {
    val jsonStringPOST = "{\"line1\":\"street\",\"country\":\"GB\"}"
    println("JSON string is: $jsonStringPOST")

    val myAddressPost = Json.decodeFromString<MyAddressNew>(jsonStringPOST)
    println("MyAddress object: $myAddressPost")

    val jsonStringUPDATE = "{\"country\":null}"
    println("JSON string is: $jsonStringUPDATE")

    val myAddressUpdate = Json.decodeFromString<MyAddressNew>(jsonStringUPDATE)
    println("MyAddress object: $myAddressUpdate")
    if(myAddressUpdate.country.isPresent()) {
        println("Update country: ${myAddressUpdate.country}")
    } else {
        println("No update for country: ${myAddressUpdate.country}")
    }
}

This prints:

JSON string is: {"line1":"street","country":"GB"}
MyAddress object: MyAddressNew(line1=street, line2=<NotPresent>, city=<NotPresent>, postal_code=<NotPresent>, state=<NotPresent>, country=GB)
JSON string is: {"country":null}
MyAddress object: MyAddressNew(line1=<NotPresent>, line2=<NotPresent>, city=<NotPresent>, postal_code=<NotPresent>, state=<NotPresent>, country=null)
Update country: null