feat: add an optional cow interface for context properties and results (#332)

Author: sighphyre

unleash-yggdrasil/src/lib.rs

@@ -759,7 +759,8 @@ fn get_seed<'a>(stickiness: Option<&str>, context: &'a EnrichedContext<'a>) -> O
             "remoteAddress" => context.remote_address,
             _ => context
                 .properties
-                .and_then(|props| props.get(custom).map(|v| v.as_str())),
+                .as_ref()
+                .and_then(|props| props.get(custom)),
         },
     }
 }
@@ -775,11 +776,10 @@ fn lookup_override_context<'a>(
         "appName" => context.app_name,
         "currentTime" => context.current_time,
         "remoteAddress" => context.remote_address,
-        _ => context.properties.and_then(|props| {
-            props
-                .get(variant_override.context_name.as_str())
-                .map(|s| s.as_str())
-        }),
+        _ => context
+            .properties
+            .as_ref()
+            .and_then(|props| props.get(variant_override.context_name.as_str())),
     }
 }
 

unleash-yggdrasil/src/state.rs

@@ -1,15 +1,48 @@
-use std::collections::HashMap;
+use std::{borrow::Cow, collections::HashMap};
 use unleash_types::client_features::Context;
 
+pub type PropertiesCow<'a> = HashMap<Cow<'a, str>, Cow<'a, str>>;
+pub type ExternalResultsCow<'a> = HashMap<Cow<'a, str>, bool>;
+
+#[derive(Copy, Clone)]
+pub enum PropertiesRef<'a> {
+    Strings(&'a HashMap<String, String>),
+    Cows(&'a PropertiesCow<'a>),
+}
+
+#[derive(Copy, Clone)]
+pub enum ExternalResultsRef<'a> {
+    Strings(&'a HashMap<String, bool>),
+    Cows(&'a ExternalResultsCow<'a>),
+}
+
+impl<'a> PropertiesRef<'a> {
+    pub fn get(&self, key: &str) -> Option<&'a str> {
+        match self {
+            PropertiesRef::Strings(m) => m.get(key).map(|v| v.as_str()),
+            PropertiesRef::Cows(m) => m.get(key).map(|v| v.as_ref()),
+        }
+    }
+}
+
+impl<'a> ExternalResultsRef<'a> {
+    pub fn get(&self, key: &str) -> Option<bool> {
+        match self {
+            ExternalResultsRef::Strings(m) => m.get(key).copied(),
+            ExternalResultsRef::Cows(m) => m.get(key).copied(),
+        }
+    }
+}
+
 pub struct EnrichedContext<'a> {
     pub user_id: Option<&'a str>,
     pub session_id: Option<&'a str>,
     pub environment: Option<&'a str>,
     pub app_name: Option<&'a str>,
     pub current_time: Option<&'a str>,
     pub remote_address: Option<&'a str>,
-    pub properties: Option<&'a HashMap<String, String>>,
-    pub external_results: Option<&'a HashMap<String, bool>>,
+    pub properties: Option<PropertiesRef<'a>>,
+    pub external_results: Option<ExternalResultsRef<'a>>,
     pub toggle_name: &'a str,
     pub runtime_hostname: Option<&'a str>,
 }
@@ -27,8 +60,8 @@ impl<'a> EnrichedContext<'a> {
             app_name: context.app_name.as_deref(),
             current_time: context.current_time.as_deref(),
             remote_address: context.remote_address.as_deref(),
-            properties: context.properties.as_ref(),
-            external_results,
+            properties: context.properties.as_ref().map(PropertiesRef::Strings),
+            external_results: external_results.map(ExternalResultsRef::Strings),
             toggle_name,
             runtime_hostname: None,
         }

unleash-yggdrasil/src/strategy_parsing.rs

@@ -189,7 +189,7 @@ fn context_property(node: Pairs<Rule>) -> ContextResolver {
             .properties
             .as_ref()?
             .get(context_name.as_str())
-            .map(|v| Cow::Borrowed(v.as_str()))
+            .map(Cow::Borrowed)
     })
 }
 
@@ -530,7 +530,6 @@ fn external_value(node: Pairs<Rule>) -> CompileResult<RuleFragment> {
             .external_results
             .as_ref()
             .and_then(|strategy_results| strategy_results.get(&strategy_index))
-            .copied()
             .unwrap_or(false)
     }))
 }
@@ -661,6 +660,8 @@ pub fn compile_rule(rule: &str) -> CompileResult<RuleFragment> {
 
 #[cfg(test)]
 mod tests {
+    use crate::state::{ExternalResultsRef, PropertiesRef};
+
     use super::*;
     use std::collections::HashMap;
     use test_case::test_case;
@@ -825,7 +826,7 @@ mod tests {
         let context = Context {
             current_time: None,
             user_id: Some("6".into()),
-            properties: Some(&context_property),
+            properties: Some(PropertiesRef::Strings(&context_property)),
             session_id: None,
             environment: None,
             app_name: None,
@@ -872,7 +873,7 @@ mod tests {
         let context = Context {
             user_id: Some("42".into()),
             session_id: Some("7".into()),
-            properties: Some(&props),
+            properties: Some(PropertiesRef::Strings(&props)),
             ..Context::default()
         };
 
@@ -958,7 +959,7 @@ mod tests {
         let mut context = Context::default();
         let mut props = HashMap::new();
         props.insert("cutoff".into(), "2022-01-25T13:00:00.000Z".into());
-        context.properties = Some(&props);
+        context.properties = Some(PropertiesRef::Strings(&props));
 
         assert_eq!(rule(&context), expected);
     }
@@ -971,7 +972,7 @@ mod tests {
         let mut context = Context::default();
         let mut props = HashMap::new();
         props.insert("cutoff".into(), "2022-01-25T13:00:00.000Z".into());
-        context.properties = Some(&props);
+        context.properties = Some(PropertiesRef::Strings(&props));
 
         assert!(!rule(&context));
     }
@@ -1052,7 +1053,7 @@ mod tests {
         custom_strategy_results.insert("test_value".to_string(), true);
 
         let context = Context {
-            external_results: Some(&custom_strategy_results),
+            external_results: Some(ExternalResultsRef::Strings(&custom_strategy_results)),
             ..Context::default()
         };
 
@@ -1068,7 +1069,7 @@ mod tests {
         custom_strategy_results.insert("test_value".to_string(), true);
 
         let context = Context {
-            external_results: Some(&custom_strategy_results),
+            external_results: Some(ExternalResultsRef::Strings(&custom_strategy_results)),
             ..Context::default()
         };
 
@@ -1077,7 +1078,7 @@ mod tests {
         let mut custom_strategy_results = HashMap::new();
         custom_strategy_results.insert("test_value".to_string(), false);
         let context = Context {
-            external_results: Some(&custom_strategy_results),
+            external_results: Some(ExternalResultsRef::Strings(&custom_strategy_results)),
             ..Context::default()
         };