feat: Multi provider impl

kotlin-sdk/build.gradle.kts

@@ -55,6 +55,7 @@ kotlin {
         commonMain.dependencies {
             implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
             implementation("org.jetbrains.kotlinx:kotlinx-collections-immutable:0.4.0")
+            implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0")
         }
         commonTest.dependencies {
             implementation("org.jetbrains.kotlin:kotlin-test:2.1.21")

kotlin-sdk/src/commonMain/kotlin/dev/openfeature/kotlin/sdk/multiprovider/FirstMatchStrategy.kt

@@ -0,0 +1,57 @@
+package dev.openfeature.kotlin.sdk.multiprovider
+
+import dev.openfeature.kotlin.sdk.EvaluationContext
+import dev.openfeature.kotlin.sdk.FeatureProvider
+import dev.openfeature.kotlin.sdk.ProviderEvaluation
+import dev.openfeature.kotlin.sdk.exceptions.ErrorCode
+import dev.openfeature.kotlin.sdk.exceptions.OpenFeatureError
+
+/**
+ * Return the first result returned by a provider. Skip providers that indicate they had no value due to FLAG_NOT_FOUND.
+ * In all other cases, use the value returned by the provider. If any provider returns an error result other than
+ * FLAG_NOT_FOUND, the whole evaluation should error and "bubble up" the individual provider's error in the result.
+ *
+ * As soon as a value is returned by a provider, the rest of the operation should short-circuit and not call the
+ * rest of the providers.
+ */
+class FirstMatchStrategy : Strategy {
+    /**
+     * Evaluates providers in sequence until finding one that has knowledge of the flag.
+     *
+     * @param providers List of providers to evaluate in order
+     * @param key The feature flag key to look up
+     * @param defaultValue Value to return if no provider knows about the flag
+     * @param evaluationContext Optional context for evaluation
+     * @param flagEval The specific evaluation method to call on each provider
+     * @return ProviderEvaluation with the first match or default value
+     */
+    override fun <T> evaluate(
+        providers: List<FeatureProvider>,
+        key: String,
+        defaultValue: T,
+        evaluationContext: EvaluationContext?,
+        flagEval: FlagEval<T>
+    ): ProviderEvaluation<T> {
+        // Iterate through each provider in the provided order
+        for (provider in providers) {
+            try {
+                // Call the flag evaluation method on the current provider
+                val eval = provider.flagEval(key, defaultValue, evaluationContext)
+
+                // If the provider knows about this flag (any result except FLAG_NOT_FOUND),
+                // return this result immediately, even if it's an error
+                if (eval.errorCode != ErrorCode.FLAG_NOT_FOUND) {
+                    return eval
+                }
+                // Continue to next provider if error is FLAG_NOT_FOUND
+            } catch (_: OpenFeatureError.FlagNotFoundError) {
+                // Handle FLAG_NOT_FOUND exception - continue to next provider
+                continue
+            }
+            // We don't catch any other exception, but rather, bubble up the exceptions
+        }
+
+        // No provider knew about the flag, return default value with DEFAULT reason
+        return ProviderEvaluation(defaultValue, errorCode = ErrorCode.FLAG_NOT_FOUND)
+    }
+}

kotlin-sdk/src/commonMain/kotlin/dev/openfeature/kotlin/sdk/multiprovider/FirstSuccessfulStrategy.kt

@@ -0,0 +1,56 @@
+package dev.openfeature.kotlin.sdk.multiprovider
+
+import dev.openfeature.kotlin.sdk.EvaluationContext
+import dev.openfeature.kotlin.sdk.FeatureProvider
+import dev.openfeature.kotlin.sdk.ProviderEvaluation
+import dev.openfeature.kotlin.sdk.exceptions.OpenFeatureError
+
+/**
+ * Similar to "First Match", except that errors from evaluated providers do not halt execution.
+ * Instead, it will return the first successful result from a provider.
+ *
+ * If no provider successfully responds, it will throw an error result.
+ */
+class FirstSuccessfulStrategy : Strategy {
+    /**
+     * Evaluates providers in sequence until finding one that returns a successful result.
+     *
+     * @param providers List of providers to evaluate in order
+     * @param key The feature flag key to evaluate
+     * @param defaultValue Value to use in provider evaluations
+     * @param evaluationContext Optional context for evaluation
+     * @param flagEval The specific evaluation method to call on each provider
+     * @return ProviderEvaluation with the first successful result
+     * @throws OpenFeatureError.GeneralError if no provider returns a successful evaluation
+     */
+    override fun <T> evaluate(
+        providers: List<FeatureProvider>,
+        key: String,
+        defaultValue: T,
+        evaluationContext: EvaluationContext?,
+        flagEval: FlagEval<T>
+    ): ProviderEvaluation<T> {
+        // Iterate through each provider in the provided order
+        for (provider in providers) {
+            try {
+                // Call the flag evaluation method on the current provider
+                val eval = provider.flagEval(key, defaultValue, evaluationContext)
+
+                // If the provider returned a successful result (no error),
+                // return this result immediately
+                if (eval.errorCode == null) {
+                    return eval
+                }
+                // Continue to next provider if this one had an error
+            } catch (_: OpenFeatureError) {
+                // Handle any OpenFeature exceptions - continue to next provider
+                // FirstSuccessful strategy skips errors and continues
+                continue
+            }
+        }
+
+        // No provider returned a successful result, throw an error
+        // This indicates that all providers either failed or had errors
+        throw OpenFeatureError.GeneralError("No provider returned a successful evaluation for the requested flag.")
+    }
+}