unify types

ConfidenceDemoApp/src/main/java/com/example/confidencedemoapp/MainVm.kt

@@ -31,7 +31,7 @@ class MainVm(app: Application) : AndroidViewModel(app) {
     }
 
     private var client: Client
-    private var ctx: EvaluationContext = ImmutableContext(targetingKey = UUID.randomUUID().toString())
+    private var ctx: EvaluationContext = ImmutableContext(targetingKey = "a98a4291-53b0-49d9-bae8-73d3f5da2070")
     private val _message: MutableLiveData<String> = MutableLiveData("initial")
     private val _color: MutableLiveData<Color> = MutableLiveData(Color.Gray)
     val message: LiveData<String> = _message
@@ -72,12 +72,6 @@ class MainVm(app: Application) : AndroidViewModel(app) {
             )
             OpenFeatureAPI.setProviderAndWait(provider, Dispatchers.IO)
 
-            launch {
-                delay(5000)
-                val ctx: EvaluationContext = ImmutableContext(targetingKey = "X")
-                OpenFeatureAPI.setEvaluationContext(ctx)
-            }
-
             eventSender.send("eventDefinitions/navigate")
 
             Log.d(TAG, "client secret is $clientSecret")

Provider/src/main/java/com/spotify/confidence/Confidence.kt

