Support discriminators not being the first field when decoding

bson-kotlinx/src/main/kotlin/org/bson/codecs/kotlinx/BsonDecoder.kt

@@ -31,6 +31,7 @@ import kotlinx.serialization.modules.SerializersModule
 import org.bson.AbstractBsonReader
 import org.bson.BsonInvalidOperationException
 import org.bson.BsonReader
+import org.bson.BsonReaderMark
 import org.bson.BsonType
 import org.bson.BsonValue
 import org.bson.codecs.BsonValueCodec
@@ -125,7 +126,6 @@ internal open class DefaultBsonDecoder(
                 return BsonArrayDecoder(reader, serializersModule, configuration)
             }
             is PolymorphicKind -> {
-                reader.readStartDocument()
                 return PolymorphicDecoder(reader, serializersModule, configuration)
             }
             is StructureKind.CLASS,
@@ -213,13 +213,37 @@ private class PolymorphicDecoder(
     configuration: BsonConfiguration
 ) : DefaultBsonDecoder(reader, serializersModule, configuration) {
     private var index = 0
+    private var mark: BsonReaderMark? = reader.mark
 
-    override fun <T> decodeSerializableValue(deserializer: DeserializationStrategy<T>): T =
-        deserializer.deserialize(DefaultBsonDecoder(reader, serializersModule, configuration))
+    override fun <T> decodeSerializableValue(deserializer: DeserializationStrategy<T>): T {
+        mark?.let {
+            it.reset()
+            mark = null
+        }
+        return deserializer.deserialize(DefaultBsonDecoder(reader, serializersModule, configuration))
+    }
 
     override fun decodeElementIndex(descriptor: SerialDescriptor): Int {
+        var found = false
         return when (index) {
-            0 -> index++
+            0 -> {
+                reader.readStartDocument()
+                reader.readBsonType()
+                while (reader.state != AbstractBsonReader.State.END_OF_DOCUMENT) {
+                    if (reader.readName() == configuration.classDiscriminator) {
+                        found = true
+                        break
+                    }
+                    reader.skipValue()
+                    reader.readBsonType()
+                }
+                if (!found) {
+                    throw SerializationException(
+                        "Missing required discriminator field `${configuration.classDiscriminator}` " +
+                            "for polymorphic class: `${descriptor.serialName}`.")
+                }
+                index++
+            }
             1 -> index++
             else -> DECODE_DONE
         }
@@ -251,6 +275,8 @@ private class BsonDocumentDecoder(
                 "Invalid key type for ${descriptor.serialName}. Expected STRING or ENUM but found: `${keyKind}`")
         }
 
+        System.err.println(descriptor.serialName)
+
         if (!isKey) {
             isKey = true
             val nextType = reader.readBsonType()

bson-kotlinx/src/test/kotlin/org/bson/codecs/kotlinx/KotlinSerializerCodecProviderTest.kt

@@ -35,8 +35,12 @@ import org.bson.codecs.kotlinx.samples.DataClassOpen
 import org.bson.codecs.kotlinx.samples.DataClassOpenA
 import org.bson.codecs.kotlinx.samples.DataClassOpenB
 import org.bson.codecs.kotlinx.samples.DataClassParameterized
+import org.bson.codecs.kotlinx.samples.DataClassSealedInterface
 import org.bson.codecs.kotlinx.samples.DataClassWithSimpleValues
+import org.bson.codecs.kotlinx.samples.SealedInterface
 import org.bson.conversions.Bson
+import org.bson.json.JsonReader
+import org.bson.types.ObjectId
 import org.junit.jupiter.api.Test
 
 class KotlinSerializerCodecProviderTest {
@@ -75,6 +79,41 @@ class KotlinSerializerCodecProviderTest {
         assertEquals(DataClassWithSimpleValues::class.java, codec.encoderClass)
     }
 
+    @Test
+    fun testDataClassWithSimpleValuesFieldOrdering() {
+        val codec = MongoClientSettings.getDefaultCodecRegistry().get(DataClassWithSimpleValues::class.java)
+        val expected = DataClassWithSimpleValues('c', 0, 1, 22, 42L, 4.0f, 4.2, true, "String")
+
+        val numberLong = "\$numberLong"
+        val actual =
+            codec.decode(
+                JsonReader(
+                    """{"boolean": true, "byte": 0, "char": "c", "double": 4.2, "float": 4.0, "int": 22,
+                        |"long": {"$numberLong": "42"}, "short": 1, "string": "String"}"""
+                        .trimMargin()),
+                DecoderContext.builder().build())
+
+        assertEquals(expected, actual)
+    }
+
+    @Test
+    fun testDataClassSealedFieldOrdering() {
+        val codec = MongoClientSettings.getDefaultCodecRegistry().get(SealedInterface::class.java)
+
+        val objectId = ObjectId("111111111111111111111111")
+        val oid = "\$oid"
+        val expected = DataClassSealedInterface(objectId, "string")
+        val actual =
+            codec.decode(
+                JsonReader(
+                    """{"name": "string", "_id": {$oid: "${objectId.toHexString()}"},
+                            |"_t": "org.bson.codecs.kotlinx.samples.DataClassSealedInterface"}"""
+                        .trimMargin()),
+                DecoderContext.builder().build())
+
+        assertEquals(expected, actual)
+    }
+
     @OptIn(ExperimentalSerializationApi::class)
     @Test
     fun shouldAllowOverridingOfSerializersModuleAndBsonConfigurationInConstructor() {

bson-kotlinx/src/test/kotlin/org/bson/codecs/kotlinx/KotlinSerializerCodecTest.kt

@@ -84,20 +84,22 @@ import org.bson.codecs.kotlinx.samples.DataClassWithSequence
 import org.bson.codecs.kotlinx.samples.DataClassWithSimpleValues
 import org.bson.codecs.kotlinx.samples.DataClassWithTriple
 import org.bson.codecs.kotlinx.samples.Key
+import org.bson.codecs.kotlinx.samples.SealedInterface
 import org.bson.codecs.kotlinx.samples.ValueClass
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
 
 @OptIn(ExperimentalSerializationApi::class)
 class KotlinSerializerCodecTest {
     private val numberLong = "\$numberLong"
+    private val oid = "\$oid"
     private val emptyDocument = "{}"
     private val altConfiguration =
         BsonConfiguration(encodeDefaults = false, classDiscriminator = "_t", explicitNulls = true)
 
     private val allBsonTypesJson =
         """{
-    | "id": {"${'$'}oid": "111111111111111111111111"},
+    | "id": {"$oid": "111111111111111111111111"},
     | "arrayEmpty": [],
     | "arraySimple": [{"${'$'}numberInt": "1"}, {"${'$'}numberInt": "2"}, {"${'$'}numberInt": "3"}],
     | "arrayComplex": [{"a": {"${'$'}numberInt": "1"}}, {"a": {"${'$'}numberInt": "2"}}],
@@ -679,6 +681,17 @@ class KotlinSerializerCodecTest {
             val codec = KotlinSerializerCodec.create<DataClassWithFailingInit>()
             codec?.decode(BsonDocumentReader(data), DecoderContext.builder().build())
         }
+
+        val exception =
+            assertThrows<SerializationException>("Missing discriminator") {
+                val data = BsonDocument.parse("""{"_id": {"$oid": "111111111111111111111111"}, "name": "string"}""")
+                val codec = KotlinSerializerCodec.create<SealedInterface>()
+                codec?.decode(BsonDocumentReader(data), DecoderContext.builder().build())
+            }
+        assertEquals(
+            "Missing required discriminator field `_t` for polymorphic class: " +
+                "`org.bson.codecs.kotlinx.samples.SealedInterface`.",
+            exception.message)
     }
 
     @Test

bson-kotlinx/src/test/kotlin/org/bson/codecs/kotlinx/samples/DataClasses.kt

@@ -245,6 +245,15 @@ data class DataClassOptionalBsonValues(
 
 @Serializable @SerialName("C") data class DataClassSealedC(val c: String) : DataClassSealed()
 
+@Serializable
+sealed interface SealedInterface {
+    val name: String
+}
+
+@Serializable
+data class DataClassSealedInterface(@Contextual @SerialName("_id") val id: ObjectId, override val name: String) :
+    SealedInterface
+
 @Serializable data class DataClassListOfSealed(val items: List<DataClassSealed>)
 
 interface DataClassOpen