Another plugin

Author: ardatan

lib/executor/src/plugins/examples/subgraph_response_cache.rs

@@ -1,32 +1,30 @@
 use dashmap::DashMap;
 
-use crate::{hooks::on_subgraph_execute::{OnSubgraphExecuteEndPayload, OnSubgraphExecuteStartPayload, SubgraphExecutorResponse, SubgraphResponse}, plugin_trait::{ControlFlow, RouterPlugin}};
+use crate::{executors::dedupe::SharedResponse, hooks::on_subgraph_http_request::{OnSubgraphHttpRequestPayload, OnSubgraphHttpResponsePayload}, plugin_trait::{ControlFlow, RouterPlugin}};
 
-struct SubgraphResponseCachePlugin {
-    cache: DashMap<String, SubgraphResponse<'static>>,
+pub struct SubgraphResponseCachePlugin {
+    cache: DashMap<String, SharedResponse>,
 }
 
 impl RouterPlugin for SubgraphResponseCachePlugin {
-    fn on_subgraph_execute<'exec>(
-            &self, 
-            payload: OnSubgraphExecuteStartPayload<'exec>,
-        ) -> ControlFlow<'exec, OnSubgraphExecuteEndPayload<'exec>> {
+    fn on_subgraph_http_request<'exec>(
+            &'static self, 
+            payload: OnSubgraphHttpRequestPayload<'exec>,
+        ) -> ControlFlow<'exec, OnSubgraphHttpResponsePayload<'exec>> {
         let key = format!(
-            "subgraph_response_cache:{}:{}:{:?}",
-            payload.subgraph_name, payload.execution_request.operation_name.unwrap_or(""), payload.execution_request.variables
+            "subgraph_response_cache:{}:{:?}",
+            payload.execution_request.query, payload.execution_request.variables
         );
         if let Some(cached_response) = self.cache.get(&key) {
-            *payload.response = Some(SubgraphExecutorResponse::RawResponse(cached_response));
-            // Return early with the cached response
+            // Here payload.response is Option
+            // So it is bypassing the actual subgraph request
+            *payload.response = Some(cached_response.clone());
             return ControlFlow::Continue;
-        } else {
-            ControlFlow::OnEnd(Box::new(move |payload: OnSubgraphExecuteEndPayload| {
-                let cacheable = payload.response.errors.is_none_or(|errors| errors.is_empty());
-                if cacheable {
-                    self.cache.insert(key, *payload.response);
-                }
-                ControlFlow::Continue
-            }))
         }
+        ControlFlow::OnEnd(Box::new(move |payload: OnSubgraphHttpResponsePayload| {
+            // Here payload.response is not Option
+            self.cache.insert(key, payload.response.clone());
+            ControlFlow::Continue
+        }))
     }
 }

lib/executor/src/plugins/hooks/mod.rs

@@ -1,3 +1,3 @@
 pub mod on_execute;
 pub mod on_schema_reload;
-pub mod on_subgraph_execute;
+pub mod on_subgraph_http_request;

lib/executor/src/plugins/hooks/on_subgraph_execute.rs renamed to lib/executor/src/plugins/hooks/on_subgraph_http_request.rs

@@ -1,47 +1,47 @@
 use std::collections::HashMap;
 
-use bytes::Bytes;
 use hive_router_query_planner::ast::operation::SubgraphFetchOperation;
+use http::{HeaderMap, Uri};
 use ntex::web::HttpRequest;
 
-use crate::{executors::dedupe::SharedResponse, response::{graphql_error::GraphQLError, value::Value}};
+use crate::
+    executors::dedupe::SharedResponse
+;
 
+pub struct OnSubgraphHttpRequestPayload<'exec> {
+    pub router_http_request: &'exec HttpRequest,
+    pub subgraph_name: &'exec str,
+    // At this point, there is no point of mutating this
+    pub execution_request: &'exec SubgraphExecutionRequest<'exec>,
 
