feat(surveys): support event property filters

Author: adboio

.changeset/thick-squids-punch.md

@@ -0,0 +1,5 @@
+---
+"posthog-ios": minor
+---
+
+support survey event property filters

PostHog/Models/Surveys/PostHogSurveyConditions.swift

@@ -40,8 +40,23 @@ struct PostHogSurveyActionsConditions: Decodable {
     let values: [PostHogEventCondition]
 }
 
+/// Represents a single property filter for event condition matching
+struct PostHogPropertyFilter: Decodable, Equatable {
+    /// The values to compare against
+    let values: [String]
+    /// The comparison operator
+    let matchOperator: PostHogSurveyMatchType
+
+    enum CodingKeys: String, CodingKey {
+        case values
+        case matchOperator = "operator"
+    }
+}
+
 /// Represents a single event condition used in survey targeting
 struct PostHogEventCondition: Decodable, Equatable {
     /// Name of the event (e.g., "content loaded")
     let name: String
+    /// Property filters that must match for this event condition (optional)
+    var propertyFilters: [String: PostHogPropertyFilter]? = nil
 }

PostHog/Models/Surveys/PostHogSurveyEnums.swift

@@ -88,6 +88,8 @@ enum PostHogSurveyMatchType: Decodable, Equatable {
     case isNot
     case iContains
     case notIContains
+    case gt
+    case lt
     case unknown(value: String)
 
     init(from decoder: any Decoder) throws {
@@ -107,6 +109,10 @@ enum PostHogSurveyMatchType: Decodable, Equatable {
             self = .iContains
         case "not_icontains":
             self = .notIContains
+        case "gt":
+            self = .gt
+        case "lt":
+            self = .lt
         default:
             self = .unknown(value: valueString)
         }

PostHog/PostHogSDK.swift

@@ -882,7 +882,7 @@ let maxRetryDelay = 30.0
         }
 
         #if os(iOS)
-            surveysIntegration?.onEvent(event: posthogEvent.event)
+            surveysIntegration?.onEvent(event: posthogEvent.event, properties: posthogEvent.properties)
         #endif
     }
 

PostHog/Surveys/PostHogSurveyIntegration.swift

@@ -32,7 +32,7 @@
         private var allSurveys: [PostHogSurvey]?
 
         private var eventsToSurveysLock = NSLock()
-        private var eventsToSurveys: [String: [String]] = [:]
+        private var eventsToSurveys: [String: [(surveyId: String, condition: PostHogEventCondition)]] = [:]
 
         private var seenSurveyKeysLock = NSLock()
         private var seenSurveyKeys: [AnyHashable: Any]?
@@ -145,12 +145,18 @@
 
         // TODO: Decouple PostHogSDK and use registration handlers instead
         /// Called from PostHogSDK instance when an event is captured
