if anybody else is using

KClass.serializer()

it’s marked as

@InternalSerializationApi

in 1.0.0-RC, I filed https://github.com/Kotlin/kotlinx.serialization/issues/991 to try and get some more clarity on why it’s not recommended

ah, depending on ktor 1.4.0 resolved my issue

Is there any more compact way of configuring JSon with these settings

serializer = KotlinxSerializer(
                Json {
                    isLenient = true
                    ignoreUnknownKeys = true
                    useArrayPolymorphism = true
                }
            )

I had some code like this in a custom serializer (found elsewhere) that worked in 0.20.0:

return when (val jsonElement = JsonElementSerializer.deserialize(decoder)) {
            is JsonArray -> jsonElement.content.map { parser.decodeFromString(dataSerializer, it.toString()) }
            else -> listOf(parser.decodeFromString(dataSerializer, jsonElement.toString()))
        }

but in 1.0.0-RC the JsonElementSerializer is not recognized. What is the replacement for this?

So my project builds and runs well with Kotlin 1.4.0, but Android Studio shows all serializers like so: anything I can do to fix it?

In Java, we can add/remove property in JSONObject. In serialization, JsonObject is Map that can not be change. Is any suggestion to migrate this logic?

Hey folks, reading https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/polymorphism.md now, I wonder if I can use a composite key (multiple json fields that is) instead of

type

to deserialize subclasses?

If a field can either be a

String

or a

List<String>

in the serialized format, can this somehow be catered for with

kotlinx.serialization

? In my concrete case I try using

kaml

to parse a GitHub workflow yml file. It can for example have this:

jobs:
  job1:
  job2:
    needs: job1
  job3:
    needs: [job1, job2]

Hello. I am owner of TelegramBotAPI library and currently I am working on a new update related to new Kotlin and other dependencies versions. I have faced with an issue after upgrade of my project up to Kotlin 1.4.0 and Serialization up to 1.0.0-RC. It is look like currently code for JS serializer is generating incorrectly due to the fact that the test which normally must correctly work is failing. I have created a small bot for that and found the things you will see in attached screenshot. In two words:

tmp0_subject

was set up from

this._file_3

on line 98291 on screenshot. This value is absent, but there is value

value._file_3

which is look like something what must be on place of

tmp0_subject

Is there a way / trick / lib to make kotlinx.serializable able to serialize / deserialize simple PoJo trees? With Jackson you can simply do

ObjectMapper().writerWithDefaultPrettyPrinter().writeValue(it, this)

and

ObjectMapper().readValue(buildSrcResultFile, Result::class.java)!!

. Exists something similar that works with kotlinx.serialization?

Hi everyone. I am trying to serialize a class where a part is implemented by another class using the delegation pattern. Minimal example:

interface WithValue { val x: Int }

@Serializable
data class WithValueImpl(override val x: Int) : WithValue

@Serializable
data class MyClass(val y: Int) : WithValue by WithValueImpl(1)

fun main() {
    println(Json.encodeToString(MyClass(5)))
    // prints: {"y":5}
}

In the documentation, I have only found that delegated properties are transient, but nothing regarding delegated interfaces. The desired result would be, that MyClass is encoded as

{"y": 5, "x": 1}

. Do you have any pointers for me?

What am I doing wrong in the following snippet? Important: The answer is not that I do not simply annotate with

@Serializable

.

Foo

in reality is a Groovy object from a library so it is not modifiable.

data class Foo(val count: Int = 1)

@Serializer(forClass = Foo::class)
object FooSerializer : KSerializer<Foo> {
    override val descriptor = SerialDescriptor("Foo") {
        element("count", Int.serializer().descriptor)
    }

    override fun deserialize(decoder: Decoder) = decoder.decodeStructure(descriptor) {
        Foo(decodeIntElement(descriptor, 0))
    }

    override fun serialize(encoder: Encoder, value: Foo) {
        encoder.encodeStructure(descriptor) {
            encodeIntElement(descriptor, 0, value.count)
        }
    }
}

println(Json(Stable).parse(FooSerializer, Json(Stable).stringify(FooSerializer, Foo())))

Result:

Unexpected JSON token at offset 14: Failed to parse 'int'.
   JSON input: {
      "count": 1
  }

Because it tries to parse

count

as

Int

instead of

1

:-/

Hi! I'm currently updating a multiplatform project to Kotlin 1.4. I changed the following:

