Add support for type adapters

CHANGELOG.md

@@ -4,7 +4,7 @@
 * None.
 
 ### Enhancements
-* None.
+* Add support for persisting custom types using Realm type adapters. (Issue [#587](https://github.com/realm/realm-kotlin/issues/587))
 
 ### Fixed
 * None.

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/Configuration.kt

@@ -25,6 +25,7 @@ import io.realm.kotlin.log.LogLevel
 import io.realm.kotlin.log.RealmLog
 import io.realm.kotlin.log.RealmLogger
 import io.realm.kotlin.types.BaseRealmObject
+import io.realm.kotlin.types.RealmTypeAdapter
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlin.reflect.KClass
 
@@ -49,6 +50,16 @@ public fun interface CompactOnLaunchCallback {
     public fun shouldCompact(totalBytes: Long, usedBytes: Long): Boolean
 }
 
+/**
+ * Builder for setting up any runtime type adapters.
+ */
+public class TypeAdapterBuilder {
+    internal val typeAdapters: MutableList<RealmTypeAdapter<*, *>> = mutableListOf()
+    public fun add(adapter: RealmTypeAdapter<*, *>) {
+        typeAdapters.add(adapter)
+    }
+}
+
 /**
  * This interface is used to write data to a Realm file when the file is first created.
  * It will be used in a way similar to using [Realm.writeBlocking].
@@ -196,6 +207,11 @@ public interface Configuration {
      */
     public val initialRealmFileConfiguration: InitialRealmFileConfiguration?
 
+    /**
+     * List of types adapters that would be available in runtime.
+     */
+    public val typeAdapters: List<RealmTypeAdapter<*, *>>
+
     /**
      * Base class for configuration builders that holds properties available to both
      * [RealmConfiguration] and [SyncConfiguration].
@@ -238,6 +254,7 @@ public interface Configuration {
         protected var initialDataCallback: InitialDataCallback? = null
         protected var inMemory: Boolean = false
         protected var initialRealmFileConfiguration: InitialRealmFileConfiguration? = null
+        protected var typeAdapters: List<RealmTypeAdapter<*, *>> = listOf()
 
         /**
          * Sets the filename of the realm file.

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/RealmConfiguration.kt

@@ -89,6 +89,14 @@ public interface RealmConfiguration : Configuration {
         public fun directory(directoryPath: String): Builder =
             apply { this.directory = directoryPath }
 
+        /**
+         * Sets the type adapters that would be available in runtime.
+         */
+        public fun typeAdapters(block: TypeAdapterBuilder.() -> Unit): Builder =
+            apply {
+                this.typeAdapters = TypeAdapterBuilder().apply(block).typeAdapters
+            }
+
         /**
          * Setting this will change the behavior of how migration exceptions are handled. Instead of
          * throwing an exception the on-disc Realm will be cleared and recreated with the new Realm
@@ -192,7 +200,8 @@ public interface RealmConfiguration : Configuration {
                 initialDataCallback,
                 inMemory,
                 initialRealmFileConfiguration,
-                realmLogger
+                realmLogger,
+                typeAdapters,
             )
         }
     }

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/internal/ConfigurationImpl.kt

@@ -45,6 +45,7 @@ import io.realm.kotlin.internal.util.CoroutineDispatcherFactory
 import io.realm.kotlin.migration.AutomaticSchemaMigration
 import io.realm.kotlin.migration.RealmMigration
 import io.realm.kotlin.types.BaseRealmObject
+import io.realm.kotlin.types.RealmTypeAdapter
 import kotlin.reflect.KClass
 
 // TODO Public due to being accessed from `library-sync`
@@ -67,7 +68,8 @@ public open class ConfigurationImpl(
     override val isFlexibleSyncConfiguration: Boolean,
     inMemory: Boolean,
     initialRealmFileConfiguration: InitialRealmFileConfiguration?,
-    logger: ContextLogger
+    logger: ContextLogger,
+    override val typeAdapters: List<RealmTypeAdapter<*, *>>,
 ) : InternalConfiguration {
 
     override val path: String
@@ -102,6 +104,7 @@ public open class ConfigurationImpl(
     override val initialDataCallback: InitialDataCallback?
     override val inMemory: Boolean
     override val initialRealmFileConfiguration: InitialRealmFileConfiguration?
+    override val typeAdapterMap: Map<KClass<*>, RealmTypeAdapter<*, *>>
 
     override fun createNativeConfiguration(): RealmConfigurationPointer {
         val nativeConfig: RealmConfigurationPointer = RealmInterop.realm_config_new()
@@ -148,6 +151,7 @@ public open class ConfigurationImpl(
         this.initialDataCallback = initialDataCallback
         this.inMemory = inMemory
         this.initialRealmFileConfiguration = initialRealmFileConfiguration
+        this.typeAdapterMap = typeAdapters.associateBy { it::class }
 
         // We need to freeze `compactOnLaunchCallback` reference on initial thread for Kotlin Native
         val compactCallback = compactOnLaunchCallback?.let { callback ->

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/internal/Converters.kt

@@ -36,6 +36,7 @@ import io.realm.kotlin.types.ObjectId
 import io.realm.kotlin.types.RealmAny
 import io.realm.kotlin.types.RealmInstant
 import io.realm.kotlin.types.RealmObject
+import io.realm.kotlin.types.RealmTypeAdapter
 import io.realm.kotlin.types.RealmUUID
 import io.realm.kotlin.types.geo.GeoBox
 import io.realm.kotlin.types.geo.GeoCircle
@@ -259,6 +260,29 @@ internal object IntConverter : CoreIntConverter, CompositeConverter<Int, Long>()
 public inline fun intToLong(value: Int?): Long? = value?.toLong()
 public inline fun longToInt(value: Long?): Int? = value?.toInt()
 
+public fun getTypeAdapter(
+    obj: RealmObjectReference<out BaseRealmObject>,
+    adapterClass: KClass<*>,
+): RealmTypeAdapter<Any?, Any?> =
+    obj.owner.owner
+        .configuration
+        .typeAdapterMap.let { adapters ->
+            require(adapters.contains(adapterClass)) { "User provided adaptes don't contains adapter ${adapterClass.simpleName}" }
+            adapters[adapterClass] as RealmTypeAdapter<Any?, Any?>
+        }
+
+public inline fun toRealm(
+    obj: RealmObjectReference<out BaseRealmObject>,
+    adapterClass: KClass<*>,
+    userValue: Any?,
+): Any? = getTypeAdapter(obj, adapterClass).toRealm(userValue)
+
+public inline fun fromRealm(
+    obj: RealmObjectReference<out BaseRealmObject>,
+    adapterClass: KClass<*>,
+    realmValue: Any,
+): Any? = getTypeAdapter(obj, adapterClass).toPublic(realmValue)
+
 internal object RealmInstantConverter : PassThroughPublicConverter<RealmInstant>() {
     override inline fun fromRealmValue(realmValue: RealmValue): RealmInstant? =
         if (realmValue.isNull()) null else realmValueToRealmInstant(realmValue)

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/internal/InternalConfiguration.kt

@@ -21,6 +21,7 @@ import io.realm.kotlin.internal.interop.RealmConfigurationPointer
 import io.realm.kotlin.internal.interop.SchemaMode
 import io.realm.kotlin.internal.util.CoroutineDispatcherFactory
 import io.realm.kotlin.types.BaseRealmObject
+import io.realm.kotlin.types.RealmTypeAdapter
 import kotlin.reflect.KClass
 
 /**
@@ -36,6 +37,7 @@ public interface InternalConfiguration : Configuration {
     public val writeDispatcherFactory: CoroutineDispatcherFactory
     public val schemaMode: SchemaMode
     public val logger: ContextLogger
+    public val typeAdapterMap: Map<KClass<*>, RealmTypeAdapter<*, *>>
 
     // Temporary work-around for https://github.com/realm/realm-kotlin/issues/724
     public val isFlexibleSyncConfiguration: Boolean

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/internal/RealmConfigurationImpl.kt

@@ -25,6 +25,7 @@ import io.realm.kotlin.internal.interop.SchemaMode
 import io.realm.kotlin.internal.util.CoroutineDispatcherFactory
 import io.realm.kotlin.migration.RealmMigration
 import io.realm.kotlin.types.BaseRealmObject
+import io.realm.kotlin.types.RealmTypeAdapter
 import kotlin.reflect.KClass
 
 public const val REALM_FILE_EXTENSION: String = ".realm"
@@ -47,7 +48,8 @@ internal class RealmConfigurationImpl(
     initialDataCallback: InitialDataCallback?,
     inMemory: Boolean,
     override val initialRealmFileConfiguration: InitialRealmFileConfiguration?,
-    logger: ContextLogger
+    logger: ContextLogger,
+    typeAdapters: List<RealmTypeAdapter<*, *>>
 ) : ConfigurationImpl(
     directory,
     name,
@@ -69,6 +71,7 @@ internal class RealmConfigurationImpl(
     false,
     inMemory,
     initialRealmFileConfiguration,
-    logger
+    logger,
+    typeAdapters,
 ),
     RealmConfiguration

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/internal/RealmListInternal.kt

@@ -41,6 +41,7 @@ import io.realm.kotlin.notifications.internal.UpdatedListImpl
 import io.realm.kotlin.query.RealmQuery
 import io.realm.kotlin.types.BaseRealmObject
 import io.realm.kotlin.types.RealmList
+import io.realm.kotlin.types.RealmTypeAdapter
 import kotlinx.coroutines.channels.ProducerScope
 import kotlinx.coroutines.flow.Flow
 import kotlin.reflect.KClass
@@ -249,6 +250,37 @@ internal interface ListOperator<E> : CollectionOperator<E, RealmListPointer> {
     fun copy(realmReference: RealmReference, nativePointer: RealmListPointer): ListOperator<E>
 }
 
+internal class TypeAdaptedListOperator<E, S>(
+    private val listOperator: ListOperator<S>,
+    private val typeAdapter: RealmTypeAdapter<S, E>
+) : ListOperator<E> {
+    override val nativePointer: RealmListPointer by listOperator::nativePointer
+    override val mediator: Mediator by listOperator::mediator
+    override val realmReference: RealmReference by listOperator::realmReference
+    override val valueConverter: RealmValueConverter<E> by lazy { throw IllegalStateException("TypeAdaptedListOperator does not have a valueConverter") }
+
+    override fun get(index: Int): E = typeAdapter.toPublic(listOperator.get(index))
+
+    override fun copy(
+        realmReference: RealmReference,
+        nativePointer: RealmListPointer,
+    ): ListOperator<E> = TypeAdaptedListOperator(listOperator.copy(realmReference, nativePointer), typeAdapter)
+
+    override fun set(
+        index: Int,
+        element: E,
+        updatePolicy: UpdatePolicy,
+        cache: UnmanagedToManagedObjectCache,
+    ): E = typeAdapter.toPublic(listOperator.set(index, typeAdapter.toRealm(element), updatePolicy, cache))
+
+    override fun insert(
+        index: Int,
+        element: E,
+        updatePolicy: UpdatePolicy,
+        cache: UnmanagedToManagedObjectCache,
+    ) = listOperator.insert(index, typeAdapter.toRealm(element), updatePolicy, cache)
+}
+
 internal class PrimitiveListOperator<E>(
     override val mediator: Mediator,
     override val realmReference: RealmReference,

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/internal/RealmMapInternal.kt

@@ -51,6 +51,7 @@ import io.realm.kotlin.types.BaseRealmObject
 import io.realm.kotlin.types.RealmAny
 import io.realm.kotlin.types.RealmDictionary
 import io.realm.kotlin.types.RealmMap
+import io.realm.kotlin.types.RealmTypeAdapter
 import kotlinx.coroutines.channels.ProducerScope
 import kotlinx.coroutines.flow.Flow
 import kotlin.reflect.KClass
@@ -286,6 +287,55 @@ internal interface MapOperator<K, V> : CollectionOperator<V, RealmMapPointer> {
     fun copy(realmReference: RealmReference, nativePointer: RealmMapPointer): MapOperator<K, V>
 }
 
+internal class TypeAdaptedMapOperator<K, E, S>(
+    val mapOperator: MapOperator<K, S>,
+    val typeAdapter: RealmTypeAdapter<S, E>
+) : MapOperator<K, E> {
+    override var modCount: Int by mapOperator::modCount
+    override val keyConverter: RealmValueConverter<K> by mapOperator::keyConverter
+    override val nativePointer: RealmMapPointer by mapOperator::nativePointer
+
+    override fun getEntryInternal(position: Int): Pair<K, E> = mapOperator
+        .getEntryInternal(position)
+        .run {
+            Pair(first, typeAdapter.toPublic(second))
+        }
+
+    override fun copy(
+        realmReference: RealmReference,
+        nativePointer: RealmMapPointer,
+    ): MapOperator<K, E> = TypeAdaptedMapOperator(mapOperator.copy(realmReference, nativePointer), typeAdapter)
+
+    override fun areValuesEqual(expected: E?, actual: E?): Boolean = mapOperator.areValuesEqual(
+        expected?.let { typeAdapter.toRealm(it) }, actual?.let { typeAdapter.toRealm(it) }
+    )
+
+    override fun containsValueInternal(value: E): Boolean = mapOperator.containsValueInternal(typeAdapter.toRealm(value))
+
+    override fun getInternal(key: K): E? = mapOperator.getInternal(key)
+        ?.let { typeAdapter.toPublic(it) }
+
+    override fun eraseInternal(key: K): Pair<E?, Boolean> = mapOperator.eraseInternal(key).run {
+        Pair(first?.let { typeAdapter.toPublic(it) }, second)
+    }
+
+    override fun insertInternal(
+        key: K,
+        value: E?,
+        updatePolicy: UpdatePolicy,
+        cache: UnmanagedToManagedObjectCache,
+    ): Pair<E?, Boolean> = mapOperator.insertInternal(
+        key,
+        value?.let { typeAdapter.toRealm(it) }, updatePolicy, cache
+    ).run {
+        Pair(first?.let { typeAdapter.toPublic(it) }, second)
+    }
+
+    override val mediator: Mediator by mapOperator::mediator
+    override val realmReference: RealmReference by mapOperator::realmReference
+    override val valueConverter: RealmValueConverter<E> by lazy { throw IllegalStateException("TypeAdaptedMapOperator does not have a valueConverter") }
+}
+
 internal open class PrimitiveMapOperator<K, V> constructor(
     override val mediator: Mediator,
     override val realmReference: RealmReference,