-        func onEvent(event: String) {
-            let activatedSurveys = eventsToSurveysLock.withLock { eventsToSurveys[event] } ?? []
-            guard !activatedSurveys.isEmpty else { return }
+        func onEvent(event: String, properties: [String: Any]) {
+            let candidates = eventsToSurveysLock.withLock { eventsToSurveys[event] } ?? []
+            guard !candidates.isEmpty else { return }
+
+            let matchingSurveyIds = candidates
+                .filter { matchPropertyFilters($0.condition.propertyFilters, eventProperties: properties) }
+                .map(\.surveyId)
+
+            guard !matchingSurveyIds.isEmpty else { return }
 
             eventActivatedSurveysLock.withLock {
-                for survey in activatedSurveys {
+                for survey in matchingSurveyIds {
                     eventActivatedSurveys.insert(survey)
                 }
             }
@@ -214,10 +220,12 @@
         private func decodeAndSetSurveys(remoteConfig: [String: Any]?, callback: @escaping SurveyCallback) {
             let loadedSurveys: [PostHogSurvey] = decodeSurveys(from: remoteConfig ?? [:])
 
-            let eventMap = loadedSurveys.reduce(into: [String: [String]]()) { result, current in
-                if let surveyEvents = current.conditions?.events?.values.map(\.name) {
-                    for event in surveyEvents {
-                        result[event, default: []].append(current.id)
+            let eventMap = loadedSurveys.reduce(into: [String: [(surveyId: String, condition: PostHogEventCondition)]]()) { result, current in
+                if let surveyEvents = current.conditions?.events?.values {
+                    for eventCondition in surveyEvents {
+                        result[eventCondition.name, default: []].append(
+                            (surveyId: current.id, condition: eventCondition)
+                        )
                     }
                 }
             }
@@ -389,6 +397,24 @@
             storage?.setString(forKey: .lastSeenSurveyDate, contents: toISO8601String(date))
         }
 
+        /// Checks if the given event properties satisfy all property filters.
+        /// Returns true if propertyFilters is nil or empty (no filters = match all).
+        private func matchPropertyFilters(
+            _ propertyFilters: [String: PostHogPropertyFilter]?,
+            eventProperties: [String: Any]
+        ) -> Bool {
+            guard let propertyFilters, !propertyFilters.isEmpty else {
+                return true
+            }
+            return propertyFilters.allSatisfy { propertyName, filter in
+                guard let eventValue = eventProperties[propertyName] else {
+                    return false
+                }
+                let eventValueString = String(describing: eventValue)
+                return filter.matchOperator.matches(targets: filter.values, value: eventValueString)
+            }
+        }
+
         /// Checks if a survey has been previously activated by an associated event
         private func isSurveyEventActivated(survey: PostHogSurvey) -> Bool {
             eventActivatedSurveysLock.withLock {
@@ -831,25 +857,25 @@
     private extension PostHogSurveyMatchType {
         func matches(targets: [String], value: String) -> Bool {
             switch self {
-            // any of the targets contain the value (matched lowercase)
+            // value contains any of the targets (case-insensitive)
             case .iContains:
                 targets.contains { target in
-                    target.lowercased().contains(value.lowercased())
+                    value.lowercased().contains(target.lowercased())
                 }
-            // *none* of the targets contain the value (matched lowercase)
+            // value contains *none* of the targets (case-insensitive)
             case .notIContains:
                 targets.allSatisfy { target in
-                    !target.lowercased().contains(value.lowercased())
+                    !value.lowercased().contains(target.lowercased())
                 }
-            // any of the targets match with regex
+            // value matches any of the targets as a regex pattern
             case .regex:
                 targets.contains { target in
-                    target.range(of: value, options: .regularExpression) != nil
+                    value.range(of: target, options: .regularExpression) != nil
                 }
-            // *none* if the targets match with regex
+            // value matches *none* of the targets as a regex pattern
             case .notRegex:
                 targets.allSatisfy { target in
-                    target.range(of: value, options: .regularExpression) == nil
+                    value.range(of: target, options: .regularExpression) == nil
                 }
             // any of the targets is an exact match
             case .exact:
@@ -861,6 +887,22 @@
                 targets.allSatisfy { target in
                     target != value
                 }
+            // any of the targets is numerically less than the value (value > target)
+            case .gt:
+                targets.contains { target in
+                    if let targetNum = Double(target), let valueNum = Double(value) {
+                        return valueNum > targetNum
+                    }
+                    return false
+                }
+            // any of the targets is numerically greater than the value (value < target)
+            case .lt:
+                targets.contains { target in
+                    if let targetNum = Double(target), let valueNum = Double(value) {
+                        return valueNum < targetNum
+                    }
+                    return false
+                }
             case .unknown:
                 false
             }
@@ -955,6 +997,25 @@
                 getNewResponseKey(for: questionId)
             }
 
+            func testMatchPropertyFilters(
+                _ propertyFilters: [String: PostHogPropertyFilter]?,
+                eventProperties: [String: Any]
+            ) -> Bool {
+                matchPropertyFilters(propertyFilters, eventProperties: eventProperties)
+            }
+
+            func testSetEventsToSurveys(_ map: [String: [(surveyId: String, condition: PostHogEventCondition)]]) {
+                eventsToSurveysLock.withLock {
+                    eventsToSurveys = map
+                }
+            }
+
+            func testIsEventActivated(surveyId: String) -> Bool {
+                eventActivatedSurveysLock.withLock {
+                    eventActivatedSurveys.contains(surveyId)
+                }
+            }
+
             static func clearInstalls() {
                 integrationInstalledLock.withLock {
                     integrationInstalled = false