A more general statement of my previous question for dealing with the Language Server Protocol (LSP) might be: when encountering a single JSON element (same name == "fieldName") that can be a primitive (

"fieldName":234

), a structure (

"fieldName":{...}

) or an array (

"fieldName":["string1","string2","string3"]

), what is the most logical/appropriate KSX feature for handling the serialization of that JSON element. JsonContentPolymorphicSerializer has proven to be very helpful for "regular" TypeScript <-> Kotlin interface mappings, i.e. interface constructs that appear nearly the same in both languages. It is when TypeScript can have one of primitive, object and/or array JSON elements that it gets much harder, at least as I understand KSX so far. My current thinking is that the most likely feature to use is the experimental one ("Under the hood") in the Json Transformations in the fifth chapter of the Kotlin Serialization Guide. If there is an easier approach, I'd love to hear about it.

All over a sudden,

Person.serializer().list

can't be resovled. How do I get a list serializer in

kotlinx-serilialization-1.0.1

?

Is there any quick API to put a simple value into a

JsonObject

without unboxing the whole object?

My next serialization challenge is to conjure up a serializer for the abstract class Number. My first guess would be to use @Contextual. Good guess? But since I may have to tweak the actual Json, JsonTransformingSerializer might be better.

Is there a way to have a subclass serialized with the custom serializer of its superclass, without having to declare

@Serializable(with= ... )

on every subclass?

Is there any easy way to (de)serialize purely through an

interface

? That is, without adding any support for serialization to the implementing

class

, and when deserializing have the compiler generate an

object

that implements the

interface

.

@Serializable
interface Foo {
	val bar1: String
	val bar2: Int
}

Should serialize too

{"bar1":"…","bar2":…}

independent of the implementing

class

.

{"bar1":"abc","bar2":42}

should deserialize to

object : Foo { override val bar1 = "abc"; override val bar2 = 42 }

.

Class

ArrayList

is not registered for polymorphic serialization in the scope of

Any

. Mark the base class as

sealed

or register the serializer explicitly.

Class

SingletonList

is not registered for polymorphic serialization in the scope of

Any

. Mark the base class as

sealed

or register the serializer explicitly.

Do I really have to do this dance for every possible implementation of

Collection

? 😮 Also, how do I register subclasses of

Collection

? There’s no

Collection.serializer()

or

ArrayList.serializer()

I could use for polymorphism 🤔

The kotlinx.serialization Json format is able to fall back on default values if something is missing during decoding. So if you have a class

@Serializable
data class Foo(val bar: String = "bar")

and deserialize an empty json object

val foo = Json.decodeFromString(Foo.serializer(), "{}")

then you get

Foo("bar")

as output rather than an error or

Foo("")

or something else. Can anyone point to what makes that happen? I want to do something similar for a custom format. (NB I’m not looking for the

encodeDefaults

option. That flag controls whether default values are added to Json output. I’m looking for how default values are inferred when missing from Json input.)

I've a question: I've an api that returns information for the pagination and the list of items in the same object:

{
     "offset":0,
     "limit":15,
     "count":1,
     //and a field with custom fieldname with the items
     "fooItems": [...]
}

Can I transform this somehow in a class like this:

class PaginationResult<T>(
    val offset : Int,
    val limit : Int,
    val count : Int,
    val items : List<T>
}
@Serializable FooItem
@serializable BarItem

As I understand the JSON spec, there is no order dependence on fields on a JSON object:

{"foo":"fooValue","fee":"feeValue"}

and `{"fee":"feeValue","foo":"fooValue"}`should deserialize to the same object. But this is apparently not the case with KXS. Is there some fine print that says JSON implementors can do pretty much what they want or is this a bug of some sort? My assumption is the former so that means transforming incoming JSON to a correct order. Any chance I have this assumption wrong?

Hello. I was previously using serialization-core

1.0.0-RC

and updated to serialization-json

1.0.1

and it seems there is a change in behaviour for this use case:

@Serializable
class MyClass(
  val id: String
) {
  val message = "my message"
}

This is my serialization code:

val serializer = Json {
  // Not relevant to the example but this is the Json serialization config I'm using
  ignoreUnknownKeys = true
  prettyPrint = true
}
val myClass = MyClass("abc123")
val serialized = serializer.serialize(myClass)

