graph/subgraph misusage errors (#459)

This commit adds the following errors:

* error when a non-federated graph is about to be overwritten by a subgraph
* error when running subgraph check on a federated graph
* error for attempts to introspect a subgraph on graphs which don't support _service

Co-authored-by: Irina Shestak <[email protected]>

Author: JakeDawkins

crates/rover-client/src/error.rs

@@ -129,4 +129,7 @@ pub enum RoverClientError {
     /// could not parse the latest version
     #[error("Could not get the latest release version")]
     UnparseableReleaseVersion,
+
+    #[error("This endpoint doesn't support subgraph introspection via the Query._service field")]
+    SubgraphIntrospectionNotAvailable,
 }

crates/rover-client/src/lib.rs

@@ -15,8 +15,8 @@ pub mod introspection;
 /// Module for client related errors.
 pub use error::RoverClientError;
 
-/// Module for actually querying studio
 #[allow(clippy::upper_case_acronyms)]
+/// Module for actually querying studio
 pub mod query;
 
 /// Module for getting release info

crates/rover-client/src/query/config/is_federated.graphql

@@ -0,0 +1,7 @@
+query IsFederatedGraph($graphId: ID!, $graphVariant: String!) {
+  service(id: $graphId) {
+    implementingServices(graphVariant: $graphVariant) {
+      __typename
+    }
+  }
+}

crates/rover-client/src/query/config/is_federated.rs

@@ -0,0 +1,49 @@
+// PublishPartialSchemaMutation
+use crate::blocking::StudioClient;
+use crate::RoverClientError;
+use graphql_client::*;
+
+#[derive(GraphQLQuery)]
+// The paths are relative to the directory where your `Cargo.toml` is located.
+// Both json and the GraphQL schema language are supported as sources for the schema
+#[graphql(
+    query_path = "src/query/config/is_federated.graphql",
+    schema_path = ".schema/schema.graphql",
+    response_derives = "PartialEq, Debug, Serialize, Deserialize",
+    deprecated = "warn"
+)]
+/// This struct is used to generate the module containing `Variables` and
+/// `ResponseData` structs.
+/// Snake case of this name is the mod name. i.e. publish_partial_schema_mutation
+pub struct IsFederatedGraph;
+
+#[derive(Debug, PartialEq)]
+pub struct IsFederatedGraphResponse {
+    pub result: bool,
+}
+
+pub fn run(
+    variables: is_federated_graph::Variables,
+    client: &StudioClient,
+) -> Result<IsFederatedGraphResponse, RoverClientError> {
+    let data = client.post::<IsFederatedGraph>(variables)?;
+    let is_federated_response = data.service.unwrap();
+    Ok(build_response(is_federated_response))
+}
+
+type FederatedResponse = is_federated_graph::IsFederatedGraphService;
+type ImplementingServices = is_federated_graph::IsFederatedGraphServiceImplementingServices;
+
+fn build_response(service: FederatedResponse) -> IsFederatedGraphResponse {
+    match service.implementing_services {
+        Some(typename) => match typename {
+            ImplementingServices::FederatedImplementingServices => {
+                IsFederatedGraphResponse { result: true }
+            }
+            ImplementingServices::NonFederatedImplementingService => {
+                IsFederatedGraphResponse { result: false }
+            }
+        },
+        None => IsFederatedGraphResponse { result: false },
+    }
+}

crates/rover-client/src/query/config/mod.rs

@@ -1,2 +1,5 @@
 /// runner for rover config whoami
 pub mod whoami;
+
+/// runner is_federated check
+pub mod is_federated;

crates/rover-client/src/query/subgraph/introspect.rs

