Wire up rover subgraph preview, swap subgraph delete to use it

Adds `rover subgraph preview`: composes a preview supergraph from
hypothetical subgraph changes (add/update/remove, via --subgraph-changes)
with optional contract filters, without publishing anything. Same
async/--build-id/poll UX as `rover contract preview`.

Also swaps `rover subgraph delete`'s pre-confirmation build-error check from
a synchronous removeImplementingServiceAndTriggerComposition(dryRun: true)
call to the new async compose-and-filter-preview path (delete::check).
Holding that dry-run mutation open for the duration of composition blocked
the server connection and risked timing out on large supergraphs -- the
same reason this whole feature is async. Bundled with this PR rather than
the subgraph-impl PR because it's a breaking change to the existing
SubgraphDeleteInput/runner shape that only this PR's CLI change consumes;
splitting it further would leave an intermediate commit that doesn't build.

Also brings the command's print calls up to date with the simplified
rover-print Print::print signature that landed on main after this branch
was first written.

Author: sirdodger

CHANGELOG.md

@@ -32,6 +32,12 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
   `rover auth logout` revokes the OAuth session stored by `rover auth login` for the given `--profile` (or "default") — the access token and, if one was issued, the refresh token (RFC 7009) — then removes the local credential. Revocation is best-effort: if the OAuth server can't be reached, Rover still clears the local credential and warns instead of leaving you stuck "logged in" locally. Only meaningful for profiles logged in via `rover auth login`; running it against a profile holding a Personal API Key (from `rover config auth`) errors and points you at `rover config delete` instead. Only compiled in when built with `--features oauth`, matching `rover auth login`.
 