I expect

serialized

to be

{
  "id": "abc123",
  "message": "my message"
}

but I’m getting

{
  "id": "abc123"
}

Is there no way to pack the proguard.rules into a consumer.rules in kotlinx.serialization? so the library itself applies the rules needed for kotlinx serialization?

Hello, I have a serializable class that holds one parameter (a map) and I'd like to be able to serialize it directly using that map's serializer, without the parameter name. I've managed to write my own serializer that just uses a map serializer and its descriptor to do this, and it works exactly how I want. The only issue is, I now want to use this with polymorphic serialization and I can't seem to find a way to change the SerialName. Is there a better way to do this, or any way to change the SerialName on an existing descriptor? Thanks in advance!

with kotlin 1.4.30 M1, the support for inline classes is coming?

Does kotlix serialization json have streaming? I remember it not being supported yet, now I notice StreamingJsonDecoder in the code base so.. is it? (But I have checked changelogs and no mention)

Hello all, i'm trying to use kotlinx, but i'm getting this error:

kotlinx.serialization.SerializationException: Serializer for class 'Immobile' is not found.

Mark the class as @Serializable or provide the serializer explicitly.

Any idea why Kotlin 1.4.30-M1 does not allow

@file:UseContextualSerialization

annotation (both with IR and Legacy)?

Is there a way to check @Serializable annotation at compile time? I'm getting burned at runtime and that's often too late

Any idea why I can't serialize a generic class that's inside a sealed class with the Message serializer?

Is there any chance of infix functions being added back to

JsonObjectBuilder

(named something other than

to

)? It felt more fluid that way than using

put

In the attached screen shot, I show three classes, A, B and C. A and B use interfaces and all is well. C uses a list of implementations and it passes but I would like to use a list of interfaces, as in B. When I change C to use a list of interfaces (by commenting line 48 and uncommenting line 49) the test fails with a polymorphism error message as indicated. Is there an obvious solution to this problem?

I want to use kotlinx.serialization, but we also really need strong obfuscation. Is there any way to use kotlinx.serialization (with retrofit) that would allow me to ignore the proguard rules, and move back to full obfuscation?

For me this release still doesn't work when combining Compose and Serialization https://github.com/JetBrains/kotlin/releases/tag/v1.4.21-2

Looking for some clarification on missing fields: in the code shown below all is well if both fields have valid content. When the

serverInfo

field is missing, a missing field exception is thrown which I did not expect (because of the nullable indication). My conclusion is that this means I need to detect missing fields (using a transforming polymorphic serializer) and explicitly add a null, as in

{"serverInfo":null}

. Would that conclusion be correct or am I missing something?

Hi 👋 , first post here 🙂 I have a problem adding

serialization-protobuf

to my android project. This is what I am doing. in project level build.gradle:

buildscipt {
dependencies {
        classpath "org.jetbrains.kotlin:kotlin-serialization:${versions.kotlin}"
}
}

apply plugin: 'org.jetbrains.kotlin.plugin.serialization'

in app-level build.gradle:

plugins {
    id 'kotlinx-serialization'
}
dependencies {
    implementation "org.jetbrains.kotlinx:kotlinx-serialization-protobuf:1.4.20"
}

I got following error:

Could not find org.jetbrains.kotlinx:kotlinx-serialization-protobuf:1.4.20

I believe I wrongly configured the plugins, but I do not found any guide for android. All of them are for multiplatform 🙂 . Can anyone point me where the issue is?

Hello, World! I have a JSON API returning numbers, but apparently

kotlin.Number

is not Serializable. What's the easiest way to deal with this?

Hey, I currently have a problem with a sealed class on kotlin/js (IR) I can only use encodeTo/decodeFromString when specifiyng the serializer otherwise an exception is thrown telling me to annotate classes with

@Serializable

but all of them are and work fine on Kotlin/JVM

hello 👋 what is the suggested way to use wrapper objects? i.e. given some

String

value I'd like to have it wrapped in

data class Wrapper(val value: String)

, in Jackson I can use

@JsonCreator/@JsonValue

annotations to achieve this. Based on the docs it looks like I need to build a custom serializer?

whats the appropriate way to convert a

Map<String, String>

into an object that is marked

@Serializable

?