plugins {
    kotlin("multiplatform") version "1.4.0" // previously 1.3.61
    kotlin("plugin.serialization") version "1.4.0" // same
}

and:

val serialization_version = "1.0.0-RC"
val commonMain by getting {
    dependencies {
        implementation(kotlin("stdlib-common"))
        implementation("org.jetbrains.kotlinx:kotlinx-serialization-runtime-common:$serialization_version")
        // ktor...
    }
}
// other targets, with serialization-runtime-jvm, etc

Etc. However, I'm getting this Gradle error:

Execution failed for task ':compileKotlinJvm'.
> Could not resolve all files for configuration ':jvmCompileClasspath'.
   > Could not find org.jetbrains.kotlinx:kotlinx-serialization-runtime-common:1.0.0-RC.
     Required by: ...
   > Could not find org.jetbrains.kotlinx:kotlinx-serialization-runtime:1.0.0-RC.
     Required by: ...

Unless I read something incorrectly, I think that's what the GitHub README & the documentation on kotlinlang.org say to do... Did I do something wrong?

Hi everyone! I'm a long standing user of kotlinx.serialisation but since upgrading to 1.0.0-RC I've been facing the following issue in my MPP:

Overload resolution ambiguity: 
public fun String.Companion.serializer(): KSerializer<String> defined in kotlinx.serialization.builtins
public fun String.Companion.serializer(): KSerializer<String> defined in kotlinx.serialization.builtins

Overload resolution ambiguity: 
public fun <K, V> MapSerializer(keySerializer: KSerializer<TypeVariable(K)>, valueSerializer: KSerializer<TypeVariable(V)>): KSerializer<Map<TypeVariable(K), TypeVariable(V)>> defined in kotlinx.serialization.builtins
public fun <K, V> MapSerializer(keySerializer: KSerializer<TypeVariable(K)>, valueSerializer: KSerializer<TypeVariable(V)>): KSerializer<Map<TypeVariable(K), TypeVariable(V)>> defined in kotlinx.serialization.builtins

I've checked the dependencies downloaded by Gradle and indeed see that there are 2 identical artefacts for JVM, but that's not the case for common, JS or native. I only have a single dependency declared on the common module for

org.jetbrains.kotlinx:kotlinx-serialization-core:1.0.0-RC

Has anyone experienced something similar and could shed some light on how to solve it?

I found this 1+ year old comment while trying to debug some Kotlin JVM serialization code I am working on: "Kotlin serialization is more like a serialization code generator than a serialization library. Most JSON libraries are more for reading/writing Json rather than generating it." Given the hassles I've had trying to configure Gradle to be happy with the documented use of Kotlin serialization, I'm thinking this comment is meant for my application and I should be looking to GSON or Jackson rather than a Kotlin solution. My app definitely wants a library type solution: given a class get the JSON representation as a string and vice versa. But while the former does not involve code generation, the latter might, so I'm confused. And my preferences are for a pure Kotlin solution if at all possible. Advice, as in "how would you approach this problem - keep troubleshooting or switch to Jackson or GSON"?

If memory serves, when using Kotlin serialization with KMP, I had to tell Gradle that I was using "experimental" features. Is this still necessary with Kotlin 1.4.0 code that is JVM (not KMP)? When I enable the serialization plugin, all dependencies are colored red in IntelliJ with no clear error message. A pointer to a working sample Kotlin/JVM app using 1.4.0 serialization in a Kotlin DSL gradle file would be very helpful.

Hello, I updated kotlinx.serialization to 1.0.0-RC and this code that used to work on 0.9.1, now throws an error. It seems caused by the "id" property being used in the default initializer of the "otherData" property.

@Serializable
data class OtherData(val id:String)

@Serializable
data class MyData(val id: String = "", val otherData: OtherData = OtherData(id))

it would be nice to have a mode where you can run kotlin 1.4 plugin but work with old codebases

Is streaming comming?

Hi everyone, maybe this is a dumb question but suppose I do this:

@Serializable
data class MyClass(val myProp: String, private val myPrivateProp: String)

does

myPrivateProp

get serialized?

Hello, I've updated my kotlin version to 1.4 and kotlinx serialization to 1.0.0-RC And i get the following error when i try to build for ios Compilation failed: IrPropertyPublicSymbolImpl for public kotlinx.serialization.internal/EMPTY_SERIALIZER_ARRAY|-1756714926106261760[0] is already bound: PROPERTY name:EMPTY_SERIALIZER_ARRAY visibility:internal modality:FINAL [val] Any idea ? Thanks

