Add MultiProvider

Author: jescriba

Sources/OpenFeature/Provider/MultiProvider/FirstMatchStrategy.swift

@@ -0,0 +1,34 @@
+/// FirstMatchStrategy is a strategy that evaluates a feature flag across multiple providers
+/// and returns the first result. Skips providers that indicate they had no value due to flag not found.
+/// If any provider returns an error result other than flag not found, the error is returned.
+final public class FirstMatchStrategy: Strategy {
+
+    public init() {}
+
+    public func evaluate<T>(
+        providers: [FeatureProvider],
+        key: String,
+        defaultValue: T,
+        evaluationContext: EvaluationContext?,
+        flagEvaluation: FlagEvaluation<T>
+    ) throws -> ProviderEvaluation<T> where T: AllowedFlagValueType {
+        for provider in providers {
+            do {
+                let eval = try flagEvaluation(provider)(key, defaultValue, evaluationContext)
+                if eval.errorCode != ErrorCode.flagNotFound {
+                    return eval
+                }
+            } catch OpenFeatureError.flagNotFoundError {
+                continue
+            } catch {
+                throw error
+            }
+        }
+
+        return ProviderEvaluation(
+            value: defaultValue,
+            reason: Reason.defaultReason.rawValue,
+            errorCode: ErrorCode.flagNotFound
+        )
+    }
+}

Sources/OpenFeature/Provider/MultiProvider/FirstSuccessfulStrategy.swift

@@ -0,0 +1,26 @@
+/// FirstSuccessfulStrategy is a strategy that evaluates a feature flag across multiple providers
+/// and returns the first result. Similar to `FirstMatchStrategy` but does not bubble up individual provider errors.
+/// If no provider successfully responds, it will throw an error.
+final public class FirstSuccessfulStrategy: Strategy {
+    public func evaluate<T>(
+        providers: [FeatureProvider],
+        key: String,
+        defaultValue: T,
+        evaluationContext: EvaluationContext?,
+        flagEvaluation: FlagEvaluation<T>
+    ) throws -> ProviderEvaluation<T> where T: AllowedFlagValueType {
+        for provider in providers {
+            do {
+                let eval = try flagEvaluation(provider)(key, defaultValue, evaluationContext)
+                if eval.errorCode == nil {
+                    return eval
+                }
+            } catch {
+                continue
+            }
+        }
+
+        throw OpenFeatureError.generalError(
+            message: "No provider returned a successful evaluation for the requested flag.")
+    }
+}

Sources/OpenFeature/Provider/MultiProvider/MultiProvider.swift

@@ -0,0 +1,108 @@
+import Combine
+import Foundation
+
+/// A provider that combines multiple providers into a single provider.
+public class MultiProvider: FeatureProvider {
+
+    public var hooks: [any Hook] {
+        []
+    }
+
+    public static let name = "MultiProvider"
+    public var metadata: ProviderMetadata = MultiProvider.MultiProviderMetadata()
+
+    private let providers: [FeatureProvider]
+    private let strategy: Strategy
+
+    /// Initialize a MultiProvider with a list of providers and a strategy.
+    /// - Parameters:
+    ///   - providers: A list of providers to evaluate.
+    ///   - strategy: A strategy to evaluate the providers. Defaults to FirstMatchStrategy.
+    public init(
+        providers: [FeatureProvider],
+        strategy: Strategy = FirstMatchStrategy()
+    ) {
+        self.providers = providers
+        self.strategy = strategy
+    }
+
+    public func initialize(initialContext: EvaluationContext?) async throws {
+        try await withThrowingTaskGroup(of: Void.self) { group in
+            for provider in providers {
+                group.addTask {
+                    try await provider.initialize(initialContext: initialContext)
+                }
+            }
+            try await group.waitForAll()
+        }
+    }
+
+    public func onContextSet(oldContext: EvaluationContext?, newContext: EvaluationContext) async throws {
+        try await withThrowingTaskGroup(of: Void.self) { group in
+            for provider in providers {
+                group.addTask {
+                    try await provider.onContextSet(oldContext: oldContext, newContext: newContext)
+                }
+            }
+            try await group.waitForAll()
+        }
+    }
+
+    public func getBooleanEvaluation(key: String, defaultValue: Bool, context: EvaluationContext?) throws
+        -> ProviderEvaluation<Bool>
+    {
+        return try strategy.evaluate(
+            providers: providers, key: key, defaultValue: defaultValue, evaluationContext: context,
+            flagEvaluation: { provider in
+                return provider.getBooleanEvaluation(key:defaultValue:context:)
+            })
+    }
+
+    public func getStringEvaluation(key: String, defaultValue: String, context: EvaluationContext?) throws
+        -> ProviderEvaluation<String>
+    {
+        return try strategy.evaluate(
+            providers: providers, key: key, defaultValue: defaultValue, evaluationContext: context,
+            flagEvaluation: { provider in
+                return provider.getStringEvaluation(key:defaultValue:context:)
+            })
+    }
+
+    public func getIntegerEvaluation(key: String, defaultValue: Int64, context: EvaluationContext?) throws
+        -> ProviderEvaluation<Int64>
+    {
+        return try strategy.evaluate(
+            providers: providers, key: key, defaultValue: defaultValue, evaluationContext: context,
+            flagEvaluation: { provider in
+                return provider.getIntegerEvaluation(key:defaultValue:context:)
+            })
+    }
+
+    public func getDoubleEvaluation(key: String, defaultValue: Double, context: EvaluationContext?) throws
+        -> ProviderEvaluation<Double>
+    {
+        return try strategy.evaluate(
+            providers: providers, key: key, defaultValue: defaultValue, evaluationContext: context,
+            flagEvaluation: { provider in
+                return provider.getDoubleEvaluation(key:defaultValue:context:)
+            })
+    }
+
+    public func getObjectEvaluation(key: String, defaultValue: Value, context: EvaluationContext?) throws
+        -> ProviderEvaluation<Value>
+    {
+        return try strategy.evaluate(
+            providers: providers, key: key, defaultValue: defaultValue, evaluationContext: context,
+            flagEvaluation: { provider in
+                return provider.getObjectEvaluation(key:defaultValue:context:)
+            })
+    }
+
+    public func observe() -> AnyPublisher<ProviderEvent?, Never> {
+        return Publishers.MergeMany(providers.map { $0.observe() }).eraseToAnyPublisher()
+    }
+
+    public struct MultiProviderMetadata: ProviderMetadata {
+        public var name: String? = MultiProvider.name
+    }
+}

Sources/OpenFeature/Provider/MultiProvider/Strategy.swift

@@ -0,0 +1,19 @@
+/// FlagEvaluation is a function that evaluates a feature flag and returns a ProviderEvaluation.
+/// It is used to evaluate a feature flag across multiple providers using the strategy's logic.
+public typealias FlagEvaluation<T> = (FeatureProvider) -> (
+    _ key: String, _ defaultValue: T, _ evaluationContext: EvaluationContext?
+) throws -> ProviderEvaluation<T> where T: AllowedFlagValueType
+
+/// Strategy interface defines how multiple feature providers should be evaluated
+/// to determine the final result for a feature flag evaluation.
+/// Different strategies can implement different logic for combining or selecting
+/// results from multiple providers.
+public protocol Strategy {
+    func evaluate<T>(
+        providers: [FeatureProvider],
+        key: String,
+        defaultValue: T,
+        evaluationContext: EvaluationContext?,
+        flagEvaluation: FlagEvaluation<T>
+    ) throws -> ProviderEvaluation<T> where T: AllowedFlagValueType
+}