+- **Add `rover subgraph preview` - @sirdodger**
+
+  `rover subgraph preview` composes a preview supergraph from hypothetical subgraph changes described by a `--subgraph-changes` YAML file (add/update a subgraph's schema or routing URL, or mark one `remove: true`), with optional include/exclude/hide-unreachable-types contract filters, without publishing anything. It runs asynchronously on the server; by default Rover polls until the build completes (or `APOLLO_CHECKS_TIMEOUT_SECONDS` elapses), or pass `--async` to just start the build and check on it later with `--build-id`. Exits non-zero if composition or filtering fails.
+
+  `rover subgraph delete`'s pre-confirmation build-error check now runs through this same async preview path instead of a synchronous dry-run mutation, avoiding a long-held server connection (and its timeout risk) while previewing the deletion of a subgraph from a large supergraph.
+
 ## 🐛 Fixes
 
 - **Surface the underlying GraphQL errors when a response has no `data` field - @sirdodger**

crates/rover-client/src/operations/subgraph/delete/delete_mutation.graphql

@@ -2,13 +2,11 @@ mutation SubgraphDeleteMutation(
   $graph_id: ID!
   $variant: String!
   $subgraph: String!
-  $dry_run: Boolean!
 ) {
   graph(id: $graph_id) {
     removeImplementingServiceAndTriggerComposition(
       graphVariant: $variant
       name: $subgraph
-      dryRun: $dry_run
     ) {
       errors {
         message

crates/rover-client/src/operations/subgraph/delete/mod.rs

@@ -1,5 +1,5 @@
 mod runner;
 mod types;
 
-pub use runner::run;
+pub use runner::{check, run};
 pub use types::{SubgraphDeleteInput, SubgraphDeleteResponse};

crates/rover-client/src/operations/subgraph/delete/runner.rs

@@ -2,7 +2,15 @@ use apollo_federation_types::rover::{BuildError, BuildErrors};
 use graphql_client::*;
 use rover_studio::types::GraphRef;
 
-use crate::{blocking::StudioClient, operations::subgraph::delete::types::*, RoverClientError};
+use crate::{
+    blocking::StudioClient,
+    operations::subgraph::{
+        delete::types::*,
+        preview::{self, ComposeAndFilterPreviewInput, SubgraphChange},
+    },
+    shared::AsyncBuildStatus,
+    RoverClientError,
+};
 
 #[derive(GraphQLQuery)]
 // The paths are relative to the directory where your `Cargo.toml` is located.
@@ -30,6 +38,37 @@ pub async fn run(
     Ok(build_response(data))
 }
 
+/// Preview the composition impact of deleting a subgraph, via the same async
+/// `composeAndFilterPreviewAsync` build `rover subgraph preview` uses.
+pub async fn check(
+    input: SubgraphDeleteInput,
+    client: &StudioClient,
+    checks_timeout_seconds: u64,
+) -> Result<SubgraphDeleteResponse, RoverClientError> {
+    let preview_response = preview::run(
+        ComposeAndFilterPreviewInput {
+            graph_ref: input.graph_ref,
+            filter_config: None,
+            subgraph_changes: vec![SubgraphChange {
+                name: input.subgraph,
+                info: None,
+            }],
+        },
+        client,
+        checks_timeout_seconds,
+    )
+    .await?;
+
+    Ok(SubgraphDeleteResponse {
+        supergraph_was_updated: preview_response.status == AsyncBuildStatus::Success,
+        build_errors: preview_response
+            .errors
+            .into_iter()
+            .map(|message| BuildError::composition_error(None, Some(message), None, None))
+            .collect(),
+    })
+}
+
 fn get_delete_data_from_response(
     response_data: subgraph_delete_mutation::ResponseData,
     graph_ref: GraphRef,
@@ -60,10 +99,143 @@ fn build_response(response: MutationComposition) -> SubgraphDeleteResponse {
 
 #[cfg(test)]
 mod tests {
+    use std::time::Duration;
+
+    use houston::{Credential, CredentialOrigin};
+    use httpmock::prelude::*;
+    use reqwest::Client as ReqwestClient;
     use serde_json::json;
 
     use super::*;
 
+    fn test_client(server_url: &str) -> StudioClient {
+        StudioClient::new(
+            Credential {
+                api_key: "test".to_string(),
+                origin: CredentialOrigin::EnvVar,
+                expires_at: None,
+            },
+            server_url,
+            "test-version",
+            false,
+            ReqwestClient::new(),
+            Duration::from_secs(1),
+        )
+    }
+
+    fn test_input() -> SubgraphDeleteInput {
+        SubgraphDeleteInput {
+            graph_ref: "test-graph@test-variant".parse().unwrap(),
+            subgraph: "accounts".to_string(),
+        }
+    }
+
+    #[tokio::test]
+    async fn check_reports_success_when_composition_succeeds() {
+        let server = MockServer::start_async().await;
+        server.mock(|when, then| {
+            when.method(POST)
+                .body_includes("ComposeAndFilterPreviewAsyncMutation");
+            then.status(200).json_body(json!({
+                "data": { "graph": { "variant": {
+                    "composeAndFilterPreviewAsync": { "buildID": "build-123" }
+                } } }
+            }));
+        });
+        server.mock(|when, then| {
+            when.method(POST)
+                .body_includes("ComposeAndFilterPreviewStatusQuery");
+            then.status(200).json_body(json!({
+                "data": { "graph": { "variant": {
+                    "composeAndFilterPreviewStatus": { "__typename": "ComposeAndFilterPreviewSuccess" }
+                } } }
+            }));
+        });
+        server.mock(|when, then| {
+            when.method(POST)
+                .body_includes("ComposeAndFilterPreviewResultQuery");
+            then.status(200).json_body(json!({
+                "data": { "graph": { "variant": {
+                    "composeAndFilterPreviewStatus": {
+                        "__typename": "ComposeAndFilterPreviewSuccess",
+                        "composeResults": {
+                            "apiSchemaDocument": "type Query { hi: String }",
+                            "supergraphSchemaDocument": "supergraph"
+                        },
+                        "filterResults": null
+                    }
+                } } }
+            }));
+        });
+
+        let response = check(test_input(), &test_client(&server.url("/")), 30)
+            .await
+            .unwrap();
+
+        assert_eq!(
+            response,
+            SubgraphDeleteResponse {
+                supergraph_was_updated: true,
+                build_errors: BuildErrors::new(),
+            }
+        );
+    }
+
+    #[tokio::test]
+    async fn check_reports_build_errors_when_composition_fails() {
+        let server = MockServer::start_async().await;
+        server.mock(|when, then| {
+            when.method(POST)
+                .body_includes("ComposeAndFilterPreviewAsyncMutation");
+            then.status(200).json_body(json!({
+                "data": { "graph": { "variant": {
+                    "composeAndFilterPreviewAsync": { "buildID": "build-123" }
+                } } }
+            }));
+        });
+        server.mock(|when, then| {
+            when.method(POST)
+                .body_includes("ComposeAndFilterPreviewStatusQuery");
+            then.status(200).json_body(json!({
+                "data": { "graph": { "variant": {
+                    "composeAndFilterPreviewStatus": { "__typename": "ComposeAndFilterPreviewComposeFailure" }
+                } } }
+            }));
+        });
+        server.mock(|when, then| {
+            when.method(POST)
+                .body_includes("ComposeAndFilterPreviewResultQuery");
+            then.status(200).json_body(json!({
+                "data": { "graph": { "variant": {
+                    "composeAndFilterPreviewStatus": {
+                        "__typename": "ComposeAndFilterPreviewComposeFailure",
+                        "composeErrors": [
+                            { "message": "accounts is required by products", "code": "REQUIRED_SUBGRAPH", "failedStep": "VALIDATE" }
+                        ]
+                    }
+                } } }
+            }));
+        });
+
+        let response = check(test_input(), &test_client(&server.url("/")), 30)
+            .await
+            .unwrap();
+
+        assert_eq!(
+            response,
+            SubgraphDeleteResponse {
+                supergraph_was_updated: false,
+                build_errors: vec![BuildError::composition_error(
+                    None,
+                    Some("accounts is required by products".to_string()),
+                    None,
+                    None
+                )]
+                .into(),
+            }
+        );
+    }
+
     #[test]
     fn get_delete_data_from_response_works() {
         let json_response = json!({

crates/rover-client/src/operations/subgraph/delete/types.rs

@@ -14,7 +14,6 @@ pub(crate) type MutationCompositionErrors = subgraph_delete_mutation::SubgraphDe
 pub struct SubgraphDeleteInput {
     pub graph_ref: GraphRef,
     pub subgraph: String,
-    pub dry_run: bool,
 }
 
 /// this struct contains all the info needed to print the result of the delete.
@@ -36,7 +35,6 @@ impl From<SubgraphDeleteInput> for MutationVariables {
             graph_id,
             variant,
             subgraph: input.subgraph,
-            dry_run: input.dry_run,
         }
     }
 }

src/command/subgraph/delete.rs

@@ -28,7 +28,11 @@ pub struct Delete {
 }
 
 impl Delete {
-    pub async fn run(&self, client_config: StudioClientConfig) -> RoverResult<RoverOutput> {
+    pub async fn run(
+        &self,
+        client_config: StudioClientConfig,
+        checks_timeout_seconds: u64,
+    ) -> RoverResult<RoverOutput> {
         let client = client_config.get_authenticated_client(&self.profile)?;
         eprintln!(
             "Checking for build errors resulting from deleting subgraph {} from {} using credentials from the {} profile.",
@@ -40,23 +44,21 @@ impl Delete {
         // this is probably the normal path -- preview a subgraph delete
         // and make the user confirm it manually.
         if !self.confirm {
-            let dry_run = true;
-            // run delete with dryRun, so we can preview build errors
-            let delete_dry_run_response = delete::run(
+            let delete_check_response = delete::check(
                 SubgraphDeleteInput {
                     graph_ref: self.graph.graph_ref.clone(),
                     subgraph: self.subgraph.subgraph_name.clone(),
-                    dry_run,
                 },
                 &client,
+                checks_timeout_seconds,
             )
             .await?;
 
             RoverOutput::SubgraphDeleteResponse {
                 graph_ref: self.graph.graph_ref.clone(),
                 subgraph: self.subgraph.subgraph_name.clone(),
-                dry_run,
-                delete_response: delete_dry_run_response,
+                dry_run: true,
+                delete_response: delete_check_response,
             }
             .get_stdout()?;
 
@@ -67,13 +69,10 @@ impl Delete {
             }
         }
 
-        let dry_run = false;
-
         let delete_response = delete::run(
             SubgraphDeleteInput {
                 graph_ref: self.graph.graph_ref.clone(),
                 subgraph: self.subgraph.subgraph_name.clone(),
-                dry_run,
             },
             &client,
         )
@@ -82,7 +81,7 @@ impl Delete {
         Ok(RoverOutput::SubgraphDeleteResponse {
             graph_ref: self.graph.graph_ref.clone(),
             subgraph: self.subgraph.subgraph_name.clone(),
-            dry_run,
+            dry_run: false,
             delete_response,
         })
     }

src/command/subgraph/mod.rs

@@ -4,6 +4,7 @@ mod fetch;
 pub mod introspect;
 mod lint;
 mod list;
+mod preview;
 mod publish;
 
 use clap::Parser;
@@ -20,17 +21,20 @@ pub struct Subgraph {
 
 #[derive(Debug, Serialize, Parser)]
 pub enum Command {
-    /// Check for build errors and breaking changes caused by an updated subgraph schema
-    /// against the federated graph in the Apollo graph registry
+    /// Check for build errors and breaking changes caused by an updated
+    /// subgraph schema against the federated graph in the Apollo graph
+    /// registry
     Check(check::Check),
 
-    /// Delete a subgraph from the Apollo registry and trigger composition in the graph router
+    /// Delete a subgraph from the Apollo registry and trigger composition in
+    /// the graph router
     Delete(delete::Delete),
 
     /// Fetch a subgraph schema from the Apollo graph registry
     Fetch(fetch::Fetch),
 
-    /// Introspect a running subgraph endpoint to retrieve its schema definition (SDL)
+    /// Introspect a running subgraph endpoint to retrieve its schema
+    /// definition (SDL)
     Introspect(introspect::Introspect),
 
     /// Lint a subgraph schema
@@ -39,7 +43,12 @@ pub enum Command {
     /// List all subgraphs for a federated graph
     List(list::List),
 
-    /// Publish an updated subgraph schema to the Apollo graph registry and trigger composition in the graph router
+    /// Preview the supergraph schema (and optionally a contract filter)
+    /// produced by hypothetical subgraph changes (without publishing them)
+    Preview(preview::Preview),
+
+    /// Publish an updated subgraph schema to the Apollo graph registry and
+    /// trigger composition in the graph router
     Publish(publish::Publish),
 }
 
@@ -57,7 +66,7 @@ impl Subgraph {
                     .run(client_config, git_context, checks_timeout_seconds)
                     .await
             }
-            Command::Delete(command) => command.run(client_config).await,
+            Command::Delete(command) => command.run(client_config, checks_timeout_seconds).await,
             Command::Introspect(command) => {
                 command
                     .run(
@@ -70,6 +79,15 @@ impl Subgraph {
             Command::Fetch(command) => command.run(client_config).await,
             Command::Lint(command) => command.run(client_config).await,
             Command::List(command) => command.run(client_config).await,
+            Command::Preview(command) => {
+                command
+                    .run(
+                        client_config,
+                        checks_timeout_seconds,
+                        &rover_print::print::stderr::default(),
+                    )
+                    .await
+            }
             Command::Publish(command) => {
                 command
                     .run(client_config, git_context, checks_timeout_seconds)