error when a non-federated graph is about to be overwritten by a subgraph

Author: lrlna

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;

installers/npm/package-lock.json

@@ -33,6 +33,6 @@
     "console.table": "^0.10.0"
   },
   "devDependencies": {
-    "prettier": "^2.2.1"
+    "prettier": "^2.3.0"
   }
 }

installers/npm/package.json

@@ -2,16 +2,19 @@ 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::Result;
+use crate::{anyhow, Result};
+use crate::{command::RoverStdout, error::RoverError};
 
-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 +40,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 +71,24 @@ 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 {
+            return Err(RoverError::new(anyhow!(
+                "Could not publish a subgraph to a non-federated graph."
+            )));
+        }
+
         let publish_response = publish::run(
             publish::publish_partial_schema_mutation::Variables {
                 graph_id: self.graph.name.clone(),
@@ -81,12 +106,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 +145,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 +158,7 @@ mod tests {
             composition_errors: None,
         };
 
-        handle_response(response, "accounts", "my-graph");
+        handle_publish_response(response, "accounts", "my-graph");
     }
 
     #[test]
@@ -148,7 +173,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