apply correctly

Author: ardatan

lib/executor/src/executors/map.rs

@@ -295,26 +295,30 @@ impl SubgraphExecutorMap {
             .clone();
 
         let mut client = self.client.clone();
+        let mut timeout = &self.config.traffic_shaping.all.request_timeout;
+        let pool_idle_timeout_seconds = self.config.traffic_shaping.all.pool_idle_timeout_seconds;
         let mut dedupe_enabled = self.config.traffic_shaping.all.dedupe_enabled;
-        let mut timeout = self.config.traffic_shaping.all.request_timeout.clone();
         if let Some(subgraph_traffic_shaping_config) =
             self.config.traffic_shaping.subgraphs.get(subgraph_name)
         {
-            if subgraph_traffic_shaping_config.pool_idle_timeout_seconds
-                != self.config.traffic_shaping.all.pool_idle_timeout_seconds
-            {
-                client = Arc::new(
-                    Client::builder(TokioExecutor::new())
-                        .pool_timer(TokioTimer::new())
-                        .pool_idle_timeout(Duration::from_secs(
-                            subgraph_traffic_shaping_config.pool_idle_timeout_seconds,
-                        ))
-                        .pool_max_idle_per_host(self.max_connections_per_host)
-                        .build(HttpsConnector::new()),
-                );
-            }
-            dedupe_enabled = subgraph_traffic_shaping_config.dedupe_enabled;
-            timeout = subgraph_traffic_shaping_config.request_timeout.clone();
+            client = Arc::new(
+                Client::builder(TokioExecutor::new())
+                    .pool_timer(TokioTimer::new())
+                    .pool_idle_timeout(Duration::from_secs(
+                        subgraph_traffic_shaping_config
+                            .pool_idle_timeout_seconds
+                            .unwrap_or(pool_idle_timeout_seconds),
+                    ))
+                    .pool_max_idle_per_host(self.max_connections_per_host)
+                    .build(HttpsConnector::new()),
+            );
+            dedupe_enabled = subgraph_traffic_shaping_config
+                .dedupe_enabled
+                .unwrap_or(dedupe_enabled);
+            timeout = subgraph_traffic_shaping_config
+                .request_timeout
+                .as_ref()
+                .unwrap_or(timeout);
         }
 
         let executor = HTTPSubgraphExecutor::new(
@@ -324,7 +328,7 @@ impl SubgraphExecutorMap {
             semaphore,
             dedupe_enabled,
             self.in_flight_requests.clone(),
-            timeout,
+            timeout.clone(),
         );
 
         self.executors_by_subgraph

lib/router-config/src/traffic_shaping.rs

@@ -13,7 +13,7 @@ pub struct TrafficShapingConfig {
     pub all: TrafficShapingExecutorConfig,
     /// Optional per-subgraph configurations that will override the default configuration for specific subgraphs.
     #[serde(default, skip_serializing_if = "HashMap::is_empty")]
-    pub subgraphs: HashMap<String, TrafficShapingExecutorConfig>,
+    pub subgraphs: HashMap<String, TrafficShapingExecutorSubgraphConfig>,
     /// Limits the concurrent amount of requests/connections per host/subgraph.
     #[serde(default = "default_max_connections_per_host")]
     pub max_connections_per_host: usize,
@@ -41,6 +41,39 @@ fn default_dedupe_enabled() -> bool {
     true
 }
 
+#[derive(Debug, Deserialize, Serialize, JsonSchema, Clone)]
+#[serde(deny_unknown_fields)]
+pub struct TrafficShapingExecutorSubgraphConfig {
+    /// Timeout for idle sockets being kept-alive.
+    pub pool_idle_timeout_seconds: Option<u64>,
+
+    /// Enables/disables request deduplication to subgraphs.
+    ///
+    /// When requests exactly matches the hashing mechanism (e.g., subgraph name, URL, headers, query, variables), and are executed at the same time, they will
+    /// be deduplicated by sharing the response of other in-flight requests.
+    pub dedupe_enabled: Option<bool>,
+
+    /// Optional timeout configuration for requests to subgraphs.
+    ///
+    /// Example with a fixed duration:
+    /// ```yaml
+    ///   timeout:
+    ///     duration: 5s
+    /// ```
+    ///
+    /// Or with a VRL expression that can return a duration based on the operation kind:
+    /// ```yaml
+    ///   timeout:
+    ///     expression: |
+    ///      if (.request.operation.type == "mutation") {
+    ///        "10s"
+    ///      } else {
+    ///        "15s"
+    ///      }
+    /// ```
+    pub request_timeout: Option<DurationOrExpression>,
+}
+
 #[derive(Debug, Deserialize, Serialize, JsonSchema, Clone)]
 #[serde(deny_unknown_fields)]
 pub struct TrafficShapingExecutorConfig {