feat: support prerequisite references in all_flags_detail

Author: cwaldren-ld

launchdarkly-server-sdk/src/evaluation.rs

@@ -1,7 +1,8 @@
+use std::cell::RefCell;
 use super::stores::store::DataStore;
 use serde::Serialize;
 
-use launchdarkly_server_sdk_evaluation::{evaluate, Context, FlagValue, Reason};
+use launchdarkly_server_sdk_evaluation::{evaluate, Context, FlagValue, PrerequisiteEvent, PrerequisiteEventRecorder, Reason};
 use std::collections::HashMap;
 use std::time::SystemTime;
 
@@ -78,6 +79,9 @@ pub struct FlagState {
 
     #[serde(skip_serializing_if = "Option::is_none")]
     debug_events_until_date: Option<u64>,
+
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    prerequisites: Vec<String>,
 }
 
 /// FlagDetail is a snapshot of the state of multiple feature flags with regard to a specific user.
@@ -97,6 +101,27 @@ pub struct FlagDetail {
     valid: bool,
 }
 
+struct DirectPrerequisiteRecorder {
+    target_flag_key: String,
+    prerequisites: RefCell<Vec<String>>,
+}
+
+impl DirectPrerequisiteRecorder {
+    pub fn new(target_flag_key: impl Into<String>) -> Self {
+        Self {
+            target_flag_key: target_flag_key.into(),
+            prerequisites: RefCell::new(Vec::new()),
+        }
+    }
+}
+impl PrerequisiteEventRecorder for DirectPrerequisiteRecorder {
+    fn record(&self, event: PrerequisiteEvent) {
+        if event.target_flag_key == self.target_flag_key {
+            self.prerequisites.borrow_mut().push(event.prerequisite_flag.key)
+        }
+    }
+}
+
 impl FlagDetail {
     /// Create a new empty instance of FlagDetail.
     pub fn new(valid: bool) -> Self {
@@ -118,7 +143,10 @@ impl FlagDetail {
                 continue;
             }
 
-            let detail = evaluate(store.to_store(), &flag, context, None);
+            let event_recorder = DirectPrerequisiteRecorder::new(key.clone());
+
+            let detail = evaluate(store.to_store(), &flag, context, Some(&event_recorder));
+
 
             // Here we are applying the same logic used in EventFactory.new_feature_request_event
             // to determine whether the evaluation involved an experiment, in which case both
@@ -171,6 +199,7 @@ impl FlagDetail {
                     track_events,
                     track_reason,
                     debug_events_until_date: flag.debug_events_until_date,
+                    prerequisites: event_recorder.prerequisites.take(),
                 },
             );
         }
@@ -182,11 +211,12 @@ impl FlagDetail {
 
 #[cfg(test)]
 mod tests {
+    use assert_json_diff::assert_json_eq;
     use crate::evaluation::FlagDetail;
     use crate::stores::store::DataStore;
     use crate::stores::store::InMemoryDataStore;
     use crate::stores::store_types::{PatchTarget, StorageItem};
-    use crate::test_common::basic_flag;
+    use crate::test_common::{basic_flag, basic_flag_with_prereqs};
     use crate::FlagDetailConfig;
     use launchdarkly_server_sdk_evaluation::ContextBuilder;
 
@@ -410,4 +440,57 @@ mod tests {
             serde_json::to_string_pretty(&expected).unwrap(),
         );
     }
+
+    #[test]
+    fn flag_prerequisites_should_be_exposed() {
+        let context = ContextBuilder::new("bob")
+            .build()
+            .expect("Failed to create context");
+        let mut store = InMemoryDataStore::new();
+
+        let prereq1 = basic_flag("prereq1");
+        let prereq2 = basic_flag("prereq2");
+        let toplevel = basic_flag_with_prereqs("toplevel", &["prereq1", "prereq2"]);
+
+
+        store
+            .upsert("prereq1", PatchTarget::Flag(StorageItem::Item(prereq1)))
+            .expect("patch should apply");
+
+        store
+            .upsert("prereq2", PatchTarget::Flag(StorageItem::Item(prereq2)))
+            .expect("patch should apply");
+
+        store
+            .upsert("toplevel", PatchTarget::Flag(StorageItem::Item(toplevel)))
+            .expect("patch should apply");
+
+        let mut flag_detail = FlagDetail::new(true);
+        flag_detail.populate(&store, &context, FlagDetailConfig::new());
+
+        let expected = json!({
+            "prereq1": true,
+            "prereq2": true,
+            "toplevel": true,
+            "$flagsState": {
+                "toplevel": {
+                    "version": 42,
+                    "variation": 1,
+                    "prerequisites": ["prereq1", "prereq2"]
+                },
+                "prereq2": {
+                    "version": 42,
+                    "variation": 1
+                },
+                "prereq1": {
+                    "version": 42,
+                    "variation": 1,
+                },
+            },
+            "$valid": true
+        });
+
+        assert_json_eq!(expected, flag_detail);
+
+    }
 }

launchdarkly-server-sdk/src/test_common.rs

@@ -24,7 +24,7 @@ pub fn basic_flag(key: &str) -> Flag {
         }}"#,
         serde_json::Value::String(key.to_string())
     ))
-    .unwrap()
+        .unwrap()
 }
 
 pub fn basic_off_flag(key: &str) -> Flag {
@@ -51,14 +51,26 @@ pub fn basic_off_flag(key: &str) -> Flag {
 }
 
 pub fn basic_flag_with_prereq(key: &str, prereq_key: &str) -> Flag {
+    basic_flag_with_prereqs(key, &[prereq_key])
+}
+
+pub fn basic_flag_with_prereqs(key: &str, prereq_keys: &[&str]) -> Flag {
+
+    let prereqs_json: String = prereq_keys
+        .iter()
+        .map(|&prereq_key| format!(r#"{{"key": {}, "variation": 1}}"#, serde_json::Value::String(prereq_key.to_string())))
+        .collect::<Vec<String>>()
+        .join(",");
+
+
     serde_json::from_str(&format!(
         r#"{{
             "key": {},
             "version": 42,
             "on": true,
             "targets": [],
             "rules": [],
-            "prerequisites": [{{"key": {}, "variation": 1}}],
+            "prerequisites": [{}],
             "fallthrough": {{"variation": 1}},
             "offVariation": 0,
             "variations": [false, true],
@@ -69,9 +81,9 @@ pub fn basic_flag_with_prereq(key: &str, prereq_key: &str) -> Flag {
             "salt": "kosher"
         }}"#,
         serde_json::Value::String(key.to_string()),
-        serde_json::Value::String(prereq_key.to_string()),
+        prereqs_json
     ))
-    .unwrap()
+        .unwrap()
 }
 
 pub fn basic_int_flag(key: &str) -> Flag {