Release 1.2.1

Merge pull request #475 from cph-cachet/develop

Author: Whathecode

build.gradle

@@ -3,8 +3,8 @@ buildscript {
     ext {
         // Version used for submodule artifacts.
         // Snapshot publishing changes (or adds) the suffix after '-' with 'SNAPSHOT' prior to publishing.
-        globalVersion = '1.2.0'
-        clientsVersion = '1.2.0-alpha.1' // The clients subsystem is still expected to change drastically.
+        globalVersion = '1.2.1'
+        clientsVersion = '1.2.1-alpha.1' // The clients subsystem is still expected to change drastically.
 
         versions = [
             // Kotlin multiplatform versions.

carp.common/src/commonMain/kotlin/dk/cachet/carp/common/infrastructure/reflect/AccessInternals.kt

@@ -3,6 +3,9 @@ package dk.cachet.carp.common.infrastructure.reflect
 
 /**
  * Provide access to runtime internals which cannot be accessed at compile time.
+ *
+ * Warning: on JavaScript targets, this only works for non-minified sources. Variables which aren't exported are mangled
+ * completely. So this should not be used in production code! It may still be useful for test automation.
  */
 internal expect object AccessInternals
 {

carp.common/src/commonMain/kotlin/dk/cachet/carp/common/infrastructure/serialization/UnknownPolymorphicSerializer.kt

@@ -1,6 +1,5 @@
 package dk.cachet.carp.common.infrastructure.serialization
 
-import dk.cachet.carp.common.infrastructure.reflect.AccessInternals
 import dk.cachet.carp.common.infrastructure.reflect.reflectIfAvailable
 import kotlinx.serialization.*
 import kotlinx.serialization.descriptors.*
@@ -58,18 +57,30 @@ abstract class UnknownPolymorphicSerializer<P : Any, W : P>(
         {
             throw unsupportedException
         }
-        getClassDiscriminator( encoder.json ) // Throws error in case array polymorphism is used.
+        val classDiscriminator = getClassDiscriminator( encoder.json ) // Throws error in case of array polymorphism.
 
         // Get the unknown JSON object.
         check( value is UnknownPolymorphicWrapper )
         val unknown = Json.parseToJsonElement( value.jsonSource ) as JsonObject
+        val unknownTypeFields = unknown.filter { it.key != classDiscriminator }
+
+        // Create a serial descriptor which contains all elements of the unknown JSON object, except type discriminator.
+        // If the encoder is in polymorphic writing mode, a class discriminator field will automatically be added using
+        // the serial name of the descriptor.
+        val unknownType = checkNotNull( unknown[ classDiscriminator ]?.jsonPrimitive?.content )
+        val jsonSerializer = JsonElement.serializer()
+        val overrideDescriptor = buildClassSerialDescriptor( unknownType )
+        {
+            unknownTypeFields.keys.forEach { element( it, jsonSerializer.descriptor ) }
+        }
 
-        // HACK: Modify kotlinx.serialization internals to ensure the encoder is not in polymorphic mode.
-        //  Otherwise, `encoder.encodeJsonElement` encodes type information, but this is already represented in the wrapped unknown object.
-        AccessInternals.setField( encoder, "polymorphicDiscriminator", null )
-
-        // Output the originally wrapped JSON.
-        encoder.encodeJsonElement( unknown )
+        // Write the JSON object.
+        encoder.encodeStructure( overrideDescriptor )
+        {
+            var id = 0
+            for ( field in unknownTypeFields.values )
+                encodeSerializableElement( overrideDescriptor, id++, JsonElement.serializer(), field )
+        }
     }
 
     override fun deserialize( decoder: Decoder ): P
@@ -85,7 +96,8 @@ abstract class UnknownPolymorphicSerializer<P : Any, W : P>(
         // Get raw JSON for the unknown type.
         val jsonElement = decoder.decodeJsonElement()
         val jsonSource = jsonElement.toString()
-        val className = jsonElement.jsonObject[ classDiscriminator ]!!.jsonPrimitive.content
+        val className = requireNotNull( jsonElement.jsonObject[ classDiscriminator ]?.jsonPrimitive?.content )
+            { "Can't deserialize type which was serialized non-polymorphically." }
 
         return createWrapper( className, jsonSource, decoder.json )
     }

carp.test/src/commonMain/kotlin/dk/cachet/carp/test/serialization/ConcreteTypesSerializationTest.kt

@@ -49,10 +49,13 @@ abstract class ConcreteTypesSerializationTest(
         for ( toSerialize in instancesToSerialize )
         {
             // Get serializer.
+            // Polymorphic serializer is used to ensure type information is always embedded,
+            // which some deserializers may depend upon.
             val type = toSerialize::class
+            val registration = polymorphicSerializers[ type ]
+            assertNotNull( registration, "No serializer registered for type '$type'" )
             @Suppress( "UNCHECKED_CAST" )
-            val serializer = polymorphicSerializers[ type ] as? KSerializer<Any>
-            assertNotNull( serializer, "No serializer registered for type '$type'" )
+            val serializer = PolymorphicSerializer( registration.baseKlass ) as KSerializer<Any>
 
             // Verify whether serializing and deserializing the instance results in the same object.
             val serialized = json.encodeToString( serializer, toSerialize )
@@ -67,12 +70,12 @@ abstract class ConcreteTypesSerializationTest(
  * Get a map which holds the [KSerializer] for each [KClass] registered for polymorphic serialization in [serialModule].
  */
 @ExperimentalSerializationApi
-fun getPolymorphicSerializers( serialModule: SerializersModule ): Map<KClass<*>, KSerializer<*>>
+fun getPolymorphicSerializers( serialModule: SerializersModule ): Map<KClass<*>, PolymorphicRegistration>
 {
     val collector =
         object : SerializersModuleCollector
         {
-            val serializers: MutableMap<KClass<*>, KSerializer<*>> = mutableMapOf()
+            val serializers: MutableMap<KClass<*>, PolymorphicRegistration> = mutableMapOf()
 
             override fun <T : Any> contextual(
                 kClass: KClass<T>,
@@ -85,7 +88,7 @@ fun getPolymorphicSerializers( serialModule: SerializersModule ): Map<KClass<*>,
                 actualSerializer: KSerializer<Sub>
             )
             {
-                serializers[ actualClass ] = actualSerializer
+                serializers[ actualClass ] = PolymorphicRegistration( baseClass, actualSerializer )
             }
 
             @Suppress( "REDUNDANT_PROJECTION", "KotlinRedundantDiagnosticSuppress" ) // Exact override needed.
@@ -109,3 +112,6 @@ fun getPolymorphicSerializers( serialModule: SerializersModule ): Map<KClass<*>,
     serialModule.dumpTo( collector )
     return collector.serializers
 }
+
+
+data class PolymorphicRegistration( val baseKlass: KClass<*>, val serializer: KSerializer<*> )

typescript-declarations/carp-common/package.json

@@ -2,5 +2,5 @@
   "name": "@cachet/carp-common",
   "type": "module",
   "main": "index.js",
-  "version":  "1.1.2"
+  "version":  "1.2.1"
 }

typescript-declarations/carp-data-core/package.json

@@ -2,5 +2,5 @@
   "name": "@cachet/carp-data-core",
   "type": "module",
   "main": "index.js",
-  "version":  "1.1.2"
+  "version":  "1.2.1"
 }

typescript-declarations/carp-deployments-core/package.json

@@ -2,5 +2,5 @@
   "name": "@cachet/carp-deployments-core",
   "type": "module",
   "main": "index.js",
-  "version":  "1.1.2"
+  "version":  "1.2.1"
 }

typescript-declarations/carp-kotlin/package.json

@@ -2,5 +2,5 @@
   "name": "@cachet/carp-kotlin",
   "type": "module",
   "main": "index.js",
-  "version":  "1.1.2"
+  "version":  "1.2.1"
 }

typescript-declarations/carp-kotlinx-datetime/package.json

@@ -2,5 +2,5 @@
   "name": "@cachet/carp-kotlinx-datetime",
   "type": "module",
   "main": "index.js",
-  "version":  "1.1.2"
+  "version":  "1.2.1"
 }

typescript-declarations/carp-kotlinx-serialization/index.ts

@@ -7,7 +7,7 @@ import extendJson from "@cachet/kotlinx-serialization-kotlinx-serialization-json
 // Facade with better method names and type conversions for internal types.
 export namespace kotlinx.serialization
 {
-    export function getSerializer( type: any ) { return type.Companion.t16() }
+    export function getSerializer( type: any ) { return type.Companion.m16() }
 }
 export namespace kotlinx.serialization.json
 {