Wire-in supergraph config resolver

src/command/supergraph/compose/do_compose.rs

@@ -1,3 +1,4 @@
+use std::env::current_dir;
 use std::{fs::File, io::Write, process::Command, str};
 
 use anyhow::{anyhow, Context};
@@ -13,10 +14,12 @@ use derive_getters::Getters;
 use semver::Version;
 use serde::Serialize;
 use std::io::Read;
+use tempfile::NamedTempFile;
 
 use rover_client::shared::GraphRef;
 use rover_client::RoverClientError;
 
+use crate::composition::supergraph::config::SupergraphConfigResolver;
 use crate::options::ProfileOpt;
 use crate::utils::supergraph_config::get_supergraph_config;
 use crate::utils::{client::StudioClientConfig, parsers::FileDescriptorType};
@@ -126,11 +129,41 @@ impl Compose {
     ) -> RoverResult<RoverOutput> {
         #[cfg(debug_assertions)]
         if self.opts.watch {
-            let mut runner = crate::composition::runner::Runner::new(&client_config, &self.opts);
             let profile = ProfileOpt {
                 profile_name: "default".to_string(),
             };
-            runner.run(&profile).await;
+            let supergraph_config_root = if let Some(FileDescriptorType::File(file_path)) =
+                &self.opts.supergraph_config_source.supergraph_yaml
+            {
+                file_path
+                    .parent()
+                    .ok_or_else(|| {
+                        anyhow!("Could not get the parent directory of ({})", file_path)
+                    })?
+                    .to_path_buf()
+            } else {
+                Utf8PathBuf::try_from(current_dir()?)?
+            };
+            let studio_client = client_config.get_authenticated_client(&profile)?;
+            let internal_supergraph_config_path =
+                Utf8PathBuf::from_path_buf(NamedTempFile::new()?.into_temp_path().to_path_buf())
+                    .map_err(|err| {
+                        anyhow!("Unable to convert PathBuf ({:?}) to Utf8PathBuf", err)
+                    })?;
+            let supergraph_config = SupergraphConfigResolver::new()
+                .load_from_file_descriptor(
+                    self.opts.supergraph_config_source.supergraph_yaml.as_ref(),
+                )?
+                .load_remote_subgraphs(
+                    &studio_client,
+                    self.opts.supergraph_config_source.graph_ref.as_ref(),
+                )
+                .await?
+                .lazily_resolve_subgraphs(&supergraph_config_root)
+                .await?
+                .write(internal_supergraph_config_path)?;
+            let runner = crate::composition::runner::Runner::new(supergraph_config);
+            runner.run().await?;
             return Ok(RoverOutput::EmptySuccess);
         }
         let mut supergraph_config = get_supergraph_config(

src/command/supergraph/compose/mod.rs

@@ -8,7 +8,7 @@ pub(crate) use no_compose::Compose;
 mod do_compose;
 
 #[cfg(feature = "composition-js")]
-pub(crate) use do_compose::{Compose, SupergraphComposeOpts};
+pub(crate) use do_compose::Compose;
 
 use apollo_federation_types::build::BuildHint;
 

src/composition/mod.rs

@@ -16,8 +16,6 @@
     watcher::{router_config::RouterConfigMessage, supergraph_config::SupergraphConfigDiff},
 };
 
-use self::supergraph::config::FinalSupergraphConfig;
-
 pub mod events;
 pub mod runner;
 pub mod supergraph;
@@ -55,19 +53,19 @@
 }
 
 // NB: this is where we'll contain the logic for kicking off watchers
 struct Composition {
     supergraph_binary: SupergraphBinary,
     supergraph_config_events: Option<InputEvent>,
     router_config_events: Option<InputEvent>,
 }
 
 enum InputEvent {
     SupergraphConfig(BoxStream<'static, SupergraphConfigDiff>),
     RouterConfig(BoxStream<'static, RouterConfigMessage>),
 }
 
 impl Composition {
     fn new(supergraph_binary: SupergraphBinary) -> Self {
         Self {
             supergraph_binary,
             supergraph_config_events: None,
@@ -107,7 +105,7 @@
     }
 }
 
 struct WatchResultBetterName {
     abort_handle: AbortHandle,
     composition_events: UnboundedReceiverStream<CompositionEvent>,
 }
@@ -135,7 +133,7 @@
                     InputEvent::SupergraphConfig(mut events) => {
                         while let Some(event) = events.next().await {
                             sender.send(CompositionEvent::Started);
                             let current_supergraph_config = event.current();
 
                             // TODO: write current_supergraph_config to a path
                             match self.supergraph_binary.compose(&Utf8PathBuf::new()).await {

src/composition/runner.rs

@@ -1,11 +1,9 @@
-use anyhow::anyhow;
 use apollo_federation_types::config::SupergraphConfig;
 use futures::stream::StreamExt;
 use rover_std::errln;
 use tokio::task::JoinHandle;
 
 use crate::{
-    command::supergraph::compose::SupergraphComposeOpts,
     composition::watchers::{
         subtask::{Subtask, SubtaskRunUnit},
         watcher::{
@@ -14,53 +12,38 @@ use crate::{
             supergraph_config::SupergraphConfigWatcher,
         },
     },
-    options::ProfileOpt,
-    utils::{client::StudioClientConfig, supergraph_config::get_supergraph_config},
-    RoverError, RoverResult,
+    RoverResult,
 };
 
+use super::supergraph::config::FinalSupergraphConfig;
+
 // TODO: handle retry flag for subgraphs (see rover dev help)
 pub struct Runner {
-    client_config: StudioClientConfig,
-    supergraph_compose_opts: SupergraphComposeOpts,
+    supergraph_config: FinalSupergraphConfig,
 }
 
 impl Runner {
-    pub fn new(
-        client_config: &StudioClientConfig,
-        supergraph_compose_opts: &SupergraphComposeOpts,
-    ) -> Self {
+    pub fn new(final_supergraph_config: FinalSupergraphConfig) -> Self {
         Self {
-            client_config: client_config.clone(),
-            supergraph_compose_opts: supergraph_compose_opts.clone(),
+            supergraph_config: final_supergraph_config,
         }
     }
 
-    pub async fn run(&mut self, profile: &ProfileOpt) -> RoverResult<()> {
-        let supergraph_config = self.load_supergraph_config(profile).await?;
-
+    pub async fn run(&self) -> RoverResult<()> {
         // Start supergraph and subgraph watchers.
-        let handles = self.start_config_watchers(supergraph_config.clone());
+        let handles = self.start_config_watchers();
 
         futures::future::join_all(handles).await;
 
         Ok(())
     }
 
-    fn start_config_watchers(&self, supergraph_config: SupergraphConfig) -> Vec<JoinHandle<()>> {
+    fn start_config_watchers(&self) -> Vec<JoinHandle<()>> {
+        let supergraph_config: SupergraphConfig = self.supergraph_config.clone().into();
         let mut futs = vec![];
 
         // Create a new supergraph config file watcher.
-        let f = FileWatcher::new(
-            self.supergraph_compose_opts
-                .supergraph_config_source()
-                .supergraph_yaml()
-                .as_ref()
-                .unwrap()
-                .to_path_buf()
-                .unwrap()
-                .clone(),
-        );
+        let f = FileWatcher::new(self.supergraph_config.path().clone());
         let watcher = SupergraphConfigWatcher::new(f, supergraph_config.clone());
 
         // Create and run the file watcher in a sub task.
@@ -101,22 +84,4 @@ impl Runner {
 
         futs
     }
-
-    async fn load_supergraph_config(&self, profile: &ProfileOpt) -> RoverResult<SupergraphConfig> {
-        get_supergraph_config(
-            self.supergraph_compose_opts
-                .supergraph_config_source()
-                .graph_ref(),
-            self.supergraph_compose_opts
-                .supergraph_config_source()
-                .supergraph_yaml(),
-            self.supergraph_compose_opts.federation_version().as_ref(),
-            self.client_config.clone(),
-            profile,
-            false,
-        )
-        .await
-        .map_err(|err| RoverError::new(anyhow!("error loading supergraph config: {err}")))?
-        .ok_or_else(|| RoverError::new(anyhow!("Why is supergraph config None?")))
-    }
 }

src/composition/supergraph/binary.rs

@@ -6,15 +6,14 @@
 };
 use async_trait::async_trait;
 use camino::Utf8PathBuf;
-use derive_getters::Getters;
 use tap::TapFallible;
 
 use crate::{
     composition::{CompositionError, CompositionSuccess},
     utils::effect::{exec::ExecCommand, read_file::ReadFile},
 };
 
-use super::{config::FinalSupergraphConfig, version::SupergraphVersion};
+use super::version::SupergraphVersion;
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum OutputTarget {
@@ -73,7 +72,7 @@
 
 // TODO:
 impl From<rover_std::RoverStdError> for CompositionError {
     fn from(value: rover_std::RoverStdError) -> Self {
         todo!()
     }
 }
@@ -85,7 +84,7 @@
 }
 
 impl SupergraphBinary {
     fn new(exe: Utf8PathBuf, version: SupergraphVersion, output_target: OutputTarget) -> Self {
         Self {
             exe,
             version: version.clone(),

src/composition/supergraph/config/mod.rs

@@ -41,13 +41,13 @@ mod state {
 
 use state::LoadSupergraphConfig;
 
-pub struct IntermediateSupergraphConfig<State> {
+pub struct SupergraphConfigResolver<State> {
     state: State,
 }
 
-impl<T> IntermediateSupergraphConfig<T> {
-    pub fn new() -> IntermediateSupergraphConfig<LoadSupergraphConfig> {
-        IntermediateSupergraphConfig {
+impl SupergraphConfigResolver<LoadSupergraphConfig> {
+    pub fn new() -> SupergraphConfigResolver<LoadSupergraphConfig> {
+        SupergraphConfigResolver {
             state: LoadSupergraphConfig,
         }
     }
@@ -61,11 +61,11 @@ pub enum LoadSupergraphConfigError {
     ReadFileDescriptor(RoverError),
 }
 
-impl IntermediateSupergraphConfig<LoadSupergraphConfig> {
+impl SupergraphConfigResolver<LoadSupergraphConfig> {
     pub fn load_from_file_descriptor(
         self,
-        file_descriptor_type: Option<FileDescriptorType>,
-    ) -> Result<IntermediateSupergraphConfig<LoadRemoteSubgraphs>, LoadSupergraphConfigError> {
+        file_descriptor_type: Option<&FileDescriptorType>,
+    ) -> Result<SupergraphConfigResolver<LoadRemoteSubgraphs>, LoadSupergraphConfigError> {
         if let Some(file_descriptor_type) = file_descriptor_type {
             let supergraph_config = file_descriptor_type
                 .read_file_descriptor("supergraph config", &mut std::io::stdin())
@@ -74,13 +74,13 @@ impl IntermediateSupergraphConfig<LoadSupergraphConfig> {
                     SupergraphConfig::new_from_yaml(&contents)
                         .map_err(LoadSupergraphConfigError::SupergraphConfig)
                 })?;
-            Ok(IntermediateSupergraphConfig {
+            Ok(SupergraphConfigResolver {
                 state: LoadRemoteSubgraphs {
                     supergraph_config: Some(supergraph_config),
                 },
             })
         } else {
-            Ok(IntermediateSupergraphConfig {
+            Ok(SupergraphConfigResolver {
                 state: LoadRemoteSubgraphs {
                     supergraph_config: None,
                 },
@@ -92,23 +92,23 @@ impl IntermediateSupergraphConfig<LoadSupergraphConfig> {
 #[derive(thiserror::Error, Debug)]
 pub enum LoadRemoteSubgraphsError {
     #[error(transparent)]
-    FetchRemoteSubgraphsError(Box<dyn std::error::Error>),
+    FetchRemoteSubgraphsError(Box<dyn std::error::Error + Send + Sync>),
 }
 
-impl IntermediateSupergraphConfig<LoadRemoteSubgraphs> {
+impl SupergraphConfigResolver<LoadRemoteSubgraphs> {
     pub async fn load_remote_subgraphs(
         self,
         fetch_remote_subgraphs_impl: &impl FetchRemoteSubgraphs,
         graph_ref: Option<&GraphRef>,
-    ) -> Result<IntermediateSupergraphConfig<ResolveSubgraphs>, LoadRemoteSubgraphsError> {
+    ) -> Result<SupergraphConfigResolver<ResolveSubgraphs>, LoadRemoteSubgraphsError> {
         if let Some(graph_ref) = graph_ref {
             let remote_supergraph_config = fetch_remote_subgraphs_impl
                 .fetch_remote_subgraphs(graph_ref)
                 .await
                 .map_err(|err| {
                     LoadRemoteSubgraphsError::FetchRemoteSubgraphsError(Box::new(err))
                 })?;
-            Ok(IntermediateSupergraphConfig {
+            Ok(SupergraphConfigResolver {
                 state: ResolveSubgraphs {
                     supergraph_config: self
                         .state
@@ -121,7 +121,7 @@ impl IntermediateSupergraphConfig<LoadRemoteSubgraphs> {
                 },
             })
         } else {
-            Ok(IntermediateSupergraphConfig {
+            Ok(SupergraphConfigResolver {
                 state: ResolveSubgraphs {
                     supergraph_config: self.state.supergraph_config,
                 },
@@ -138,13 +138,13 @@ pub enum ResolveSupergraphConfigError {
     ResolveSubgraphs(Vec<ResolveSubgraphError>),
 }
 
-impl IntermediateSupergraphConfig<ResolveSubgraphs> {
+impl SupergraphConfigResolver<ResolveSubgraphs> {
     pub async fn fully_resolve_subgraphs<CTX>(
         self,
         introspect_subgraph_impl: &impl IntrospectSubgraph,
         fetch_remote_subgraph_impl: &impl FetchRemoteSubgraph,
         supergraph_config_root: &Utf8PathBuf,
-    ) -> Result<IntermediateSupergraphConfig<Writing>, ResolveSupergraphConfigError>
+    ) -> Result<SupergraphConfigResolver<Writing>, ResolveSupergraphConfigError>
     where
         CTX: IntrospectSubgraph + FetchRemoteSubgraph,
     {
@@ -161,7 +161,7 @@ impl IntermediateSupergraphConfig<ResolveSubgraphs> {
                     )
                     .await
                     .map_err(ResolveSupergraphConfigError::ResolveSubgraphs)?;
-                Ok(IntermediateSupergraphConfig {
+                Ok(SupergraphConfigResolver {
                     state: Writing {
                         supergraph_config: resolved_supergraph_config.into(),
                     },
@@ -174,7 +174,7 @@ impl IntermediateSupergraphConfig<ResolveSubgraphs> {
     pub async fn lazily_resolve_subgraphs(
         self,
         supergraph_config_root: &Utf8PathBuf,
-    ) -> Result<IntermediateSupergraphConfig<Writing>, ResolveSupergraphConfigError> {
+    ) -> Result<SupergraphConfigResolver<Writing>, ResolveSupergraphConfigError> {
         match self.state.supergraph_config {
             Some(supergraph_config) => {
                 let unresolved_supergraph_config =
@@ -186,7 +186,7 @@ impl IntermediateSupergraphConfig<ResolveSubgraphs> {
                     )
                     .await
                     .map_err(ResolveSupergraphConfigError::ResolveSubgraphs)?;
-                Ok(IntermediateSupergraphConfig {
+                Ok(SupergraphConfigResolver {
                     state: Writing {
                         supergraph_config: resolved_supergraph_config.into(),
                     },
@@ -205,7 +205,7 @@ pub enum WriteSupergraphConfigError {
     Fs(RoverStdError),
 }
 
-impl IntermediateSupergraphConfig<Writing> {
+impl SupergraphConfigResolver<Writing> {
     pub fn write(
         self,
         path: Utf8PathBuf,
@@ -219,7 +219,7 @@ impl IntermediateSupergraphConfig<Writing> {
     }
 }
 
-#[derive(Getters)]
+#[derive(Clone, Debug, Getters)]
 pub struct FinalSupergraphConfig {
     path: Utf8PathBuf,
     #[getter(skip)]

src/composition/supergraph/config/remote_subgraphs.rs

@@ -18,7 +18,7 @@ pub struct MockFetchRemoteSubgraphsError {}
 #[cfg_attr(test, mockall::automock(type Error = MockFetchRemoteSubgraphsError;))]
 #[async_trait]
 pub trait FetchRemoteSubgraphs {
-    type Error: std::error::Error + 'static;
+    type Error: std::error::Error + Send + Sync + 'static;
     async fn fetch_remote_subgraphs(
         &self,
         graph_ref: &GraphRef,

src/composition/supergraph/config/resolve/subgraph.rs

@@ -21,21 +21,21 @@ pub enum ResolveSubgraphError {
     #[error(transparent)]
     Io(#[from] std::io::Error),
     #[error(transparent)]
-    Fs(Box<dyn std::error::Error>),
+    Fs(Box<dyn std::error::Error + Send + Sync>),
     #[error("Failed to introspect the subgraph {name}.")]
     IntrospectionError {
         name: String,
-        error: Box<dyn std::error::Error>,
+        error: Box<dyn std::error::Error + Send + Sync>,
     },
     #[error("Invalid graph ref: {graph_ref}")]
     InvalidGraphRef {
         graph_ref: String,
-        error: Box<dyn std::error::Error>,
+        error: Box<dyn std::error::Error + Send + Sync>,
     },
     #[error("Failed to fetch the sdl for subgraph `{name}` from remote")]
     FetchRemoteSdlError {
         name: String,
-        error: Box<dyn std::error::Error>,
+        error: Box<dyn std::error::Error + Send + Sync>,
     },
     #[error(
         "The subgraph `{name}` with graph ref `{graph_ref}` does not have an assigned routing url"

src/composition/watchers/mod.rs

@@ -1,6 +1,5 @@
 mod handler;
 pub(crate) mod messages;
-mod run;
 pub(crate) mod subtask;
 pub mod watcher;