@@ -24,8 +24,20 @@ pub fn run(
 ) -> Result<IntrospectionResponse, RoverClientError> {
     // let graph = variables.graph_id.clone();
     let variables = introspection_query::Variables {};
-    let response_data = client.post::<IntrospectionQuery>(variables, headers)?;
-    build_response(response_data)
+    let response_data = client.post::<IntrospectionQuery>(variables, headers);
+    match response_data {
+        Ok(data) => build_response(data),
+        Err(e) => {
+            // this is almost definitely a result of a graph not
+            // being federated, or not matching the federation spec
+            if e.to_string().contains("Cannot query field") {
+                Err(RoverClientError::SubgraphIntrospectionNotAvailable)
+            } else {
+                Err(e)
+            }
+        }
+    }
+    // build_response(response_data)
 }
 
 fn build_response(

src/command/subgraph/check.rs

@@ -2,8 +2,8 @@ use ansi_term::Colour::Red;
 use serde::Serialize;
 use structopt::StructOpt;
 
-use crate::Result;
-use rover_client::query::subgraph::check;
+use crate::{anyhow, error::RoverError, Result, Suggestion};
+use rover_client::query::{config::is_federated, subgraph::check};
 
 use crate::command::RoverStdout;
 use crate::utils::client::StudioClientConfig;
@@ -65,6 +65,24 @@ impl Check {
 
         let sdl = load_schema_from_flag(&self.schema, std::io::stdin())?;
 
+        // This response is used to check whether or not the current graph is federated.
+        let federated_response = is_federated::run(
+            is_federated::is_federated_graph::Variables {
+                graph_id: self.graph.name.clone(),
+                graph_variant: self.graph.variant.clone(),
+            },
+            &client,
+        )?;
+
+        // We don't want to run subgraph check on a non-federated graph, so
+        // return an error and recommend running graph check instead.
+        if !federated_response.result {
+            let err = anyhow!("Not able to run subgraph check on a non-federated graph.");
+            let mut err = RoverError::new(err);
+            err.set_suggestion(Suggestion::UseFederatedGraph);
+            return Err(err);
+        }
+
         let partial_schema = check::check_partial_schema_query::PartialSchemaInput {
             sdl: Some(sdl),
             // we never need to send the hash since the back end computes it from SDL

src/command/subgraph/publish.rs

@@ -2,16 +2,22 @@ use ansi_term::Colour::{Cyan, Red, Yellow};
 use serde::Serialize;
 use structopt::StructOpt;
 
-use crate::command::RoverStdout;
-use crate::utils::{
-    client::StudioClientConfig,
-    git::GitContext,
-    loaders::load_schema_from_flag,
-    parsers::{parse_graph_ref, parse_schema_source, GraphRef, SchemaSource},
+use crate::{anyhow, Result};
+use crate::{command::RoverStdout, error::RoverError};
+use crate::{
+    utils::{
+        client::StudioClientConfig,
+        git::GitContext,
+        loaders::load_schema_from_flag,
+        parsers::{parse_graph_ref, parse_schema_source, GraphRef, SchemaSource},
+    },
+    Suggestion,
 };
-use crate::Result;
 
-use rover_client::query::subgraph::publish::{self, PublishPartialSchemaResponse};
+use rover_client::query::{
+    config::is_federated,
+    subgraph::publish::{self, PublishPartialSchemaResponse},
+};
 
 #[derive(Debug, Serialize, StructOpt)]
 pub struct Publish {
@@ -37,6 +43,10 @@ pub struct Publish {
     #[serde(skip_serializing)]
     subgraph: String,
 
+    /// Indicate whether to convert a non-federated graph into a subgraph
+    #[structopt(short, long)]
+    convert: bool,
+
     /// Url of a running subgraph that a gateway can route operations to
     /// (often a deployed subgraph). May be left empty ("") or a placeholder url
     /// if not running a gateway in managed federation mode
@@ -64,6 +74,25 @@ impl Publish {
 
         tracing::debug!("Schema Document to publish:\n{}", &schema_document);
 
+        // This response is used to check whether or not the current graph is federated.
+        let federated_response = is_federated::run(
+            is_federated::is_federated_graph::Variables {
+                graph_id: self.graph.name.clone(),
+                graph_variant: self.graph.variant.clone(),
+            },
+            &client,
+        )?;
+
+        // We don't want to implicitly convert non-federated graph to subgraphs.
+        // Error here if no --convert flag is passed _and_ the current context
+        // is non-federated. Add a suggestion to require a --convert flag.
+        if !federated_response.result && !self.convert {
+            let err = anyhow!("Could not publish a subgraph to a non-federated graph.");
+            let mut err = RoverError::new(err);
+            err.set_suggestion(Suggestion::ConvertGraphToSubgraph);
+            return Err(err);
+        }
+
         let publish_response = publish::run(
             publish::publish_partial_schema_mutation::Variables {
                 graph_id: self.graph.name.clone(),
@@ -81,12 +110,12 @@ impl Publish {
             &client,
         )?;
 
-        handle_response(publish_response, &self.subgraph, &self.graph.name);
+        handle_publish_response(publish_response, &self.subgraph, &self.graph.name);
         Ok(RoverStdout::None)
     }
 }
 
-fn handle_response(response: PublishPartialSchemaResponse, subgraph: &str, graph: &str) {
+fn handle_publish_response(response: PublishPartialSchemaResponse, subgraph: &str, graph: &str) {
     if response.service_was_created {
         eprintln!(
             "A new subgraph called '{}' for the '{}' graph was created",
@@ -120,7 +149,7 @@ fn handle_response(response: PublishPartialSchemaResponse, subgraph: &str, graph
 
 #[cfg(test)]
 mod tests {
-    use super::{handle_response, PublishPartialSchemaResponse};
+    use super::{handle_publish_response, PublishPartialSchemaResponse};
 
     // this test is a bit weird, since we can't test the output. We just verify it
     // doesn't error
@@ -133,7 +162,7 @@ mod tests {
             composition_errors: None,
         };
 
-        handle_response(response, "accounts", "my-graph");
+        handle_publish_response(response, "accounts", "my-graph");
     }
 
     #[test]
@@ -148,7 +177,7 @@ mod tests {
             ]),
         };
 
-        handle_response(response, "accounts", "my-graph");
+        handle_publish_response(response, "accounts", "my-graph");
     }
 
     // TODO: test the actual output of the logs whenever we do design work

src/error/metadata/mod.rs

@@ -58,7 +58,8 @@ impl From<&mut anyhow::Error> for Metadata {
                 RoverClientError::InvalidSeverity => {
                     (Some(Suggestion::SubmitIssue), Some(Code::E006))
                 }
-                RoverClientError::ExpectedFederatedGraph { graph: _ } => {
+                RoverClientError::SubgraphIntrospectionNotAvailable
+                | RoverClientError::ExpectedFederatedGraph { graph: _ } => {
                     (Some(Suggestion::UseFederatedGraph), Some(Code::E007))
                 }
                 RoverClientError::NoSchemaForVariant {

src/error/metadata/suggestion.rs

@@ -30,6 +30,7 @@ pub enum Suggestion {
     ProperKey,
     NewUserNoProfiles,
     CheckServerConnection,
+    ConvertGraphToSubgraph,
 }
 
 impl Display for Suggestion {
@@ -66,7 +67,7 @@ impl Display for Suggestion {
                 format!("Try resolving the composition errors in your subgraph(s), and publish them with the {} command.", Yellow.normal().paint("`rover subgraph publish`"))
             }
             Suggestion::UseFederatedGraph => {
-                "Try running the command on a valid federated graph.".to_string()
+                "Try running the command on a valid federated graph or use the appropriate `rover graph` command instead of `rover subgraph`.".to_string()
             }
             Suggestion::CheckGraphNameAndAuth => {
                 "Make sure your graph name is typed correctly, and that your API key is valid. (Are you using the right profile?)".to_string()
@@ -124,7 +125,8 @@ impl Display for Suggestion {
                 )
             }
             Suggestion::Adhoc(msg) => msg.to_string(),
-            Suggestion::CheckServerConnection => "Make sure the endpoint accepting connections is spelled correctly".to_string()
+            Suggestion::CheckServerConnection => "Make sure the endpoint accepting connections is spelled correctly".to_string(),
+            Suggestion::ConvertGraphToSubgraph => "If you are sure you want to convert a non-federated graph to a subgraph, you can re-run the same command with a `--convert` flag.".to_string(),
 
 
         };