basic support for Kotlin Serialization

[closes #4]

Author: fprochazka

README.md

@@ -227,6 +227,51 @@ But with the index, the `ObjectUuidTypesContributor` reads it, and registers the
 With the classes indexed, the system will know that the `User.Id` should be handled by `ObjectUuidType` and the `@Type(...)` can be dropped.
 This also simplifies usage on every other place, where Hibernate might need to resolve a type for the `Id` instance, like queries.
 
+## Usage: (de)serialization with Jackson
+
+This library provides `ObjectBigIntIdJacksonModule` and `ObjectUuidJacksonModule`, which can be registered automatically via the standard `java.util.ServiceLoader` mechanism, or explicitly.
+
+## Usage: (de)serialization with Kotlin Serialization
+
+This library supports two mechanism for the standard Kotlin Serialization.
+
+### Kotlin Serialization: Explicit
+
+This mechanism requires explicit setup for each ID class
+
+```kotlin
+@Serializable(with = Id.Serializer::class)
+class UserId private constructor(id: UUID) : ObjectUuid<UserId>(id) {
+    // standard boilerplate ...
+
+    object Serializer : ObjectUuidSerializer<UserId>(::UserId)
+}
+```
+
+but in return every time you use it, it just works
+
+```kotlin
+@Serializable
+data class UserDto(val id: UserId)
+```
+
+### Kotlin Serialization: Contextual
+
+With contextual, the standard ID boiler can be used, but you have to register the module
+
+```kotlin
+val json = Json {
+    serializersModule = ObjectUuidKotlinxSerializationModule.fromIndex
+}
+```
+
+and then mark the type as `@Contextual` on every usage
+
+```kotlin
+@Serializable
+data class UserDto(@Contextual val id: UserId)
+```
+
 ## More examples
 
 To learn more you can explore the `testing/` directory of this library,

buildSrc/build.gradle.kts

@@ -8,6 +8,11 @@ repositories {
 }
 
 dependencies {
+    val kotlinVersion = "2.1.0"
+
+    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
+    implementation("org.jetbrains.kotlin:kotlin-serialization:${kotlinVersion}")
+
     implementation("com.adarshr:gradle-test-logger-plugin:4.0.0")
     implementation("io.github.joselion:strict-null-check:3.5.0")
     implementation("net.ltgt.gradle:gradle-errorprone-plugin:4.1.0")

buildSrc/src/main/kotlin/framefork.java.gradle.kts

@@ -1,5 +1,7 @@
 import net.ltgt.gradle.errorprone.errorprone
 import net.ltgt.gradle.nullaway.nullaway
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
     `java-library`
@@ -8,6 +10,7 @@ plugins {
     id("io.github.joselion.strict-null-check")
     id("net.ltgt.errorprone")
     id("net.ltgt.nullaway")
+    id("org.jetbrains.kotlin.jvm")
 }
 
 repositories {
@@ -76,6 +79,19 @@ nullaway {
     annotatedPackages.add("org.framefork")
 }
 
+tasks.withType<KotlinCompile>() {
+    dependsOn("generatePackageInfo")
+
+    compilerOptions {
+        freeCompilerArgs = listOf(
+            "-Xjsr305=strict",
+            "-Xjvm-default=all",
+            "-Xsuppress-version-warnings",
+        )
+        jvmTarget = JvmTarget.JVM_21 // This option specifies the target version of the generated JVM bytecode
+    }
+}
+
 tasks.withType<JavaCompile> {
     options.encoding = "UTF-8"
     options.compilerArgs.add("-Xlint:all,-fallthrough,-processing,-serial,-classfile,-path,-this-escape")

gradle/libs.versions.toml

@@ -34,3 +34,4 @@ hibernate-orm-v66 = { group = "org.hibernate.orm", name = "hibernate-core", vers
 hypersistence-utils-hibernate62 = { group = "io.hypersistence", name = "hypersistence-utils-hibernate-62", version = "3.9.4" }
 hypersistence-utils-hibernate63 = { group = "io.hypersistence", name = "hypersistence-utils-hibernate-63", version = "3.9.9" }
 hypersistence-tsid = { module = "io.hypersistence:hypersistence-tsid", version = "2.1.4" }
+kotlinx-serialization = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version = "1.7.0" }

modules/typed-ids/build.gradle.kts

@@ -14,9 +14,11 @@ dependencies {
     annotationProcessor(libs.autoService.processor)
 
     compileOnly(libs.jackson.databind)
+    compileOnly(libs.kotlinx.serialization)
 
     testImplementation(project(":typed-ids-testing"))
     testImplementation(libs.jackson.databind)
+    testImplementation(libs.kotlinx.serialization)
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }
 

modules/typed-ids/src/main/kotlin/org/framefork/typedIds/bigint/json/kotlinxSerialization/ObjectBigIntIdKotlinxSerializationModule.kt

@@ -0,0 +1,42 @@
+package org.framefork.typedIds.bigint.json.kotlinxSerialization
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.modules.SerializersModule
+import org.framefork.typedIds.TypedIdsRegistry
+import org.framefork.typedIds.bigint.ObjectBigIntId
+import org.framefork.typedIds.bigint.ObjectBigIntIdTypeUtils
+import org.framefork.typedIds.common.ReflectionHacks
+import java.util.concurrent.ConcurrentHashMap
+
+object ObjectBigIntIdKotlinxSerializationModule {
+
+    /**
+     * Uses [org.framefork.typedIds.TypedIdsRegistry] to construct the module.
+     * This requires the ID types are indexed compile-time.
+     */
+    val fromIndex = SerializersModule {
+        for (javaClass in TypedIdsRegistry.getObjectBigIntIdClasses()) {
+            @Suppress("UNCHECKED_CAST")
+            contextual(javaClass.kotlin, typedIdSerializerProvider(javaClass as Any as Class<out ObjectBigIntId<*>>))
+        }
+    }
+
+    private fun <T> typedIdSerializerProvider(javaClass: Class<T>): (typeArgumentsSerializers: List<KSerializer<*>>) -> KSerializer<*> where T : ObjectBigIntId<T> {
+        val fromLongConstructor = Cache.typedIdConstructor(javaClass)
+        return { ObjectBigIntIdSerializer(fromLongConstructor) }
+    }
+
+    private object Cache {
+
+        private val constructorByType = ConcurrentHashMap<String, (Long) -> ObjectBigIntId<*>>()
+
+        @Suppress("UNCHECKED_CAST")
+        fun <T : Any> typedIdConstructor(javaClass: Class<T>): (Long) -> T =
+            constructorByType.computeIfAbsent(javaClass.name) {
+                val mainConstructor = ReflectionHacks.getMainConstructor(javaClass, *arrayOf(Long::class.java));
+                return@computeIfAbsent { raw -> ObjectBigIntIdTypeUtils.wrapBigIntToIdentifier(raw, mainConstructor) };
+            } as (Long) -> T
+
+    }
+
+}

modules/typed-ids/src/main/kotlin/org/framefork/typedIds/bigint/json/kotlinxSerialization/ObjectBigIntIdSerializer.kt

@@ -0,0 +1,26 @@
+package org.framefork.typedIds.bigint.json.kotlinxSerialization
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import org.framefork.typedIds.bigint.ObjectBigIntId
+
+open class ObjectBigIntIdSerializer<T : ObjectBigIntId<*>>(
+    private val fromLongConstructor: (Long) -> T,
+) : KSerializer<T> {
+
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("ObjectBigIntId", PrimitiveKind.STRING)
+
+    override fun serialize(encoder: Encoder, value: T) {
+        encoder.encodeLong(value.toLong());
+    }
+
+    override fun deserialize(decoder: Decoder): T {
+        val rawLong = decoder.decodeLong()
+        return fromLongConstructor.invoke(rawLong)
+    }
+
+}

modules/typed-ids/src/main/kotlin/org/framefork/typedIds/uuid/json/kotlinxSerialization/ObjectUuidKotlinxSerializationModule.kt

@@ -0,0 +1,43 @@
+package org.framefork.typedIds.uuid.json.kotlinxSerialization
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.modules.SerializersModule
+import org.framefork.typedIds.TypedIdsRegistry
+import org.framefork.typedIds.common.ReflectionHacks
+import org.framefork.typedIds.uuid.ObjectUuid
+import org.framefork.typedIds.uuid.ObjectUuidTypeUtils
+import java.util.*
+import java.util.concurrent.ConcurrentHashMap
+
+object ObjectUuidKotlinxSerializationModule {
+
+    /**
+     * Uses [org.framefork.typedIds.TypedIdsRegistry] to construct the module.
+     * This requires the ID types are indexed compile-time.
+     */
+    val fromIndex = SerializersModule {
+        for (javaClass in TypedIdsRegistry.getObjectUuidClasses()) {
+            @Suppress("UNCHECKED_CAST")
+            contextual(javaClass.kotlin, typedIdSerializerProvider(javaClass as Any as Class<out ObjectUuid<*>>))
+        }
+    }
+
+    private fun <T> typedIdSerializerProvider(javaClass: Class<T>): (typeArgumentsSerializers: List<KSerializer<*>>) -> KSerializer<*> where T : ObjectUuid<T> {
+        val fromUuidConstructor = Cache.typedIdConstructor(javaClass)
+        return { ObjectUuidSerializer(fromUuidConstructor) }
+    }
+
+    private object Cache {
+
+        private val constructorByType = ConcurrentHashMap<String, (UUID) -> ObjectUuid<*>>()
+
+        @Suppress("UNCHECKED_CAST")
+        fun <T : Any> typedIdConstructor(javaClass: Class<T>): (UUID) -> T =
+            constructorByType.computeIfAbsent(javaClass.name) {
+                val mainConstructor = ReflectionHacks.getMainConstructor(javaClass, *arrayOf(UUID::class.java));
+                return@computeIfAbsent { raw -> ObjectUuidTypeUtils.wrapUuidToIdentifier(raw, mainConstructor) };
+            } as (UUID) -> T
+
+    }
+
+}

modules/typed-ids/src/main/kotlin/org/framefork/typedIds/uuid/json/kotlinxSerialization/ObjectUuidSerializer.kt

@@ -0,0 +1,27 @@
+package org.framefork.typedIds.uuid.json.kotlinxSerialization
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import org.framefork.typedIds.uuid.ObjectUuid
+import java.util.*
+
+open class ObjectUuidSerializer<T : ObjectUuid<*>>(
+    private val fromUuidConstructor: (UUID) -> T,
+) : KSerializer<T> {
+
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("ObjectUuid", PrimitiveKind.STRING)
+
+    override fun serialize(encoder: Encoder, value: T) {
+        encoder.encodeString(value.toString());
+    }
+
+    override fun deserialize(decoder: Decoder): T {
+        val rawUuid = UUID.fromString(decoder.decodeString())
+        return fromUuidConstructor.invoke(rawUuid)
+    }
+
+}

testing/testing-typed-ids-kotlin-serialization-indexed/build.gradle.kts

@@ -0,0 +1,15 @@
+plugins {
+    id("framefork.java")
+    kotlin("plugin.serialization")
+    kotlin("kapt")
+}
+
+dependencies {
+    implementation(project(":typed-ids"))
+    implementation(libs.kotlinx.serialization)
+
+    kapt(project(":typed-ids-index-java-classes-processor"))
+
+    testImplementation(project(":typed-ids-testing"))
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+}

testing/testing-typed-ids-kotlin-serialization-indexed/src/test/kotlin/org/framefork/typedIds/bigint/kotlinxSerialization/ObjectBigIntIdKotlinxSerializationContextualTest.kt

@@ -0,0 +1,45 @@
+package org.framefork.typedIds.bigint.kotlinxSerialization
+
+import kotlinx.serialization.Contextual
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import org.assertj.core.api.Assertions.assertThat
+import org.framefork.typedIds.bigint.ObjectBigIntId
+import org.framefork.typedIds.bigint.json.kotlinxSerialization.ObjectBigIntIdKotlinxSerializationModule
+import org.junit.jupiter.api.Test
+
+class ObjectBigIntIdKotlinxSerializationContextualTest {
+
+    val json = Json {
+        serializersModule = ObjectBigIntIdKotlinxSerializationModule.fromIndex
+    }
+
+    @Test
+    fun functional() {
+        val id = UserEntity.Id.from(42)
+        val dto = UserDto(id)
+
+        val dtoJson = json.encodeToString(dto)
+        assertThat(dtoJson).isEqualTo("""{"id":42}""")
+
+        val decodedDto = json.decodeFromString<UserDto>(dtoJson)
+        assertThat(decodedDto).isEqualTo(dto)
+    }
+
+    @Serializable
+    data class UserDto(@Contextual val id: UserEntity.Id)
+
+    class UserEntity(val id: Id) {
+
+        class Id private constructor(id: Long) : ObjectBigIntId<Id>(id) {
+            companion object {
+                fun random() = randomBigInt(::Id)
+                fun from(value: String) = fromString(::Id, value)
+                fun from(value: Long) = fromLong(::Id, value)
+            }
+        }
+
+    }
+
+}

testing/testing-typed-ids-kotlin-serialization-indexed/src/test/kotlin/org/framefork/typedIds/bigint/kotlinxSerialization/ObjectBigIntIdKotlinxSerializationExplicitTest.kt

@@ -0,0 +1,45 @@
+package org.framefork.typedIds.bigint.kotlinxSerialization
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import org.assertj.core.api.Assertions.assertThat
+import org.framefork.typedIds.bigint.ObjectBigIntId
+import org.framefork.typedIds.bigint.json.kotlinxSerialization.ObjectBigIntIdSerializer
+import org.junit.jupiter.api.Test
+
+class ObjectBigIntIdKotlinxSerializationExplicitTest {
+
+    val json = Json.Default
+
+    @Test
+    fun functional() {
+        val id = UserEntity.Id.from(42)
+        val dto = UserDto(id)
+
+        val dtoJson = json.encodeToString(dto)
+        assertThat(dtoJson).isEqualTo("""{"id":42}""")
+
+        val decodedDto = json.decodeFromString<UserDto>(dtoJson)
+        assertThat(decodedDto).isEqualTo(dto)
+    }
+
+    @Serializable
+    data class UserDto(val id: UserEntity.Id)
+
+    class UserEntity(val id: Id) {
+
+        @Serializable(with = Id.Serializer::class)
+        class Id private constructor(id: Long) : ObjectBigIntId<Id>(id) {
+            companion object {
+                fun random() = randomBigInt(::Id)
+                fun from(value: String) = fromString(::Id, value)
+                fun from(value: Long) = fromLong(::Id, value)
+            }
+
+            object Serializer : ObjectBigIntIdSerializer<Id>(::Id)
+        }
+
+    }
+
+}