feat(router): add a flag to disable the caching for query plans

Author: ardatan

bin/router/src/pipeline/query_plan.rs

@@ -6,6 +6,7 @@ use crate::pipeline::normalize::GraphQLNormalizationPayload;
 use crate::pipeline::progressive_override::{RequestOverrideContext, StableOverrideContext};
 use crate::shared_state::RouterSharedState;
 use hive_router_query_planner::planner::plan_nodes::QueryPlan;
+use hive_router_query_planner::planner::PlannerError;
 use hive_router_query_planner::utils::cancellation::CancellationToken;
 use ntex::web::HttpRequest;
 use xxhash_rust::xxh3::Xxh3;
@@ -22,36 +23,36 @@ pub async fn plan_operation_with_cache(
         StableOverrideContext::new(&app_state.planner.supergraph, request_override_context);
 
     let filtered_operation_for_plan = &normalized_operation.operation_for_plan;
-    let plan_cache_key =
-        calculate_cache_key(filtered_operation_for_plan.hash(), &stable_override_context);
-    let is_pure_introspection = filtered_operation_for_plan.selection_set.is_empty()
-        && normalized_operation.operation_for_introspection.is_some();
 
-    let plan_result = app_state
-        .plan_cache
-        .try_get_with(plan_cache_key, async move {
-            if is_pure_introspection {
-                return Ok(Arc::new(QueryPlan {
-                    kind: "QueryPlan".to_string(),
-                    node: None,
-                }));
-            }
-
-            app_state
-                .planner
-                .plan_from_normalized_operation(
+    if !app_state.router_config.query_planner.cache.enabled {
+        get_plan(
+            app_state,
+            filtered_operation_for_plan,
+            normalized_operation,
+            request_override_context,
+            cancellation_token,
+        )
+        .map(Arc::new)
+        .map_err(Arc::new)
+    } else {
+        let plan_cache_key =
+            calculate_cache_key(filtered_operation_for_plan.hash(), &stable_override_context);
+
+        app_state
+            .plan_cache
+            .try_get_with(plan_cache_key, async move {
+                get_plan(
+                    app_state,
                     filtered_operation_for_plan,
-                    (&request_override_context.clone()).into(),
+                    normalized_operation,
+                    request_override_context,
                     cancellation_token,
                 )
                 .map(Arc::new)
-        })
-        .await;
-
-    match plan_result {
-        Ok(plan) => Ok(plan),
-        Err(e) => Err(req.new_pipeline_error(PipelineErrorVariant::PlannerError(e.clone()))),
+            })
+            .await
     }
+    .map_err(|err| req.new_pipeline_error(PipelineErrorVariant::PlannerError(err)))
 }
 
 #[inline]
@@ -61,3 +62,27 @@ fn calculate_cache_key(operation_hash: u64, context: &StableOverrideContext) ->
     context.hash(&mut hasher);
     hasher.finish()
 }
+
+#[inline]
+fn get_plan(
+    app_state: &Arc<RouterSharedState>,
+    filtered_operation_for_plan: &hive_router_query_planner::ast::operation::OperationDefinition,
+    normalized_operation: &Arc<GraphQLNormalizationPayload>,
+    request_override_context: &RequestOverrideContext,
+    cancellation_token: &CancellationToken,
+) -> Result<QueryPlan, PlannerError> {
+    let is_pure_introspection = filtered_operation_for_plan.selection_set.is_empty()
+        && normalized_operation.operation_for_introspection.is_some();
+    if is_pure_introspection {
+        return Ok(QueryPlan {
+            kind: "QueryPlan".to_string(),
+            node: None,
+        });
+    }
+
+    app_state.planner.plan_from_normalized_operation(
+        filtered_operation_for_plan,
+        (&request_override_context.clone()).into(),
+        cancellation_token,
+    )
+}

lib/router-config/src/query_planner.rs

@@ -21,13 +21,15 @@ pub struct QueryPlannerConfig {
     )]
     #[schemars(with = "String")]
     pub timeout: Duration,
+    pub cache: QueryPlannerCacheConfig,
 }
 
 impl Default for QueryPlannerConfig {
     fn default() -> Self {
         Self {
             allow_expose: default_query_planning_allow_expose(),
             timeout: default_query_planning_timeout(),
+            cache: QueryPlannerCacheConfig::default(),
         }
     }
 }
@@ -39,3 +41,14 @@ fn default_query_planning_allow_expose() -> bool {
 fn default_query_planning_timeout() -> Duration {
     Duration::from_secs(10)
 }
+
+#[derive(Debug, Deserialize, Serialize, JsonSchema, Clone)]
+pub struct QueryPlannerCacheConfig {
+    pub enabled: bool,
+}
+
+impl Default for QueryPlannerCacheConfig {
+    fn default() -> Self {
+        Self { enabled: true }
+    }
+}