*: Register network name in query

Author: leoyvens

core/src/subgraph/loader.rs

@@ -94,7 +94,7 @@ where
             .into_iter(),
         )));
 
-        Ok(Query::new(schema, document, variables))
+        Ok(Query::new(schema, document, variables, None))
     }
 
     fn parse_data_sources(

core/tests/interfaces.rs

@@ -33,7 +33,12 @@ fn insert_and_query(
     )?;
 
     let document = graphql_parser::parse_query(query).unwrap();
-    let query = Query::new(STORE.api_schema(&subgraph_id).unwrap(), document, None);
+    let query = Query::new(
+        STORE.api_schema(&subgraph_id).unwrap(),
+        document,
+        None,
+        STORE.network_name(&subgraph_id).unwrap(),
+    );
     Ok(execute_subgraph_query(query))
 }
 

graph/src/data/query/query.rs

@@ -111,21 +111,25 @@ pub struct Query {
     pub document: q::Document,
     pub variables: Option<QueryVariables>,
     pub shape_hash: u64,
+    pub network: Option<String>,
     _force_use_of_new: (),
 }
 
 impl Query {
+    /// The `network` is currently used only for caching purposes, so it is not mandatory.
     pub fn new(
         schema: Arc<Schema>,
         document: q::Document,
         variables: Option<QueryVariables>,
+        network: Option<String>,
     ) -> Self {
         let shape_hash = shape_hash(&document);
         Query {
             schema,
             document,
             variables,
             shape_hash,
+            network,
             _force_use_of_new: (),
         }
     }

graph/src/data/subgraph/schema/queries.rs

@@ -38,6 +38,7 @@ impl<S: SubgraphDeploymentStore, Q: GraphQlRunner> LazyMetadata<S, Q> {
                 Some(QueryVariables::new(HashMap::from_iter(
                     vec![(String::from("id"), q::Value::String(self.id.to_string()))].into_iter(),
                 ))),
+                None,
             ))
             .await?;
 
@@ -72,6 +73,7 @@ impl<S: SubgraphDeploymentStore, Q: GraphQlRunner> LazyMetadata<S, Q> {
                 Some(QueryVariables::new(HashMap::from_iter(
                     vec![(String::from("id"), q::Value::String(self.id.to_string()))].into_iter(),
                 ))),
+                None,
             ))
             .await?;
 

graphql/tests/introspection.rs

@@ -553,6 +553,7 @@ fn introspection_query(schema: Schema, query: &str) -> QueryResult {
         Arc::new(schema),
         graphql_parser::parse_query(query).unwrap(),
         None,
+        None,
     );
 
     // Execute it

graphql/tests/query.rs

@@ -231,7 +231,7 @@ fn execute_query_document_with_variables(
     variables: Option<QueryVariables>,
 ) -> QueryResult {
     let runner = GraphQlRunner::new(&*LOGGER, STORE.clone(), LOAD_MANAGER.clone());
-    let query = Query::new(Arc::new(api_test_schema()), query, variables);
+    let query = Query::new(Arc::new(api_test_schema()), query, variables, None);
 
     return_err!(runner.execute(query, None, None, None))
         .as_ref()
@@ -715,6 +715,7 @@ fn query_complexity() {
         )
         .unwrap(),
         None,
+        None,
     );
     let max_complexity = Some(1_010_100);
 
@@ -744,6 +745,7 @@ fn query_complexity() {
         )
         .unwrap(),
         None,
+        None,
     );
 
     // The extra introspection causes the complexity to go over.
@@ -776,6 +778,7 @@ async fn query_complexity_subscriptions() {
         )
         .unwrap(),
         None,
+        None,
     );
     let max_complexity = Some(1_010_100);
     let options = SubscriptionExecutionOptions {
@@ -813,6 +816,7 @@ async fn query_complexity_subscriptions() {
         )
         .unwrap(),
         None,
+        None,
     );
 
     let options = SubscriptionExecutionOptions {
@@ -841,6 +845,7 @@ fn instant_timeout() {
         Arc::new(api_test_schema()),
         graphql_parser::parse_query("query { musicians(first: 100) { name } }").unwrap(),
         None,
+        None,
     );
 
     match execute_subgraph_query_with_deadline(query, Some(Instant::now()))
@@ -1140,6 +1145,7 @@ async fn subscription_gets_result_even_without_events() {
         )
         .unwrap(),
         None,
+        None,
     );
 
     let options = SubscriptionExecutionOptions {

mock/src/store.rs

@@ -226,5 +226,7 @@ pub fn mock_store_with_users_subgraph() -> (Arc<MockStore>, SubgraphDeploymentId
             Ok(Arc::new(schema))
         });
 
+    store.expect_network_name().returning(|_| Ok(None));
+
     (Arc::new(store), subgraph_id)
 }

