expo-modules-core 0.7.0 → 0.9.1

package/android/src/main/java/expo/modules/kotlin/records/FieldValidator.kt

@@ -0,0 +1,139 @@
+package expo.modules.kotlin.records
+
+import expo.modules.kotlin.exception.ValidationException
+
+interface FieldValidator<T> {
+  fun validate(value: T)
+}
+
+class NumericRangeValidator<T : Comparable<T>>(
+  private val from: T,
+  private val to: T,
+  private val fromInclusive: Boolean,
+  private val toInclusive: Boolean
+) : FieldValidator<T> {
+  override fun validate(value: T) {
+    if (
+      value < from ||
+      to < value ||
+      value == from && !fromInclusive ||
+      value == to && !toInclusive
+    ) {
+      throw ValidationException("Value should be in range $from ${if (fromInclusive) "<=" else "<"} 'value' ${if (toInclusive) "<=" else "<"} $to, got $value")
+    }
+  }
+}
+
+class IsNotEmptyCollectionValidator : FieldValidator<Collection<*>> {
+  override fun validate(value: Collection<*>) {
+    if (value.isEmpty()) {
+      throw ValidationException("Collection is empty")
+    }
+  }
+}
+
+class IsNotEmptyIntArrayValidator : FieldValidator<IntArray> {
+  override fun validate(value: IntArray) {
+    if (value.isEmpty()) {
+      throw ValidationException("Array is empty")
+    }
+  }
+}
+
+class IsNotEmptyFloatArrayValidator : FieldValidator<FloatArray> {
+  override fun validate(value: FloatArray) {
+    if (value.isEmpty()) {
+      throw ValidationException("Array is empty")
+    }
+  }
+}
+
+class IsNotEmptyDoubleArrayValidator : FieldValidator<DoubleArray> {
+  override fun validate(value: DoubleArray) {
+    if (value.isEmpty()) {
+      throw ValidationException("Array is empty")
+    }
+  }
+}
+
+class IsNotEmptyArrayValidator : FieldValidator<Array<*>> {
+  override fun validate(value: Array<*>) {
+    if (value.isEmpty()) {
+      throw ValidationException("Array is empty")
+    }
+  }
+}
+
+class CollectionSizeValidator(
+  private val min: Int,
+  private val max: Int
+) : FieldValidator<Collection<*>> {
+  override fun validate(value: Collection<*>) {
+    if (value.size < min || value.size > max) {
+      throw ValidationException("Number of elements in the collection should be between $min and $max, got ${value.size}")
+    }
+  }
+}
+
+class IntArraySizeValidator(
+  private val min: Int,
+  private val max: Int
+) : FieldValidator<IntArray> {
+  override fun validate(value: IntArray) {
+    if (value.size < min || value.size > max) {
+      throw ValidationException("Number of elements in the array should be between $min and $max, got ${value.size}")
+    }
+  }
+}
+
+class DoubleArraySizeValidator(
+  private val min: Int,
+  private val max: Int
+) : FieldValidator<DoubleArray> {
+  override fun validate(value: DoubleArray) {
+    if (value.size < min || value.size > max) {
+      throw ValidationException("Number of elements in the array should be between $min and $max, got ${value.size}")
+    }
+  }
+}
+
+class FloatArraySizeValidator(
+  private val min: Int,
+  private val max: Int
+) : FieldValidator<FloatArray> {
+  override fun validate(value: FloatArray) {
+    if (value.size < min || value.size > max) {
+      throw ValidationException("Number of elements in the array should be between $min and $max, got ${value.size}")
+    }
+  }
+}
+
+class ArraySizeValidator(
+  private val min: Int,
+  private val max: Int
+) : FieldValidator<Array<*>> {
+  override fun validate(value: Array<*>) {
+    if (value.size < min || value.size > max) {
+      throw ValidationException("Number of elements in the array should be between $min and $max, got ${value.size}")
+    }
+  }
+}
+
+class StringSizeValidator(
+  private val min: Int,
+  private val max: Int
+) : FieldValidator<String> {
+  override fun validate(value: String) {
+    if (value.length < min || value.length > max) {
+      throw ValidationException("Length of the string should be between $min and $max, got $value (${value.length} characters)")
+    }
+  }
+}
+
+class RegexValidator(private val regex: Regex) : FieldValidator<CharSequence> {
+  override fun validate(value: CharSequence) {
+    if (!regex.matches(value)) {
+      throw ValidationException("Provided string $value didn't match regex $regex")
+    }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/records/Record.kt

@@ -1,42 +1,3 @@
 package expo.modules.kotlin.records
 
-import android.os.Bundle
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.ReadableMap
-import java.lang.IllegalArgumentException
-import kotlin.reflect.full.findAnnotation
-import kotlin.reflect.full.memberProperties
-import kotlin.reflect.jvm.isAccessible
-
 interface Record
-
-fun Record.toJSMap(): ReadableMap {
-  val writableMap = Arguments.createMap()
-  javaClass
-    .kotlin
-    .memberProperties.map { property ->
-      val fieldInformation = property.findAnnotation<Field>() ?: return@map
-      val jsKey = fieldInformation.key.takeUnless { it == "" } ?: property.name
-
-      property.isAccessible = true
-
-      // TODO(@lukmccall): add more sophisticated conversion method
-      when (val value = property.get(this)) {
-        null, is Unit -> writableMap.putNull(jsKey)
-        is Boolean -> writableMap.putBoolean(jsKey, value)
-        is Int -> writableMap.putInt(jsKey, value)
-        is Number -> writableMap.putDouble(jsKey, value.toDouble())
-        is String -> writableMap.putString(jsKey, value)
-        is ReadableArray -> writableMap.putArray(jsKey, value)
-        is ReadableMap -> writableMap.putMap(jsKey, value)
-        is Record -> writableMap.putMap(jsKey, value.toJSMap())
-        is Bundle -> writableMap.putMap(jsKey, Arguments.fromBundle(value))
-        is List<*> -> writableMap.putArray(jsKey, Arguments.fromList(value))
-        is Array<*> -> writableMap.putArray(jsKey, Arguments.fromArray(value))
-        else -> throw IllegalArgumentException("Could not convert " + value.javaClass)
-      }
-    }
-
-  return writableMap
-}

package/android/src/main/java/expo/modules/kotlin/records/RecordTypeConverter.kt

@@ -4,23 +4,41 @@ import com.facebook.react.bridge.Dynamic
 import expo.modules.kotlin.allocators.ObjectConstructor
 import expo.modules.kotlin.allocators.ObjectConstructorFactory
 import expo.modules.kotlin.exception.FieldCastException
+import expo.modules.kotlin.exception.FieldRequiredException
 import expo.modules.kotlin.exception.RecordCastException
 import expo.modules.kotlin.exception.exceptionDecorator
 import expo.modules.kotlin.recycle
 import expo.modules.kotlin.types.TypeConverter
 import expo.modules.kotlin.types.TypeConverterProvider
 import kotlin.reflect.KClass
+import kotlin.reflect.KProperty1
 import kotlin.reflect.KType
+import kotlin.reflect.full.createInstance
 import kotlin.reflect.full.findAnnotation
 import kotlin.reflect.full.memberProperties
 import kotlin.reflect.jvm.javaField
 
-// TODO(@lukmccall): create all converters during initialization
 class RecordTypeConverter<T : Record>(
   private val converterProvider: TypeConverterProvider,
   val type: KType,
 ) : TypeConverter<T>(type.isMarkedNullable) {
   private val objectConstructorFactory = ObjectConstructorFactory()
+  private val propertyDescriptors: Map<KProperty1<out Any, *>, PropertyDescriptor> =
+    (type.classifier as KClass<*>)
+      .memberProperties
+      .map { property ->
+        val fieldAnnotation = property.findAnnotation<Field>() ?: return@map null
+        val typeConverter = converterProvider.obtainTypeConverter(property.returnType)
+
+        return@map property to PropertyDescriptor(
+          typeConverter,
+          fieldAnnotation,
+          isRequired = property.findAnnotation<Required>() != null,
+          validators = getValidators(property)
+        )
+      }
+      .filterNotNull()
+      .toMap()
 
   override fun convertNonOptional(value: Dynamic): T = exceptionDecorator({ cause -> RecordCastException(type, cause) }) {
     val jsMap = value.asMap()
@@ -28,23 +46,32 @@ class RecordTypeConverter<T : Record>(
     val kClass = type.classifier as KClass<*>
     val instance = getObjectConstructor(kClass.java).construct()
 
-    kClass
-      .memberProperties
-      .map { property ->
-        val filedInformation = property.findAnnotation<Field>() ?: return@map
-        val jsKey = filedInformation.key.takeUnless { it == "" } ?: property.name
+    propertyDescriptors
+      .forEach { (property, descriptor) ->
+        val jsKey = descriptor.fieldAnnotation.key.takeUnless { it.isBlank() } ?: property.name
 
         if (!jsMap.hasKey(jsKey)) {
-          // TODO(@lukmccall): handle required keys
-          return@map
+          if (descriptor.isRequired) {
+            throw FieldRequiredException(property)
+          }
+
+          return@forEach
         }
 
         jsMap.getDynamic(jsKey).recycle {
           val javaField = property.javaField!!
 
-          val elementConverter = converterProvider.obtainTypeConverter(property.returnType)
           val casted = exceptionDecorator({ cause -> FieldCastException(property.name, property.returnType, type, cause) }) {
-            elementConverter.convert(this)
+            descriptor.typeConverter.convert(this)
+          }
+
+          if (casted != null) {
+            descriptor
+              .validators
+              .forEach { validator ->
+                @Suppress("UNCHECKED_CAST")
+                (validator as FieldValidator<Any>).validate(casted)
+              }
           }
 
           javaField.isAccessible = true
@@ -59,4 +86,26 @@ class RecordTypeConverter<T : Record>(
   private fun <T> getObjectConstructor(clazz: Class<T>): ObjectConstructor<T> {
     return objectConstructorFactory.get(clazz)
   }
+
+  private fun getValidators(property: KProperty1<out Any, *>): List<FieldValidator<*>> {
+    return property
+      .annotations
+      .map findValidators@{ annotation ->
+        val binderAnnotation = annotation.annotationClass.findAnnotation<BindUsing>()
+          ?: return@findValidators null
+        annotation to binderAnnotation
+      }
+      .filterNotNull()
+      .map { (annotation, binderAnnotation) ->
+        val binderInstance = binderAnnotation.binder.createInstance() as ValidationBinder
+        binderInstance.bind(annotation, property.returnType)
+      }
+  }
+
+  private data class PropertyDescriptor(
+    val typeConverter: TypeConverter<*>,
+    val fieldAnnotation: Field,
+    val isRequired: Boolean,
+    val validators: List<FieldValidator<*>>
+  )
 }

package/android/src/main/java/expo/modules/kotlin/records/Required.kt

@@ -0,0 +1,5 @@
+package expo.modules.kotlin.records
+
+@Target(AnnotationTarget.PROPERTY)
+@Retention(AnnotationRetention.RUNTIME)
+annotation class Required

package/android/src/main/java/expo/modules/kotlin/records/ValidationBinder.kt

@@ -0,0 +1,110 @@
+package expo.modules.kotlin.records
+
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.full.createType
+import kotlin.reflect.full.isSubclassOf
+
+interface ValidationBinder {
+  fun bind(annotation: Annotation, fieldType: KType): FieldValidator<*>
+}
+
+@Retention(AnnotationRetention.RUNTIME)
+@Target(AnnotationTarget.ANNOTATION_CLASS)
+annotation class BindUsing(val binder: KClass<*>)
+
+internal class IntRangeBinder : ValidationBinder {
+  override fun bind(annotation: Annotation, fieldType: KType): FieldValidator<*> {
+    val rangeAnnotation = annotation as IntRange
+    return NumericRangeValidator(
+      rangeAnnotation.from,
+      rangeAnnotation.to,
+      rangeAnnotation.fromInclusive,
+      rangeAnnotation.toInclusive
+    )
+  }
+}
+
+internal class LongRangeBinder : ValidationBinder {
+  override fun bind(annotation: Annotation, fieldType: KType): FieldValidator<*> {
+    val rangeAnnotation = annotation as LongRange
+    return NumericRangeValidator(
+      rangeAnnotation.from,
+      rangeAnnotation.to,
+      rangeAnnotation.fromInclusive,
+      rangeAnnotation.toInclusive
+    )
+  }
+}
+
+internal class FloatRangeBinder : ValidationBinder {
+  override fun bind(annotation: Annotation, fieldType: KType): FieldValidator<*> {
+    val rangeAnnotation = annotation as FloatRange
+    return NumericRangeValidator(
+      rangeAnnotation.from,
+      rangeAnnotation.to,
+      rangeAnnotation.fromInclusive,
+      rangeAnnotation.toInclusive
+    )
+  }
+}
+
+internal class DoubleRangeBinder : ValidationBinder {
+  override fun bind(annotation: Annotation, fieldType: KType): FieldValidator<*> {
+    val rangeAnnotation = annotation as DoubleRange
+    return NumericRangeValidator(
+      rangeAnnotation.from,
+      rangeAnnotation.to,
+      rangeAnnotation.fromInclusive,
+      rangeAnnotation.toInclusive
+    )
+  }
+}
+
+internal class IsCollectionNotEmptyBinder : ValidationBinder {
+  override fun bind(annotation: Annotation, fieldType: KType): FieldValidator<*> {
+    assert(annotation is IsNotEmpty)
+
+    when (fieldType) {
+      IntArray::class.createType() -> return IsNotEmptyIntArrayValidator()
+      DoubleArray::class.createType() -> return IsNotEmptyDoubleArrayValidator()
+      FloatArray::class.createType() -> return IsNotEmptyFloatArrayValidator()
+    }
+
+    val kClass = fieldType.classifier as KClass<*>
+    if (kClass.isSubclassOf(Array::class) || kClass.java.isArray) {
+      return IsNotEmptyArrayValidator()
+    }
+
+    return IsNotEmptyCollectionValidator()
+  }
+}
+
+internal class SizeBinder : ValidationBinder {
+  override fun bind(annotation: Annotation, fieldType: KType): FieldValidator<*> {
+    val sizeAnnotation = annotation as Size
+
+    when (fieldType) {
+      IntArray::class.createType() -> return IntArraySizeValidator(sizeAnnotation.min, sizeAnnotation.max)
+      DoubleArray::class.createType() -> return DoubleArraySizeValidator(sizeAnnotation.min, sizeAnnotation.max)
+      FloatArray::class.createType() -> return FloatArraySizeValidator(sizeAnnotation.min, sizeAnnotation.max)
+    }
+
+    val kClass = fieldType.classifier as KClass<*>
+
+    if (kClass.isSubclassOf(String::class)) {
+      return StringSizeValidator(sizeAnnotation.min, sizeAnnotation.max)
+    } else if (kClass.isSubclassOf(Array::class) || kClass.java.isArray) {
+      return ArraySizeValidator(sizeAnnotation.min, sizeAnnotation.max)
+    }
+
+    return CollectionSizeValidator(sizeAnnotation.min, sizeAnnotation.max)
+  }
+}
+
+internal class RegexBinder : ValidationBinder {
+  override fun bind(annotation: Annotation, fieldType: KType): FieldValidator<*> {
+    val regexAnnotation = annotation as RegularExpression
+    return RegexValidator(regexAnnotation.regex.toRegex())
+  }
+}

package/android/src/main/java/expo/modules/kotlin/records/Validators.kt

@@ -0,0 +1,61 @@
+package expo.modules.kotlin.records
+
+@Retention(AnnotationRetention.RUNTIME)
+@Target(AnnotationTarget.PROPERTY, AnnotationTarget.TYPE, AnnotationTarget.VALUE_PARAMETER)
+@BindUsing(IntRangeBinder::class)
+annotation class IntRange(
+  val from: Int,
+  val to: Int,
+  val fromInclusive: Boolean = true,
+  val toInclusive: Boolean = true,
+)
+
+@Retention(AnnotationRetention.RUNTIME)
+@Target(AnnotationTarget.PROPERTY)
+@BindUsing(LongRangeBinder::class)
+annotation class LongRange(
+  val from: Long,
+  val to: Long,
+  val fromInclusive: Boolean = true,
+  val toInclusive: Boolean = true
+)
+
+@Retention(AnnotationRetention.RUNTIME)
+@Target(AnnotationTarget.PROPERTY)
+@BindUsing(FloatRangeBinder::class)
+annotation class FloatRange(
+  val from: Float,
+  val to: Float,
+  val fromInclusive: Boolean = true,
+  val toInclusive: Boolean = true
+)
+
+@Retention(AnnotationRetention.RUNTIME)
+@Target(AnnotationTarget.PROPERTY)
+@BindUsing(DoubleRangeBinder::class)
+annotation class DoubleRange(
+  val from: Double,
+  val to: Double,
+  val fromInclusive: Boolean = true,
+  val toInclusive: Boolean = true
+)
+
+@Retention(AnnotationRetention.RUNTIME)
+@Target(AnnotationTarget.PROPERTY)
+@BindUsing(IsCollectionNotEmptyBinder::class)
+annotation class IsNotEmpty
+
+@Retention(AnnotationRetention.RUNTIME)
+@Target(AnnotationTarget.PROPERTY)
+@BindUsing(SizeBinder::class)
+annotation class Size(
+  val min: Int = 0,
+  val max: Int = Int.MAX_VALUE
+)
+
+@Retention(AnnotationRetention.RUNTIME)
+@Target(AnnotationTarget.PROPERTY)
+@BindUsing(RegexBinder::class)
+annotation class RegularExpression(
+  val regex: String
+)

package/android/src/main/java/expo/modules/kotlin/types/JSTypeConverter.kt

@@ -0,0 +1,35 @@
+package expo.modules.kotlin.types
+
+import android.os.Bundle
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import expo.modules.kotlin.records.Record
+
+object JSTypeConverter {
+  interface ContainerProvider {
+    fun createMap(): WritableMap
+    fun createArray(): WritableArray
+  }
+
+  internal object DefaultContainerProvider : ContainerProvider {
+    override fun createMap(): WritableMap = Arguments.createMap()
+    override fun createArray(): WritableArray = Arguments.createArray()
+  }
+
+  fun convertToJSValue(value: Any?, containerProvider: ContainerProvider = DefaultContainerProvider): Any? {
+    return when (value) {
+      null, is Unit -> null
+      is Bundle -> value.toJSValue(containerProvider)
+      is Iterable<*> -> value.toJSValue(containerProvider)
+      is Array<*> -> value.toJSValue(containerProvider)
+      is IntArray -> value.toJSValue(containerProvider)
+      is FloatArray -> value.toJSValue(containerProvider)
+      is DoubleArray -> value.toJSValue(containerProvider)
+      is Map<*, *> -> value.toJSValue(containerProvider)
+      is Enum<*> -> value.toJSValue()
+      is Record -> value.toJSValue(containerProvider)
+      else -> value
+    }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/types/JSTypeConverterHelper.kt

@@ -0,0 +1,148 @@
+package expo.modules.kotlin.types
+
+import android.os.Bundle
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+import kotlin.reflect.KProperty1
+import kotlin.reflect.full.declaredMemberProperties
+import kotlin.reflect.full.findAnnotation
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.full.primaryConstructor
+import kotlin.reflect.jvm.isAccessible
+
+fun Record.toJSValue(containerProvider: JSTypeConverter.ContainerProvider): WritableMap {
+  val result = containerProvider.createMap()
+
+  javaClass
+    .kotlin
+    .memberProperties.map { property ->
+      val fieldInformation = property.findAnnotation<Field>() ?: return@map
+      val jsKey = fieldInformation.key.takeUnless { it == "" } ?: property.name
+
+      property.isAccessible = true
+
+      val value = property.get(this)
+      val convertedValue = JSTypeConverter.convertToJSValue(value, containerProvider)
+      result.putGeneric(jsKey, convertedValue)
+    }
+
+  return result
+}
+
+fun Bundle.toJSValue(containerProvider: JSTypeConverter.ContainerProvider): WritableMap {
+  val result = containerProvider.createMap()
+
+  for (key in keySet()) {
+    val value = get(key)
+    val convertedValue = JSTypeConverter.convertToJSValue(value, containerProvider)
+    result.putGeneric(key, convertedValue)
+  }
+
+  return result
+}
+
+fun <K, V> Map<K, V>.toJSValue(containerProvider: JSTypeConverter.ContainerProvider): WritableMap {
+  val result = containerProvider.createMap()
+
+  for ((key, value) in entries) {
+    val convertedValue = JSTypeConverter.convertToJSValue(value, containerProvider)
+    result.putGeneric(key.toString(), convertedValue)
+  }
+
+  return result
+}
+
+fun <T> Iterable<T>.toJSValue(containerProvider: JSTypeConverter.ContainerProvider): WritableArray {
+  val result = containerProvider.createArray()
+
+  for (value in this) {
+    val convertedValue = JSTypeConverter.convertToJSValue(value, containerProvider)
+    result.putGeneric(convertedValue)
+  }
+
+  return result
+}
+
+fun <T> Array<T>.toJSValue(containerProvider: JSTypeConverter.ContainerProvider): WritableArray {
+  val result = containerProvider.createArray()
+
+  for (value in this) {
+    val convertedValue = JSTypeConverter.convertToJSValue(value, containerProvider)
+    result.putGeneric(convertedValue)
+  }
+
+  return result
+}
+
+fun IntArray.toJSValue(containerProvider: JSTypeConverter.ContainerProvider): WritableArray {
+  return containerProvider.createArray().also {
+    for (value in this) {
+      it.pushInt(value)
+    }
+  }
+}
+
+fun FloatArray.toJSValue(containerProvider: JSTypeConverter.ContainerProvider): WritableArray {
+  return containerProvider.createArray().also {
+    for (value in this) {
+      it.pushDouble(value.toDouble())
+    }
+  }
+}
+
+fun DoubleArray.toJSValue(containerProvider: JSTypeConverter.ContainerProvider): WritableArray {
+  return containerProvider.createArray().also {
+    for (value in this) {
+      it.pushDouble(value)
+    }
+  }
+}
+
+fun Enum<*>.toJSValue(): Any? {
+  val primaryConstructor = requireNotNull(this::class.primaryConstructor) {
+    "Cannot convert enum without the primary constructor to js value"
+  }
+
+  if (primaryConstructor.parameters.isEmpty()) {
+    return this.name
+  } else if (primaryConstructor.parameters.size == 1) {
+    val parameterName = primaryConstructor.parameters.first().name!!
+    @Suppress("UNCHECKED_CAST")
+    val parameterProperty = this::class.declaredMemberProperties
+      .find { it.name == parameterName } as KProperty1<Enum<*>, *>
+
+    return parameterProperty.get(this)
+  }
+
+  throw IllegalStateException("Enum '$javaClass' cannot be used as return type (incompatible with JS)")
+}
+
+internal fun WritableMap.putGeneric(key: String, value: Any?) {
+  when (value) {
+    null, is Unit -> putNull(key)
+    is ReadableArray -> putArray(key, value)
+    is ReadableMap -> putMap(key, value)
+    is String -> putString(key, value)
+    is Int -> putInt(key, value)
+    is Number -> putDouble(key, value.toDouble())
+    is Boolean -> putBoolean(key, value)
+    else -> throw IllegalArgumentException("Could not put '${value.javaClass}' to WritableMap")
+  }
+}
+
+internal fun WritableArray.putGeneric(value: Any?) {
+  when (value) {
+    null, is Unit -> pushNull()
+    is ReadableArray -> pushArray(value)
+    is ReadableMap -> pushMap(value)
+    is String -> pushString(value)
+    is Int -> pushInt(value)
+    is Number -> pushDouble(value.toDouble())
+    is Boolean -> pushBoolean(value)
+    else -> throw IllegalArgumentException("Could not put '${value.javaClass}' to WritableArray")
+  }
+}

package/android/src/main/java/expo/modules/kotlin/types/TypeConverterProvider.kt

@@ -35,6 +35,7 @@ fun convert(value: Dynamic, type: KType): Any? {
 
 object TypeConverterProviderImpl : TypeConverterProvider {
   private val cachedConverters = createCashedConverters(false) + createCashedConverters(true)
+  private val cachedRecordConverters = mutableMapOf<KClass<*>, TypeConverter<*>>()
 
   override fun obtainTypeConverter(type: KType): TypeConverter<*> {
     cachedConverters[type]?.let {
@@ -68,8 +69,15 @@ object TypeConverterProviderImpl : TypeConverterProvider {
       return EnumTypeConverter(kClass as KClass<Enum<*>>, type.isMarkedNullable)
     }
 
+    val cachedConverter = cachedRecordConverters[kClass]
+    if (cachedConverter != null) {
+      return cachedConverter
+    }
+
     if (kClass.isSubclassOf(Record::class)) {
-      return RecordTypeConverter<Record>(this, type)
+      val converter = RecordTypeConverter<Record>(this, type)
+      cachedRecordConverters[kClass] = converter
+      return converter
     }
 
     throw MissingTypeConverter(type)