I just updated to Kotlin 1.4 and serialization 1.0.0-RC in my KMM project and I’m getting the error:

Compilation failed: Deserializer for declaration public kotlinx.coroutines/SingleThreadDispatcher|null[0] is not found

Does this look familiar to anyone? EDIT: I reverted back to 0.20.0 and have the same issue

Hi all, i'm starting a new project and considering kotlinx.serialization over jackson which I am using currently. The project is microservices-based so restful and graphql endpoints which have a decent throughput level (1 request per second average). I understand that kotlinx.serialization is nearly 1.0.0 and was curious on anyone else experiences good or bad/would you recommend a move to kotlinx.serial from jackson? Thanks for your thoughts in advance 🙏

Hey! I'm trying to write a custom decoder for a little argument parsing thing I'm working on and it's going all good, except that I can't seem to figure out a way to make enums case insensitive. The thing is that

decodeEnum

is given a string that it should try to match to a enum value index, but

SerialDescriptor#getElementIndex

doesn't seem to have any way to do a case insensitive lookup. Any ideas how I might achieve this?

Hello, I have faced with problem on JS Browser target. It is very strange, but all serial formats can't decode data which were incoded by themself. The most strangest here that I have created tests which should represent this issue, but they was correctly passed. I have tried to encode bytearra with cbor. Serializer was

ListSerializer

with data class subserializer, which have one custom serializer in it. As a result on trying to decode encoded bytearray I got error like

Expected array, but found 00

. I have tried to find some known issue on github or in the google, but didn't find it. Maybe, somebody here faced this too and could help me?

I know inline classes are not supported out of the box, but are they if we have a custom serializer for them?

hello! i'm new to this library, can anyone point me to the right doc or an example to help me figure out how to handle de/serialization in cases where the data comes in a very specific format like this:

{
  "op": "op type",
  "data": {
    "id": "",
    "name": ""
  }
}

for some context, the server utilizes both http and websockets. the op is something like

GetSite

or

GetUser

and the data block is an array of the op's values. right now i'm running into an issue where it can't figure out what to use for the data block when receiving a response on the websocket. i'm starting to feel like it won't be possible to utilize one set of classes for both http/ws. i got the following to work but something about it just feels hacky 😓

@Serializable
class SampleRequest {
    private val op = "GetThing"
    var data: Data

    constructor(auth: String?): super() {
        data = Data(auth)
    }

    @Serializable
    class Data(
        val auth: String?
    )
}

@Serializable
class SampleResponse {
    private val op = "GetThing"
    var data: Data
    
    constructor(id: Int, name: String): super() {
        data = Data(id, name)
    }
    
    @Serializable
    class Data(
        val id: Int,
        val name: String
    )
}

the return type works fine (e.g.

MyResponse<SpecificResponse>

as return type) but I get a no serializer found for

MyRequest

even though I can use serialization manual of an instance correctly.

Hi 👋 I have many model classes extending a base interface like:

class BaseModel {
    val keys: Set<String> 
    fun <T> get(key: String): T?
    fun <T> set(key: String, value: T?)
}

Basically, it works as a

Map<String, Any?>

and we can assume that the actual values are something that can be serialized, like numbers or strings. Then I have concrete models e.g.

class UserModel : BaseModel

,

class PostModel : BaseModel

and so on. How can I make these classes serializable? I tried to write a common KSerializer and can handle serialization like:

@Serializer(UserModel::class)
object UserSerializer : BaseSerializer<UserModel>({ UserModel() })

@Serializer(PostModel::class)
object PostSerializer : BaseSerializer<PostModel>({ PostModel() })

class BaseSerializer<M : BaseModel>: KSerializer<M> {

    override fun serialize(encoder: Encoder, model: T) {
        for (key in model.keys) {
            encoder.encodeString(key)
            val value = model.get(key)
            when (value) {
                is Int -> encoder.encodeInt(value)
                is Long -> encoder.encodeLong(value)
                is String -> encoder.encodeString(value)
                else -> error()
            }
        }
    }
}

But then I have no idea of how to implement

deserialize

(looks like order matters there...?) and

descriptor: SerialDescriptor

(not even sure what this is). I might get it working but I don't think I'm doing things in the correct way. Can anyone help? The BaseModel also has a working Parcelable implementation, if that matters.