server/http/src/request.rs

@@ -9,12 +9,17 @@ use graph::prelude::*;
 pub struct GraphQLRequest {
     body: Bytes,
     schema: Arc<Schema>,
+    network: Option<String>,
 }
 
 impl GraphQLRequest {
     /// Creates a new GraphQLRequest future based on an HTTP request and a result sender.
-    pub fn new(body: Bytes, schema: Arc<Schema>) -> Self {
-        GraphQLRequest { body, schema }
+    pub fn new(body: Bytes, schema: Arc<Schema>, network: Option<String>) -> Self {
+        GraphQLRequest {
+            body,
+            schema,
+            network,
+        }
     }
 }
 
@@ -65,7 +70,12 @@ impl Future for GraphQLRequest {
             )),
         }?;
 
-        Ok(Async::Ready(Query::new(schema, document, variables)))
+        Ok(Async::Ready(Query::new(
+            schema,
+            document,
+            variables,
+            self.network.clone(),
+        )))
     }
 }
 
@@ -86,15 +96,16 @@ mod tests {
     fn rejects_invalid_json() {
         let schema =
             Schema::parse(EXAMPLE_SCHEMA, SubgraphDeploymentId::new("test").unwrap()).unwrap();
-        let request = GraphQLRequest::new(hyper::body::Bytes::from("!@#)%"), Arc::new(schema));
+        let request =
+            GraphQLRequest::new(hyper::body::Bytes::from("!@#)%"), Arc::new(schema), None);
         request.wait().expect_err("Should reject invalid JSON");
     }
 
     #[test]
     fn rejects_json_without_query_field() {
         let schema =
             Schema::parse(EXAMPLE_SCHEMA, SubgraphDeploymentId::new("test").unwrap()).unwrap();
-        let request = GraphQLRequest::new(hyper::body::Bytes::from("{}"), Arc::new(schema));
+        let request = GraphQLRequest::new(hyper::body::Bytes::from("{}"), Arc::new(schema), None);
         request
             .wait()
             .expect_err("Should reject JSON without query field");
@@ -104,8 +115,11 @@ mod tests {
     fn rejects_json_with_non_string_query_field() {
         let schema =
             Schema::parse(EXAMPLE_SCHEMA, SubgraphDeploymentId::new("test").unwrap()).unwrap();
-        let request =
-            GraphQLRequest::new(hyper::body::Bytes::from("{\"query\": 5}"), Arc::new(schema));
+        let request = GraphQLRequest::new(
+            hyper::body::Bytes::from("{\"query\": 5}"),
+            Arc::new(schema),
+            None,
+        );
         request
             .wait()
             .expect_err("Should reject JSON with a non-string query field");
@@ -118,6 +132,7 @@ mod tests {
         let request = GraphQLRequest::new(
             hyper::body::Bytes::from("{\"query\": \"foo\"}"),
             Arc::new(schema),
+            None,
         );
         request.wait().expect_err("Should reject broken queries");
     }
@@ -129,6 +144,7 @@ mod tests {
         let request = GraphQLRequest::new(
             hyper::body::Bytes::from("{\"query\": \"{ user { name } }\"}"),
             Arc::new(schema),
+            None,
         );
         let query = request.wait().expect("Should accept valid queries");
         assert_eq!(
@@ -150,6 +166,7 @@ mod tests {
                  }",
             ),
             Arc::new(schema),
+            None,
         );
         let query = request.wait().expect("Should accept null variables");
 
@@ -171,6 +188,7 @@ mod tests {
                  }",
             ),
             Arc::new(schema),
+            None,
         );
         request.wait().expect_err("Should reject non-map variables");
     }
@@ -190,6 +208,7 @@ mod tests {
                  }",
             ),
             Arc::new(schema),
+            None,
         );
         let query = request.wait().expect("Should accept valid queries");
 

server/http/src/service.rs

@@ -260,10 +260,17 @@ where
             }
         };
 
+        let network = match self.store.network_name(&id) {
+            Ok(network) => network,
+            Err(e) => {
+                return Err(GraphQLServerError::InternalError(e.to_string()));
+            }
+        };
+
         let start = Instant::now();
         hyper::body::to_bytes(request_body)
             .map_err(|_| GraphQLServerError::from("Failed to read request body"))
-            .and_then(move |body| GraphQLRequest::new(body, schema).compat())
+            .and_then(move |body| GraphQLRequest::new(body, schema, network).compat())
             .and_then(move |query| {
                 // Run the query using the query runner
                 tokio::task::block_in_place(|| {

server/index-node/src/request.rs

@@ -66,7 +66,7 @@ impl Future for IndexNodeRequest {
             )),
         }?;
 
-        Ok(Async::Ready(Query::new(schema, document, variables)))
+        Ok(Async::Ready(Query::new(schema, document, variables, None)))
     }
 }