Kotlin Serializer not available for org.axonframework.messaging.MetaData

[ph-teven]

Basic information

• Axon Framework version: 4.11.0
• JDK version: 21
• Kotlin Extension version: 4.11.0

Steps to reproduce

Using the Kotlin Serializer like this:

val json = Json {
    serializersModule = AxonSerializersModule
}
KotlinSerializer(serialFormat = json)

Expected behaviour

MetaData is serialised.

Actual behaviour

Using the Kotlin Serializer gives me the following error:

Serializer for class 'MetaData' is not found.
Please ensure that class is marked as '@Serializable' and that the serialization compiler plugin is applied.

kotlinx.serialization.SerializationException: Serializer for class 'MetaData' is not found.
Please ensure that class is marked as '@Serializable' and that the serialization compiler plugin is applied.

	at kotlinx.serialization.internal.PlatformKt.serializerNotRegistered(Platform.kt:36)
	at kotlinx.serialization.SerializersKt__SerializersJvmKt.serializer(SerializersJvm.kt:77)
	at kotlinx.serialization.SerializersKt.serializer(Unknown Source)
	at org.axonframework.extensions.kotlin.serialization.KotlinSerializer$serializerFor$serializer$1.invoke(KotlinSerializer.kt:162)
	at org.axonframework.extensions.kotlin.serialization.KotlinSerializer$serializerFor$serializer$1.invoke(KotlinSerializer.kt:162)
	at org.axonframework.extensions.kotlin.serialization.KotlinSerializer.serializerFor$lambda$0(KotlinSerializer.kt:162)
	at java.base/java.util.concurrent.ConcurrentHashMap.computeIfAbsent(ConcurrentHashMap.java:1708)
	at org.axonframework.extensions.kotlin.serialization.KotlinSerializer.serializerFor(KotlinSerializer.kt:162)
	at org.axonframework.extensions.kotlin.serialization.KotlinSerializer.serialize(KotlinSerializer.kt:68)
	at org.axonframework.serialization.SerializedObjectHolder.serializeMetaData(SerializedObjectHolder.java:77)
	at org.axonframework.messaging.GenericMessage.serializeMetaData(GenericMessage.java:172)
	at org.axonframework.messaging.MessageDecorator.serializeMetaData(MessageDecorator.java:71)
	at org.axonframework.eventsourcing.eventstore.jdbc.statements.JdbcEventStorageEngineStatements.appendEvents(JdbcEventStorageEngineStatements.java:111)
	at org.axonframework.eventsourcing.eventstore.jdbc.JdbcEventStorageEngine.appendEvents(JdbcEventStorageEngine.java:233)
	at org.axonframework.eventsourcing.eventstore.jdbc.JdbcEventStorageEngine.lambda$null$3(JdbcEventStorageEngine.java:412)
	at org.axonframework.common.jdbc.JdbcUtils.createSqlStatement(JdbcUtils.java:245)
	at org.axonframework.common.jdbc.JdbcUtils.executeBatch(JdbcUtils.java:166)
	at org.axonframework.eventsourcing.eventstore.jdbc.JdbcEventStorageEngine.lambda$appendEvents$5(JdbcEventStorageEngine.java:410)
	at org.axonframework.common.transaction.TransactionManager.executeInTransaction(TransactionManager.java:47)
	at org.axonframework.eventsourcing.eventstore.jdbc.JdbcEventStorageEngine.appendEvents(JdbcEventStorageEngine.java:409)
	at org.axonframework.eventsourcing.eventstore.AbstractEventStorageEngine.appendEvents(AbstractEventStorageEngine.java:105)
	at org.axonframework.eventsourcing.eventstore.AbstractEventStore.prepareCommit(AbstractEventStore.java:66)
	at org.axonframework.eventhandling.AbstractEventBus.doWithEvents(AbstractEventBus.java:256)
	at org.axonframework.eventhandling.AbstractEventBus.lambda$null$11(AbstractEventBus.java:170)
	at org.axonframework.messaging.unitofwork.MessageProcessingContext.notifyHandlers(MessageProcessingContext.java:72)
	at org.axonframework.messaging.unitofwork.DefaultUnitOfWork.notifyHandlers(DefaultUnitOfWork.java:109)
	at org.axonframework.messaging.unitofwork.AbstractUnitOfWork.changePhase(AbstractUnitOfWork.java:236)
	at org.axonframework.messaging.unitofwork.AbstractUnitOfWork.commitAsRoot(AbstractUnitOfWork.java:87)
	at org.axonframework.messaging.unitofwork.AbstractUnitOfWork.commit(AbstractUnitOfWork.java:75)
	at org.axonframework.messaging.unitofwork.DefaultUnitOfWork.executeWithResult(DefaultUnitOfWork.java:95)
	at org.axonframework.commandhandling.SimpleCommandBus.lambda$handle$2(SimpleCommandBus.java:200)
	at org.axonframework.tracing.Span.runSupplier(Span.java:163)
	at org.axonframework.commandhandling.SimpleCommandBus.handle(SimpleCommandBus.java:191)
	at org.axonframework.commandhandling.SimpleCommandBus.doDispatch(SimpleCommandBus.java:165)
	at org.axonframework.commandhandling.SimpleCommandBus.lambda$dispatch$1(SimpleCommandBus.java:131)
	at org.axonframework.tracing.Span.run(Span.java:101)
	at org.axonframework.commandhandling.SimpleCommandBus.dispatch(SimpleCommandBus.java:125)
	at org.axonframework.commandhandling.gateway.AbstractCommandGateway.send(AbstractCommandGateway.java:76)
	at org.axonframework.commandhandling.gateway.DefaultCommandGateway.send(DefaultCommandGateway.java:83)
	at org.axonframework.commandhandling.gateway.DefaultCommandGateway.sendAndWait(DefaultCommandGateway.java:100)

