[FME-2963] Prerequisites implementation

Split/Api/DefaultSplitManager.swift

@@ -41,6 +41,7 @@ import Foundation
                 splitView.trafficType = split.trafficTypeName
                 splitView.defaultTreatment = split.defaultTreatment
                 splitView.killed = split.killed
+                splitView.prerequisites = split.prerequisites ?? []
                 splitView.sets = Array(split.sets ?? [])
                 splitView.configs = split.configurations ?? [String: String]()
                 splitView.impressionsDisabled = split.impressionsDisabled ?? false

Split/Api/SplitView.swift

@@ -25,6 +25,7 @@ public class SplitView: NSObject, Codable {
         return changeNumber as NSNumber?
     }
     @objc public var configs: [String: String]?
+    @objc public var prerequisites: [Prerequisite]?
 
     @objc public var impressionsDisabled: Bool = false
 }

Split/Common/Extensions/SplitView+StringConvertible.swift

@@ -31,6 +31,17 @@ extension SplitView {
         } else {
             output+="treatments = nil\n"
         }
+        if let prerequisites = prerequisites {
+            output+="prerequisites = [\n"
+            prerequisites.forEach { prerequisite in
+                output+="""
+                        \(prerequisite.flagName): {\(prerequisite.treatments.joined(separator: ","))}\n
+                        """
+            }
+            output+="]\n"
+        } else {
+            output+="prerequisites = nil\n"
+        }
         if let sets = sets {
             output+="sets = [\(sets.joined(separator: ","))]\n"
         } else {

Split/Common/Utils/SplitHelper.swift

@@ -21,7 +21,7 @@ class SplitHelper {
         split.trafficAllocation = 100
         split.trafficAllocationSeed = 1
         split.seed = 1
-        split.isParsed = true
+        split.isCompletelyParsed = true
         return split
     }
 

Split/Engine/Evaluator.swift

@@ -52,8 +52,11 @@ protocol Evaluator {
 }
 
 class DefaultEvaluator: Evaluator {
-    // Internal for testing purposes
-    var splitter: SplitterProtocol = Splitter.shared
+
+    // For testing purposes
+    internal var splitter: SplitterProtocol = Splitter.shared
+    private var prerequisitesMatcherFactory: ([Prerequisite]) -> MatcherProtocol = { prerequisites in PrerequisitesMatcher(prerequisites) }
+
     private let splitsStorage: SplitsStorage
     private let mySegmentsStorage: MySegmentsStorage
     private let myLargeSegmentsStorage: MySegmentsStorage?
@@ -72,17 +75,29 @@ class DefaultEvaluator: Evaluator {
     func evalTreatment(matchingKey: String, bucketingKey: String?,
                        splitName: String, attributes: [String: Any]?) throws -> EvaluationResult {
 
-        guard let split = splitsStorage.get(name: splitName),
-            split.status != .archived else {
-                Logger.w("The feature flag definition for '\(splitName)' has not been found")
-                return EvaluationResult(treatment: SplitConstants.control, label: ImpressionsConstants.splitNotFound)
+        // 1. Guarantee Split exists & is active
+        guard let split = splitsStorage.get(name: splitName), split.status != .archived else {
+            Logger.w("The feature flag definition for '\(splitName)' has not been found")
+            return EvaluationResult(treatment: SplitConstants.control, label: ImpressionsConstants.splitNotFound)
         }
-
+
+        // 2. Guarantee is not killed
         let changeNumber = split.changeNumber ?? -1
-        let defaultTreatment  = split.defaultTreatment ?? SplitConstants.control
-        if let killed = split.killed, killed {
+        let defaultTreatment = split.defaultTreatment ?? SplitConstants.control
+        guard let killed = split.killed, !killed else {
+            return EvaluationResult(treatment: defaultTreatment, label: ImpressionsConstants.killed, changeNumber: changeNumber,
+                                    configuration: split.configurations?[defaultTreatment], impressionsDisabled: split.isImpressionsDisabled())
+        }
+
+        // 3. Extract necessary info
+        let bucketKey = selectBucketKey(matchingKey: matchingKey, bucketingKey: bucketingKey)
+        let values = EvalValues(matchValue: matchingKey, matchingKey: matchingKey, bucketingKey: bucketKey, attributes: attributes)
+
+        // 4. Evaluate Prerequisites
+        let matcher = prerequisitesMatcherFactory(split.prerequisites ?? [])
+        if !matcher.evaluate(values: values, context: getContext()) {
             return EvaluationResult(treatment: defaultTreatment,
-                                    label: ImpressionsConstants.killed,
+                                    label: ImpressionsConstants.prerequisitesNotMet,
                                     changeNumber: changeNumber,
                                     configuration: split.configurations?[defaultTreatment],
                                     impressionsDisabled: split.isImpressionsDisabled())
@@ -95,8 +110,6 @@ class DefaultEvaluator: Evaluator {
             splitAlgo = algo
         }
 
-        let bucketKey = selectBucketKey(matchingKey: matchingKey, bucketingKey: bucketingKey)
-
         guard let conditions: [Condition] = split.conditions,
             let trafficAllocationSeed = split.trafficAllocationSeed,
             let seed = split.seed else {
@@ -155,11 +168,15 @@ class DefaultEvaluator: Evaluator {
     }
 
     private func selectBucketKey(matchingKey: String, bucketingKey: String?) -> String {
-        if let key = bucketingKey, !key.isEmpty() {
-            return key
-        }
+        if let key = bucketingKey, !key.isEmpty { return key }
         return matchingKey
     }
+
+    #if DEBUG
+    internal func overridePrerequisitesMatcher(_ factory: @escaping ([Prerequisite]) -> MatcherProtocol) {
+        prerequisitesMatcherFactory = factory
+    }
+    #endif
 }
 
 private extension Split {

Split/Impressions/ImpressionsConstants.swift

@@ -16,4 +16,5 @@ struct ImpressionsConstants {
     static let exception: String = "exception"
     static let notReady: String = "not ready"
     static let unsupportedMatcherType: String = "targeting rule type unsupported by sdk"
+    static let prerequisitesNotMet = "prerequisites not met"
 }

Split/Matchers/PrerequisitesMatcher.swift

@@ -0,0 +1,38 @@
+//  Created by Martin Cardozo on 22/05/2025.
+//  Copyright © 2025 Split. All rights reserved.
+
+import Foundation
+
+class PrerequisitesMatcher: BaseMatcher, MatcherProtocol {
+
+    private var prerequisites: [Prerequisite]?
+
+    init(_ prerequisites: [Prerequisite]? = nil) {
+        self.prerequisites = prerequisites
+    }
+
+    // This evaluation passes JUST if -all- prerequisite are met
+    func evaluate(values: EvalValues, context: EvalContext?) -> Bool {
+
+        guard let prerequisites = prerequisites, !prerequisites.isEmpty else { return true }
+
+        for prerequisite in prerequisites {
+            guard !prerequisite.treatments.isEmpty else { return true }
+
+            do {
+                guard let treatment = try context?.evaluator?.evalTreatment(matchingKey: values.matchingKey, bucketingKey: values.bucketingKey, splitName: prerequisite.flagName, attributes: nil).treatment else {
+                    continue
+                }
+
+                if !prerequisite.treatments.contains(treatment) {
+                    return false
+                }
+            } catch {
+                Logger.e("Error evaluating condition in PrerequisitesMatcher: \(error)")
+                return false
+            }
+        }
+
+        return true
+    }
+}

Split/Models/SplitModel/Split.swift

@@ -1,13 +1,11 @@
-//
-//  Split.swift
-//  Split
-//
 //  Created by Brian Sztamfater on 28/9/17.
-//
-//
 
 import Foundation
 
+// The JSON is -partially- parsed at startup to improve SDK ready times (for example "conditions" are left out).
+// After parsing just the strictly necesary stuff, it saves the complete JSON to finish parsing later.
+// Once .sdkReady is fired, it concurrently finishes parsing the rest (on SplitStorage.get())
+
 typealias Split = SplitDTO
 
 class SplitDTO: NSObject, SplitBase, Codable {
@@ -25,10 +23,11 @@ class SplitDTO: NSObject, SplitBase, Codable {
     var configurations: [String: String]?
     var sets: Set<String>?
     var impressionsDisabled: Bool?
+    var prerequisites: [Prerequisite]?
 
     var json: String = ""
 
-    var isParsed = true
+    var isCompletelyParsed = true
 
     init(name: String, trafficType: String, status: Status, sets: Set<String>?, json: String, killed: Bool = false, impressionsDisabled: Bool = false) {
         self.name = name
@@ -37,7 +36,7 @@ class SplitDTO: NSObject, SplitBase, Codable {
         self.sets = sets
         self.json = json
         self.killed = killed
-        self.isParsed = false
+        self.isCompletelyParsed = false
         self.impressionsDisabled = impressionsDisabled
     }
 
@@ -56,5 +55,29 @@ class SplitDTO: NSObject, SplitBase, Codable {
         case configurations
         case sets
         case impressionsDisabled
+        case prerequisites
+    }
+}
+
+@objc public class Prerequisite: NSObject, Codable {
+    @objc public var flagName: String
+    @objc public var treatments: [String]
+
+    enum CodingKeys: String, CodingKey {
+        case flagName = "n"
+        case treatments = "ts"
+    }
+
+    required public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.flagName = try container.decodeIfPresent(String.self, forKey: .flagName) ?? ""
+        self.treatments = try container.decodeIfPresent([String].self, forKey: .treatments) ?? []
+    }
+
+    #if DEBUG
+    init(flagName: String, treatments: [String]) {
+        self.flagName = flagName
+        self.treatments = treatments
     }
+    #endif
 }

Split/Storage/Splits/SplitsStorage.swift

@@ -60,7 +60,7 @@ class DefaultSplitsStorage: SplitsStorage {
         guard let split = inMemorySplits.value(forKey: name.lowercased()) else {
             return nil
         }
-        if !split.isParsed {
+        if !split.isCompletelyParsed {
             if let parsed = try? Json.decodeFrom(json: split.json, to: Split.self) {
                 if isUnsupportedMatcher(split: parsed) {
                     parsed.conditions = [SplitHelper.createDefaultCondition()]
@@ -221,3 +221,5 @@ class BackgroundSyncSplitsStorage: SyncSplitsStorage {
         persistentStorage.clear()
     }
 }
+
+