[#380] fix: add MetaDataSerializer

(cherry picked from commit c613f56)

Author: MateuszNaKodach

kotlin/src/main/kotlin/org/axonframework/extensions/kotlin/serialization/MetaDataSerializer.kt

@@ -1,119 +1,72 @@
 package org.axonframework.extensions.kotlin.serialization
 
 import kotlinx.serialization.ExperimentalSerializationApi
-import kotlinx.serialization.InternalSerializationApi
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.MapSerializer
 import kotlinx.serialization.builtins.serializer
 import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.descriptors.mapSerialDescriptor
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
 import kotlinx.serialization.json.*
-import kotlinx.serialization.serializer
 import org.axonframework.messaging.MetaData
 
-/**
- * A serializer for Axon's MetaData class that works with any encoder format.
- * MetaData is essentially a map that can contain primitive values and custom objects.
- *
- * This serializer uses a two-step approach:
- * 1. First, we convert the MetaData to a serializable representation using JSON as an intermediate format
- * 2. Then we use the target encoder to write the final output
- *
- * This approach allows us to properly handle any type of value in the MetaData, including custom objects.
- *
- * @since 4.11.1
- */
 object MetaDataSerializer : KSerializer<MetaData> {
-    // We use Json as an intermediary to convert arbitrary objects to a serializable form
     private val json = Json { encodeDefaults = true; ignoreUnknownKeys = true }
 
-    // Map with String keys and JsonElement values (which can represent any value)
-    private val mapSerializer = MapSerializer(String.serializer(), JsonElement.serializer())
+    private val mapSerializer = MapSerializer(
+        keySerializer = String.serializer(),
+        valueSerializer = JsonElement.serializer()
+    )
 
-    override val descriptor: SerialDescriptor = mapSerializer.descriptor
+    @OptIn(ExperimentalSerializationApi::class)
+    override val descriptor: SerialDescriptor = mapSerialDescriptor(
+        String.serializer().descriptor,
+        JsonElement.serializer().descriptor
+    )
 
     override fun serialize(encoder: Encoder, value: MetaData) {
-        // Convert each value to JsonElement, which can represent any serializable value
-        val jsonMap = value.mapValues { (_, value) ->
-            convertToJsonElement(value)
+        val jsonMap = value.entries.associate { (key, rawValue) ->
+            key to toJsonElement(rawValue)
         }
-
-        // Serialize the map of JsonElements
-        mapSerializer.serialize(encoder, jsonMap)
+        encoder.encodeSerializableValue(mapSerializer, jsonMap)
     }
 
     override fun deserialize(decoder: Decoder): MetaData {
-        // First deserialize to a Map<String, JsonElement>
-        val jsonMap = mapSerializer.deserialize(decoder)
-
-        // Then convert each JsonElement back to its original type
-        val resultMap = jsonMap.mapValues { (_, jsonElement) ->
-            convertFromJsonElement(jsonElement)
-        }
-
-        return MetaData.from(resultMap)
+        val map = decoder.decodeSerializableValue(mapSerializer)
+        val restored = map.mapValues { (_, jsonElement) -> fromJsonElement(jsonElement) }
+        return MetaData(restored)
     }
 
-    /**
-     * Convert any value to a JsonElement
-     */
-    private fun convertToJsonElement(value: Any?): JsonElement {
-        return when (value) {
-            null -> JsonNull
-            is JsonElement -> value
-            is Number -> JsonPrimitive(value)
-            is Boolean -> JsonPrimitive(value)
-            is String -> JsonPrimitive(value)
-            is Enum<*> -> JsonPrimitive(value.name)
-            // For custom objects, use Json to encode them to a JsonElement
-            else -> try {
-                json.encodeToJsonElement(value)
-            } catch (e: Exception) {
-                // If serialization fails, fall back to string representation
-                JsonPrimitive(value.toString())
+    private fun toJsonElement(value: Any?): JsonElement = when (value) {
+        null -> JsonNull
+        is String -> JsonPrimitive(value)
+        is Int -> JsonPrimitive(value)
+        is Long -> JsonPrimitive(value)
+        is Double -> JsonPrimitive(value)
+        is Float -> JsonPrimitive(value)
+        is Boolean -> JsonPrimitive(value)
+        is List<*> -> JsonArray(value.map { toJsonElement(it) })
+        is Map<*, *> -> JsonObject(
+            value.entries.associate { (k, v) ->
+                k.toString() to toJsonElement(v)
             }
-        }
+        )
+        else -> JsonPrimitive(value.toString()) // Fallback toString()
     }
 
-    /**
-     * Convert a JsonElement back to its original type
-     */
-    private fun convertFromJsonElement(element: JsonElement): Any? {
-        return when (element) {
-            is JsonNull -> null
-            is JsonPrimitive -> when {
-                element.isString -> element.content
-                element.booleanOrNull != null -> element.boolean
-                element.longOrNull != null -> element.long
-                element.doubleOrNull != null -> element.double
-                else -> element.content
-            }
-            is JsonArray -> element.map { convertFromJsonElement(it) }
-            is JsonObject -> element.mapValues { (_, value) -> convertFromJsonElement(value) }
-        }
-    }
-
-    /**
-     * Extension method to simplify JSON encoding of arbitrary values
-     */
-    @OptIn(InternalSerializationApi::class, ExperimentalSerializationApi::class)
-    private fun Json.encodeToJsonElement(value: Any): JsonElement {
-        return when (value) {
-            is JsonElement -> value
-            else -> {
-                try {
-                    // Try to find a serializer for this type
-                    val serializer = serializersModule.getContextual(value::class)
-                        ?: value::class.serializer()
-
-                    @Suppress("UNCHECKED_CAST")
-                    encodeToJsonElement(serializer as KSerializer<Any>, value)
-                } catch (e: Exception) {
-                    // If we can't serialize it properly, convert to string
-                    JsonPrimitive(value.toString())
-                }
-            }
+    private fun fromJsonElement(element: JsonElement): Any? = when (element) {
+        is JsonNull -> null
+        is JsonPrimitive -> when {
+            element.isString -> element.content
+            element.booleanOrNull != null -> element.boolean
+            element.intOrNull != null -> element.int
+            element.longOrNull != null -> element.long
+            element.floatOrNull != null -> element.float
+            element.doubleOrNull != null -> element.double
+            else -> element.content
         }
+        is JsonObject -> element.mapValues { fromJsonElement(it.value) }
+        is JsonArray -> element.map { fromJsonElement(it) }
     }
 }