[ph-teven]

I was able to get it working with this serializer.
Since MetaData implements Map it should be possible to use the Kotlinx internal serializer for maps?

My kotlinx.serialization knowledge is too limited but maybe it helps:

object MetaDataSerializer : KSerializer<MetaData> {

    private val mapSerializer = MapSerializer(
        keySerializer = String.serializer(),
        valueSerializer = JsonElement.serializer(),
    )

    override val descriptor: SerialDescriptor = mapSerializer.descriptor

    override fun serialize(encoder: Encoder, value: MetaData) {
        val jsonEncoder = encoder as? JsonEncoder
            ?: throw SerializationException("MetaDataSerializer supports only JSON")

        val jsonMap = value.mapValues { (_, v) ->
            jsonEncoder.json.encodeToJsonElement(
                serializer = guessSerializer(value = v),
                value = v,
            )
        }

        jsonEncoder.encodeJsonElement(JsonObject(jsonMap))
    }

    override fun deserialize(decoder: Decoder): MetaData {
        val jsonDecoder = decoder as? JsonDecoder
            ?: throw SerializationException("MetaDataSerializer supports only JSON")

        val jsonObject = jsonDecoder.decodeJsonElement().jsonObject

        val map = jsonObject.mapValues { (_, v) ->
            parseJsonElement(v)
        }

        return MetaData(map)
    }

    @Suppress("UNCHECKED_CAST")
    private fun guessSerializer(value: Any): KSerializer<Any> = when (value) {
        is String -> String.serializer()
        is Int -> Int.serializer()
        is Long -> Long.serializer()
        is Float -> Float.serializer()
        is Double -> Double.serializer()
        is Boolean -> Boolean.serializer()
        else -> throw SerializationException("Unsupported type: ${value::class}")
    } as KSerializer<Any>

    private fun parseJsonElement(v: JsonElement): Any = when (v) {
        is JsonPrimitive -> when {
            v.isString -> v.content
            v.booleanOrNull != null -> v.boolean
            v.intOrNull != null -> v.int
            v.longOrNull != null -> v.long
            v.floatOrNull != null -> v.float
            v.doubleOrNull != null -> v.double
            else -> v.content
        }

        is JsonObject -> v
        is JsonArray -> v
    }
}

[smcvb]

Thanks for filing this concern with us, @ph-teven.
We did a quick investigation on our end to check whether we could include a quick patch version of the Kotlin Extension that provides support for MetaData.
That way, it could've been included in the 4.11.2 Axon BOM release.

Sadly enough, this takes a bit more time.
Your sample will definitely help, but MetaData can include essentially any type of Object.
We thus need to add some additional testing and logic in place to make that work, or the provide a reasonable default for Object-typed values in the MetaData.

We'll be sure to update this ticket with the progress on our end.
Thanks again for sharing this (rather massive...) misser!