@@ -32,7 +32,13 @@ class Confidence private constructor(
     }
 
     internal suspend fun resolveFlags(flags: List<String>): Result<FlagResolution> {
-        return flagResolver.resolve(flags, getContext())
+        val context = getContext().toMutableMap()
+        val openFeatureContext = context["open_feature"]?.let { it as ConfidenceValue.Struct }
+        openFeatureContext?.let {
+            context += it.value
+        }
+        context.remove("open_feature")
+        return flagResolver.resolve(flags, context)
     }
 
     override fun putContext(key: String, value: ConfidenceValue) {

Provider/src/main/java/com/spotify/confidence/ConfidenceContext.kt

@@ -17,15 +17,10 @@ interface ContextApi : ConfidenceContextProvider {
     fun removeContext(key: String)
 }
 
-interface ConfidenceContext {
-    val name: String
-    val value: ConfidenceValue
-}
-
 class CommonContext : ConfidenceContextProvider {
     override fun getContext(): Map<String, ConfidenceValue> = mapOf()
 }
 
 fun EvaluationContext.toConfidenceContext(): ConfidenceValue.Struct {
-    TODO()
+    return ConfidenceValue.Struct(mapOf("targeting_key" to ConfidenceValue.String(this.getTargetingKey())))
 }

Provider/src/main/java/com/spotify/confidence/ConfidenceFlagEvaluation.kt

@@ -26,7 +26,7 @@ internal fun <T> FlagResolution.getEvaluation(
 
     // handle flag found
     val flagValue = resolvedFlag.value
-    val resolvedValue: ConfidenceValue = findValueFromValuePath(flagValue, parsedKey.valuePath)
+    val resolvedValue: ConfidenceValue = findValueFromValuePath(ConfidenceValue.Struct(flagValue), parsedKey.valuePath)
         ?: throw ParseError(
             "Unable to parse flag value: ${parsedKey.valuePath.joinToString(separator = "/")}"
         )
@@ -63,6 +63,7 @@ private fun <T> getTyped(v: ConfidenceValue): T? {
         is ConfidenceValue.Int -> v.value as T
         is ConfidenceValue.String -> v.value as T
         is ConfidenceValue.Struct -> v as T
+        is ConfidenceValue.Null -> v as T
     }
 }
 

Provider/src/main/java/com/spotify/confidence/ConfidenceValue.kt

@@ -6,4 +6,6 @@ sealed class ConfidenceValue {
     data class Boolean(val value: kotlin.Boolean) : ConfidenceValue()
     data class Int(val value: kotlin.Int) : ConfidenceValue()
     data class Struct(val value: Map<kotlin.String, ConfidenceValue>) : ConfidenceValue()
+
+    object Null : ConfidenceValue()
 }

Provider/src/main/java/com/spotify/confidence/EventSenderUploader.kt

@@ -1,31 +1,15 @@
 package com.spotify.confidence
 
 import com.spotify.confidence.client.await
-import com.spotify.confidence.client.serializers.StructureSerializer
+import com.spotify.confidence.client.serializers.ConfidenceValueSerializer
 import com.spotify.confidence.client.serializers.UUIDSerializer
 import dev.openfeature.sdk.DateSerializer
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.Contextual
-import kotlinx.serialization.KSerializer
 import kotlinx.serialization.Serializable
-import kotlinx.serialization.descriptors.PrimitiveKind
-import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
 import kotlinx.serialization.encodeToString
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
-import kotlinx.serialization.encoding.encodeStructure
 import kotlinx.serialization.json.Json
-import kotlinx.serialization.json.JsonDecoder
-import kotlinx.serialization.json.JsonPrimitive
-import kotlinx.serialization.json.boolean
-import kotlinx.serialization.json.booleanOrNull
-import kotlinx.serialization.json.double
-import kotlinx.serialization.json.doubleOrNull
-import kotlinx.serialization.json.int
-import kotlinx.serialization.json.intOrNull
-import kotlinx.serialization.json.jsonObject
-import kotlinx.serialization.json.jsonPrimitive
 import kotlinx.serialization.modules.SerializersModule
 import kotlinx.serialization.modules.contextual
 import okhttp3.Headers
@@ -38,24 +22,6 @@ internal interface EventSenderUploader {
     suspend fun upload(events: EventBatch): Boolean
 }
 
-/**
- * {
- *   "clientSecret": "my-client-secret",
- *   "events": [
- *     {
- *       "eventDefinition": "eventDefinitions/navigate",
- *       "eventTime": "2018-01-01T00:00:00Z",
- *       "payload": {
- *         "user_id": "1234",
- *         "current": "home-page",
- *         "target": "profile-page"
- *       }
- *     }
- *   ],
- *   "sendTime": "2018-01-01T00:00:00Z"
- * }
- */
-
 @Serializable
 internal data class EventBatch(
     val clientSecret: String,
@@ -115,58 +81,6 @@ internal val eventsJson = Json {
     serializersModule = SerializersModule {
         contextual(UUIDSerializer)
         contextual(DateSerializer)
-        contextual(EventValueSerializer)
-    }
-}
-
-object EventValueSerializer : KSerializer<ConfidenceValue> {
-    override val descriptor = PrimitiveSerialDescriptor("EventValue", PrimitiveKind.STRING)
-
-    override fun deserialize(decoder: Decoder): ConfidenceValue {
-        require(decoder is JsonDecoder)
-        when (val element = decoder.decodeJsonElement()) {
-            is JsonPrimitive -> {
-                val jsonPrimitive = element.jsonPrimitive
-                return when {
-                    jsonPrimitive.isString -> ConfidenceValue.String(jsonPrimitive.content)
-                    jsonPrimitive.booleanOrNull != null -> ConfidenceValue.Boolean(jsonPrimitive.boolean)
-                    jsonPrimitive.intOrNull != null -> ConfidenceValue.Int(jsonPrimitive.int)
-                    jsonPrimitive.doubleOrNull != null -> ConfidenceValue.Double(jsonPrimitive.double)
-                    else -> error("unknown type")
-                }
-            }
-            else -> {
-                val jsonObject = element
-                    .jsonObject
-                val map = jsonObject
-                    .keys.associateWith {
-                        Json.decodeFromJsonElement(
-                            this,
-                            jsonObject.getValue(it)
-                        )
-                    }
-                return ConfidenceValue.Struct(map)
-            }
-        }
-    }
-
-    override fun serialize(encoder: Encoder, value: ConfidenceValue) {
-        when (value) {
-            is ConfidenceValue.Int -> encoder.encodeInt(value.value)
-            is ConfidenceValue.Boolean -> encoder.encodeBoolean(value.value)
-            is ConfidenceValue.Double -> encoder.encodeDouble(value.value)
-            is ConfidenceValue.String -> encoder.encodeString(value.value)
-            is ConfidenceValue.Struct -> encoder.encodeStructure(StructureSerializer.descriptor) {
-                for ((key, mapValue) in value.value) {
-                    encodeStringElement(StructureSerializer.descriptor, 0, key)
-                    encodeSerializableElement(
-                        StructureSerializer.descriptor,
-                        1,
-                        this@EventValueSerializer,
-                        mapValue
-                    )
-                }
-            }
-        }
+        contextual(ConfidenceValueSerializer)
     }
 }

Provider/src/main/java/com/spotify/confidence/FlagEvaluator.kt

@@ -15,7 +15,7 @@ data class Evaluation<T>(
 @Serializable
 data class FlagResolution(
     val context: Map<String, @Contextual ConfidenceValue>,
-    val flags: List<@Contextual ResolvedFlag>,
+    val flags: List<ResolvedFlag>,
     val resolveToken: String
 )
 

Provider/src/main/java/com/spotify/confidence/RemoteFlagResolver.kt

@@ -5,8 +5,8 @@ import com.spotify.confidence.client.ResolveResponse
 import com.spotify.confidence.client.Sdk
 import com.spotify.confidence.client.SdkMetadata
 import com.spotify.confidence.client.await
+import com.spotify.confidence.client.serializers.ConfidenceValueSerializer
 import com.spotify.confidence.client.serializers.FlagsSerializer
-import com.spotify.confidence.client.serializers.StructureSerializer
 import com.spotify.confidence.client.serializers.UUIDSerializer
 import dev.openfeature.sdk.DateSerializer
 import kotlinx.coroutines.CoroutineDispatcher
@@ -79,7 +79,7 @@ private val json = Json {
     serializersModule = SerializersModule {
         contextual(UUIDSerializer)
         contextual(DateSerializer)
-        contextual(StructureSerializer)
+        contextual(ConfidenceValueSerializer)
     }
 }
 

Provider/src/main/java/com/spotify/confidence/cache/FileDiskStorage.kt

@@ -3,6 +3,7 @@ package com.spotify.confidence.cache
 import android.content.Context
 import com.spotify.confidence.FlagResolution
 import com.spotify.confidence.apply.ApplyInstance
+import com.spotify.confidence.client.serializers.ConfidenceValueSerializer
 import com.spotify.confidence.client.serializers.UUIDSerializer
 import dev.openfeature.sdk.DateSerializer
 import kotlinx.serialization.encodeToString
@@ -20,7 +21,7 @@ internal class FileDiskStorage private constructor(
 ) : DiskStorage {
 
     override fun store(flagResolution: FlagResolution) {
-        write(Json.encodeToString(flagResolution))
+        write(json.encodeToString(flagResolution))
     }
 
     override fun clear() {
@@ -51,7 +52,7 @@ internal class FileDiskStorage private constructor(
         return if (fileText.isEmpty()) {
             null
         } else {
-            Json.decodeFromString(fileText)
+            json.decodeFromString(fileText)
         }
     }
 
@@ -76,5 +77,6 @@ internal val json = Json {
     serializersModule = SerializersModule {
         contextual(UUIDSerializer)
         contextual(DateSerializer)
+        contextual(ConfidenceValueSerializer)
     }
 }

Provider/src/main/java/com/spotify/confidence/client/Types.kt

@@ -40,10 +40,11 @@ data class Flags(
     val list: List<ResolvedFlag>
 )
 
+@Serializable
 data class ResolvedFlag(
     val flag: String,
     val variant: String,
-    val value: ConfidenceValue.Struct = ConfidenceValue.Struct(mapOf()),
+    val value: Map<String, @Contextual ConfidenceValue> = mapOf(),
     val reason: ResolveReason
 )
 

Provider/src/main/java/com/spotify/confidence/client/network/ApplyFlagsInteractor.kt

@@ -3,7 +3,7 @@ package com.spotify.confidence.client.network
 import com.spotify.confidence.client.AppliedFlag
 import com.spotify.confidence.client.Sdk
 import com.spotify.confidence.client.await
-import com.spotify.confidence.client.serializers.StructureSerializer
+import com.spotify.confidence.client.serializers.ConfidenceValueSerializer
 import com.spotify.confidence.client.serializers.UUIDSerializer
 import dev.openfeature.sdk.DateSerializer
 import kotlinx.coroutines.CoroutineDispatcher
@@ -63,6 +63,6 @@ private val json = Json {
     serializersModule = SerializersModule {
         contextual(UUIDSerializer)
         contextual(DateSerializer)
-        contextual(StructureSerializer)
+        contextual(ConfidenceValueSerializer)
     }
 }

Provider/src/main/java/com/spotify/confidence/client/network/ResolveFlagsInteractor.kt

@@ -2,7 +2,7 @@ package com.spotify.confidence.client.network
 
 import com.spotify.confidence.client.ResolveFlagsRequest
 import com.spotify.confidence.client.await
-import com.spotify.confidence.client.serializers.StructureSerializer
+import com.spotify.confidence.client.serializers.ConfidenceValueSerializer
 import com.spotify.confidence.client.serializers.UUIDSerializer
 import dev.openfeature.sdk.DateSerializer
 import kotlinx.coroutines.CoroutineDispatcher
@@ -50,6 +50,6 @@ private val json = Json {
     serializersModule = SerializersModule {
         contextual(UUIDSerializer)
         contextual(DateSerializer)
-        contextual(StructureSerializer)
+        contextual(ConfidenceValueSerializer)
     }
 }