+    pub endpoint: &'exec mut Uri,
+    // By default, it is POST
+    pub method: &'exec mut http::Method,
+    pub headers: &'exec mut HeaderMap,
+    pub request_body: &'exec mut Vec<u8>,
 
-pub struct OnSubgraphExecuteStartPayload<'exec> {
-    pub router_http_request: &'exec HttpRequest,
-	pub subgraph_name: &'exec str,
-	// The node that initiates this subgraph execution
-	pub execution_request: &'exec mut SubgraphExecutionRequest<'exec>,
-	// This will be tricky to implement with the current structure,
-	// but I'm sure we'll figure it out
-	pub response: &'exec mut Option<SubgraphResponse<'exec>>,
+    // Early response
+    pub response: &'exec mut Option<SharedResponse>,
 }
 
 pub struct SubgraphExecutionRequest<'exec> {
     pub query: &'exec str,
     // We can add the original operation here too
     pub operation: &'exec SubgraphFetchOperation,
-    
+
     pub dedupe: bool,
     pub operation_name: Option<&'exec str>,
     pub variables: Option<HashMap<&'exec str, &'exec sonic_rs::Value>>,
     pub extensions: Option<HashMap<String, sonic_rs::Value>>,
     pub representations: Option<Vec<u8>>,
 }
 
-pub struct SubgraphResponse<'exec> {
-    pub data: Value<'exec>,
-    pub errors: Option<Vec<GraphQLError>>,
-    pub extensions: Option<HashMap<String, Value<'exec>>>,
-}
-
-pub struct OnSubgraphExecuteEndPayload<'exec> {
+pub struct OnSubgraphHttpResponsePayload<'exec> {
     pub router_http_request: &'exec HttpRequest,
     pub subgraph_name: &'exec str,
     // The node that initiates this subgraph execution
     pub execution_request: &'exec SubgraphExecutionRequest<'exec>,
     // This will be tricky to implement with the current structure,
     // but I'm sure we'll figure it out
-    pub response: &'exec SubgraphResponse<'exec>,
+	pub response: &'exec mut SharedResponse,
 }

lib/executor/src/plugins/plugin_trait.rs

@@ -2,13 +2,12 @@ use ntex::web::HttpResponse;
 
 use crate::hooks::on_execute::OnExecutePayload;
 use crate::hooks::on_schema_reload::OnSchemaReloadPayload;
-use crate::hooks::on_subgraph_execute::OnSubgraphExecuteEndPayload;
-use crate::hooks::on_subgraph_execute::OnSubgraphExecuteStartPayload;
+use crate::hooks::on_subgraph_http_request::{OnSubgraphHttpRequestPayload, OnSubgraphHttpResponsePayload};
 
-pub enum ControlFlow<'a, TPayload> {
+pub enum ControlFlow<'exec, TPayload> {
     Continue,
     Break(HttpResponse),
-    OnEnd(Box<dyn FnOnce(TPayload) -> ControlFlow<'a, ()> + Send + 'a>),
+    OnEnd(Box<dyn FnOnce(TPayload) -> ControlFlow<'exec, ()> + 'exec>),
 }
 
 pub trait RouterPlugin {
@@ -18,10 +17,10 @@ pub trait RouterPlugin {
     ) -> ControlFlow<'exec, OnExecutePayload<'exec>> {
         ControlFlow::Continue
     }
-    fn on_subgraph_execute<'exec>(
-        &self, 
-        _payload: OnSubgraphExecuteStartPayload<'exec>,
-    ) -> ControlFlow<'exec, OnSubgraphExecuteEndPayload<'exec>> {
+    fn on_subgraph_http_request<'exec>(
+        &'static self, 
+        _payload: OnSubgraphHttpRequestPayload<'exec>,
+    ) -> ControlFlow<'exec, OnSubgraphHttpResponsePayload<'exec>> {
         ControlFlow::Continue
     }
     fn on_schema_reload(&self, _payload: OnSchemaReloadPayload) {}