Fix

Author: ardatan

Cargo.lock

@@ -1,20 +1,22 @@
 use std::collections::{BTreeMap, HashMap, HashSet};
 
-use hive_router_config::override_labels::{LabelOverrideValue, OverrideLabelsConfig};
+use hive_router_config::{
+    override_labels::{LabelOverrideValue, OverrideLabelsConfig},
+    primitives::expression::Expression,
+};
 use hive_router_plan_executor::execution::client_request_details::ClientRequestDetails;
 use hive_router_query_planner::{
     graph::{PlannerOverrideContext, PERCENTAGE_SCALE_FACTOR},
     state::supergraph_state::SupergraphState,
 };
 use rand::Rng;
 use vrl::{
-    compiler::{compile as vrl_compile, Program as VrlProgram, TargetValue as VrlTargetValue},
+    compiler::TargetValue as VrlTargetValue,
     core::Value as VrlValue,
     prelude::{
         state::RuntimeState as VrlState, Context as VrlContext, ExpressionError,
         TimeZone as VrlTimeZone,
     },
-    stdlib::all as vrl_build_functions,
     value::Secrets as VrlSecrets,
 };
 
@@ -117,7 +119,7 @@ impl StableOverrideContext {
 /// It's intended to be used as a shared state in the router.
 pub struct OverrideLabelsEvaluator {
     static_enabled_labels: HashSet<String>,
-    expressions: HashMap<String, VrlProgram>,
+    expressions: HashMap<String, Expression>,
 }
 
 impl OverrideLabelsEvaluator {
@@ -126,27 +128,14 @@ impl OverrideLabelsEvaluator {
     ) -> Result<Self, OverrideLabelsCompileError> {
         let mut static_enabled_labels = HashSet::new();
         let mut expressions = HashMap::new();
-        let vrl_functions = vrl_build_functions();
 
         for (label, value) in override_labels_config.iter() {
             match value {
                 LabelOverrideValue::Boolean(true) => {
                     static_enabled_labels.insert(label.clone());
                 }
-                LabelOverrideValue::Expression { expression } => {
-                    let compilation_result =
-                        vrl_compile(expression, &vrl_functions).map_err(|diagnostics| {
-                            OverrideLabelsCompileError {
-                                label: label.clone(),
-                                error: diagnostics
-                                    .errors()
-                                    .into_iter()
-                                    .map(|d| d.code.to_string() + ": " + &d.message)
-                                    .collect::<Vec<_>>()
-                                    .join(", "),
-                            }
-                        })?;
-                    expressions.insert(label.clone(), compilation_result.program);
+                LabelOverrideValue::Expression(expression) => {
+                    expressions.insert(label.clone(), expression.clone());
                 }
                 _ => {} // Skip false booleans
             }
@@ -179,7 +168,7 @@ impl OverrideLabelsEvaluator {
         let mut ctx = VrlContext::new(&mut target, &mut state, &timezone);
 
         for (label, expression) in &self.expressions {
-            match expression.resolve(&mut ctx) {
+            match expression.execute_with_context(&mut ctx) {
                 Ok(evaluated_value) => match evaluated_value {
                     VrlValue::Boolean(true) => {
                         active_flags.insert(label.clone());

bin/router/src/pipeline/progressive_override.rs

@@ -1,4 +1,4 @@
-use vrl::{diagnostic::DiagnosticList, prelude::ExpressionError};
+use vrl::prelude::ExpressionError;
 
 use crate::response::graphql_error::{GraphQLError, GraphQLErrorExtensions};
 
@@ -34,21 +34,6 @@ impl From<SubgraphExecutorError> for GraphQLError {
 }
 
 impl SubgraphExecutorError {
-    pub fn new_endpoint_expression_build(
-        subgraph_name: String,
-        diagnostics: DiagnosticList,
-    ) -> Self {
-        SubgraphExecutorError::EndpointExpressionBuild(
-            subgraph_name,
-            diagnostics
-                .errors()
-                .into_iter()
-                .map(|d| d.code.to_string() + ": " + &d.message)
-                .collect::<Vec<_>>()
-                .join(", "),
-        )
-    }
-
     pub fn new_endpoint_expression_resolution_failure(
         subgraph_name: String,
         error: ExpressionError,

lib/executor/src/executors/error.rs

@@ -190,7 +190,7 @@ impl SubgraphExecutorMap {
             ]));
 
             // Resolve the expression to get an endpoint URL.
-            let endpoint_result = expression.execute(value).map_err(|err| {
+            let endpoint_result = expression.execute_with_value(value).map_err(|err| {
                 SubgraphExecutorError::new_endpoint_expression_resolution_failure(
                     subgraph_name.to_string(),
                     err,

lib/executor/src/executors/map.rs

@@ -166,9 +166,15 @@ impl ApplyRequestHeader for RequestInsertExpression {
         if is_denied_header(&self.name) {
             return Ok(());
         }
-        let value = self.expression.execute(ctx.into()).map_err(|err| {
-            HeaderRuleRuntimeError::new_expression_evaluation(self.name.to_string(), Box::new(err))
-        })?;
+        let value = self
+            .expression
+            .execute_with_value(ctx.into())
+            .map_err(|err| {
+                HeaderRuleRuntimeError::new_expression_evaluation(
+                    self.name.to_string(),
+                    Box::new(err),
+                )
+            })?;
 
         if let Some(header_value) = vrl_value_to_header_value(value) {
             if is_never_join_header(&self.name) {

lib/executor/src/headers/request.rs

@@ -188,9 +188,12 @@ impl ApplyResponseHeader for ResponseInsertExpression {
         if is_denied_header(&self.name) {
             return Ok(());
         }
-        let value = self.expression.execute(ctx.into()).map_err(|err| {
-            HeaderRuleRuntimeError::ExpressionEvaluation(self.name.to_string(), Box::new(err))
-        })?;
+        let value = self
+            .expression
+            .execute_with_value(ctx.into())
+            .map_err(|err| {
+                HeaderRuleRuntimeError::ExpressionEvaluation(self.name.to_string(), Box::new(err))
+            })?;
 
         if let Some(header_value) = vrl_value_to_header_value(value) {
             let strategy = if is_never_join_header(&self.name) {

lib/executor/src/headers/response.rs

@@ -25,6 +25,7 @@ retry-policies = { workspace = true}
 tracing = { workspace = true }
 vrl = { workspace = true }
 
+once_cell = "1.21.3"
 schemars = "1.0.4"
 humantime-serde = "1.1.1"
 config = { version = "0.15.14", features = ["yaml", "json", "json5"] }

lib/router-config/Cargo.toml

@@ -2,6 +2,8 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
+use crate::primitives::expression::Expression;
+
 /// A map of label names to their override configuration.
 pub type OverrideLabelsConfig = HashMap<String, LabelOverrideValue>;
 
@@ -15,10 +17,7 @@ pub enum LabelOverrideValue {
     /// A static boolean value to enable or disable the label.
     Boolean(bool),
     /// A dynamic value computed by an expression.
-    Expression {
-        /// An expression that must evaluate to a boolean. If true, the label will be applied.
-        expression: String,
-    },
+    Expression(Expression),
 }
 
 impl LabelOverrideValue {

lib/router-config/src/override_labels.rs

@@ -1,12 +1,12 @@
-use std::{borrow::Cow, collections::BTreeMap};
-
+use once_cell::sync::Lazy;
 use schemars::{JsonSchema, Schema, SchemaGenerator};
 use serde::{Deserialize, Serialize};
+use std::{borrow::Cow, collections::BTreeMap};
 use vrl::{
     compiler::{compile as vrl_compile, Program as VrlProgram, TargetValue as VrlTargetValue},
     core::Value as VrlValue,
     prelude::{
-        state::RuntimeState as VrlState, Context as VrlContext, ExpressionError,
+        state::RuntimeState as VrlState, Context as VrlContext, ExpressionError, Function,
         TimeZone as VrlTimeZone,
     },
     stdlib::all as vrl_build_functions,
@@ -19,16 +19,17 @@ pub struct Expression {
     program: Box<VrlProgram>,
 }
 
+static VRL_FUNCTIONS: Lazy<Vec<Box<dyn Function>>> = Lazy::new(vrl_build_functions);
+static VRL_TIMEZONE: Lazy<VrlTimeZone> = Lazy::new(VrlTimeZone::default);
+
 impl Expression {
     pub fn try_new(expression: String) -> Result<Self, String> {
-        let vrl_functions = vrl_build_functions();
-
         let compilation_result =
-            vrl_compile(&expression, &vrl_functions).map_err(|diagnostics| {
+            vrl_compile(&expression, &VRL_FUNCTIONS).map_err(|diagnostics| {
                 diagnostics
                     .errors()
-                    .into_iter()
-                    .map(|d| d.code.to_string() + ": " + &d.message)
+                    .iter()
+                    .map(|d| format!("{}: {}", d.code, d.message))
                     .collect::<Vec<_>>()
                     .join(", ")
             })?;
@@ -39,18 +40,21 @@ impl Expression {
         })
     }
 
-    pub fn execute(&self, value: VrlValue) -> Result<VrlValue, ExpressionError> {
+    pub fn execute_with_value(&self, value: VrlValue) -> Result<VrlValue, ExpressionError> {
         let mut target = VrlTargetValue {
             value,
             metadata: VrlValue::Object(BTreeMap::new()),
             secrets: VrlSecrets::default(),
         };
 
         let mut state = VrlState::default();
-        let timezone = VrlTimeZone::default();
-        let mut ctx = VrlContext::new(&mut target, &mut state, &timezone);
+        let mut ctx = VrlContext::new(&mut target, &mut state, &VRL_TIMEZONE);
+
+        self.execute_with_context(&mut ctx)
+    }
 
-        self.program.resolve(&mut ctx)
+    pub fn execute_with_context(&self, ctx: &mut VrlContext) -> Result<VrlValue, ExpressionError> {
+        self.program.resolve(ctx)
     }
 }
 
@@ -59,8 +63,44 @@ impl<'de> Deserialize<'de> for Expression {
     where
         D: serde::Deserializer<'de>,
     {
-        let expression = String::deserialize(deserializer)?;
-        Expression::try_new(expression).map_err(serde::de::Error::custom)
+        struct ExpressionVisitor;
+        impl<'de> serde::de::Visitor<'de> for ExpressionVisitor {
+            type Value = Expression;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a map for Expression")
+            }
+
+            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::MapAccess<'de>,
+            {
+                let mut expression_str: Option<String> = None;
+
+                while let Some(key) = map.next_key::<String>()? {
+                    match key.as_str() {
+                        "expression" => {
+                            if expression_str.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expression"));
+                            }
+                            expression_str = Some(map.next_value()?);
+                        }
+                        other_key => {
+                            return Err(serde::de::Error::unknown_field(
+                                other_key,
+                                &["expression"],
+                            ));
+                        }
+                    }
+                }
+
+                let expression_str =
+                    expression_str.ok_or_else(|| serde::de::Error::missing_field("expression"))?;
+
+                Expression::try_new(expression_str).map_err(serde::de::Error::custom)
+            }
+        }
+        deserializer.deserialize_map(ExpressionVisitor)
     }
 }