cli.rs

use camino::Utf8PathBuf;
use clap::{Parser, ValueEnum};
use lazycell::{AtomicLazyCell, LazyCell};
use reqwest::blocking::Client;
use serde::Serialize;

use crate::command::{self, RoverOutput};
use crate::options::OutputOpts;
use crate::utils::{
    client::{ClientBuilder, ClientTimeout, StudioClientConfig},
    env::{RoverEnv, RoverEnvKey},
    stringify::option_from_display,
    version,
};
use crate::RoverResult;

use config::Config;
use houston as config;
use rover_client::shared::GitContext;
use sputnik::Session;
use timber::Level;

use std::{io, process, thread};

#[derive(Debug, Serialize, Parser)]
#[command(
    name = "Rover",
    author,
    version,
    about = "Rover - Your Graph Companion",
    after_help = "Read the getting started guide by running:

    $ rover docs open start

To begin working with Rover and to authenticate with Apollo Studio,
run the following command:

    $ rover config auth

This will prompt you for an API Key that can be generated in Apollo Studio.

The most common commands from there are:

    - rover graph fetch: Fetch a graph schema from the Apollo graph registry
    - rover graph check: Check for breaking changes in a local graph schema against a graph schema in the Apollo graph
registry
    - rover graph publish: Publish an updated graph schema to the Apollo graph registry

You can open the full documentation for Rover by running:

    $ rover docs open
"
)]
#[command(next_line_help = true)]
pub struct Rover {
    #[clap(subcommand)]
    command: Command,

    /// Specify Rover's log level
    #[arg(long = "log", short = 'l', global = true)]
    #[serde(serialize_with = "option_from_display")]
    log_level: Option<Level>,

    #[clap(flatten)]
    output_opts: OutputOpts,

    /// Accept invalid certificates when performing HTTPS requests.
    ///
    /// You should think very carefully before using this flag.
    ///
    /// If invalid certificates are trusted, any certificate for any site will be trusted for use.
    /// This includes expired certificates.
    /// This introduces significant vulnerabilities, and should only be used as a last resort.
    #[arg(long = "insecure-accept-invalid-certs", global = true)]
    accept_invalid_certs: bool,

    /// Accept invalid hostnames when performing HTTPS requests.
    ///
    /// You should think very carefully before using this flag.
    ///
    /// If hostname verification is not used, any valid certificate for any site will be trusted for use from any other.
    /// This introduces a significant vulnerability to man-in-the-middle attacks.
    #[arg(long = "insecure-accept-invalid-hostnames", global = true)]
    accept_invalid_hostnames: bool,

    /// Configure the timeout length (in seconds) when performing HTTP(S) requests.
    #[arg(
        long = "client-timeout",
        global = true,
        default_value_t = ClientTimeout::default()
    )]
    client_timeout: ClientTimeout,

    /// Skip checking for newer versions of rover.
    #[arg(long = "skip-update-check", global = true)]
    skip_update_check: bool,

    #[arg(skip)]
    #[serde(skip_serializing)]
    env_store: LazyCell<RoverEnv>,

    #[arg(skip)]
    #[serde(skip_serializing)]
    client_builder: AtomicLazyCell<ClientBuilder>,

    #[arg(skip)]
    #[serde(skip_serializing)]
    client: AtomicLazyCell<Client>,
}

impl Rover {
    pub fn run_from_args() -> RoverResult<()> {
        Rover::parse().run()
    }

    pub fn run(&self) -> RoverResult<()> {
        timber::init(self.log_level);
        tracing::trace!(command_structure = ?self);
        self.output_opts.validate_options();

        // attempt to create a new `Session` to capture anonymous usage data
        let rover_output = match Session::new(self) {
            // if successful, report the usage data in the background
            Ok(session) => {
                // kicks off the reporting on a background thread
                let report_thread = thread::spawn(move || {
                    // log + ignore errors because it is not in the critical path
                    let _ = session.report().map_err(|telemetry_error| {
                        tracing::debug!(?telemetry_error);
                        telemetry_error
                    });
                });

                // kicks off the app on the main thread
                // don't return an error with ? quite yet
                // since we still want to report the usage data
                let app_result = self.execute_command();

                // makes sure the reporting finishes in the background
                // before continuing.
                // ignore errors because it is not in the critical path
                let _ = report_thread.join();

                // return result of app execution
                // now that we have reported our usage data
                app_result
            }

            // otherwise just run the app without reporting
            Err(_) => self.execute_command(),
        };

        match rover_output {
            Ok(output) => {
                self.output_opts.handle_output(output)?;

                process::exit(0);
            }
            Err(error) => {
                self.output_opts.handle_output(error)?;

                process::exit(1);
            }
        }
    }

    pub fn execute_command(&self) -> RoverResult<RoverOutput> {
        // before running any commands, we check if rover is up to date
        // this only happens once a day automatically
        // we skip this check for the `rover update` commands, since they
        // do their own checks.
        // the check is also skipped if the `--skip-update-check` flag is passed.
        if let Command::Update(_) = &self.command { /* skip check */
        } else if !self.skip_update_check {
            let config = self.get_rover_config();
            if let Ok(config) = config {
                let _ = version::check_for_update(config, false, self.get_reqwest_client()?);
            }
        }

        match &self.command {
            Command::Config(command) => command.run(self.get_client_config()?),
            Command::Dev(command) => {
                command.run(self.get_install_override_path()?, self.get_client_config()?)
            }
            Command::Fed2(command) => command.run(self.get_client_config()?),
            Command::Supergraph(command) => {
                command.run(self.get_install_override_path()?, self.get_client_config()?)
            }
            Command::Docs(command) => command.run(),
            Command::Graph(command) => command.run(
                self.get_client_config()?,
                self.get_git_context()?,
                self.get_checks_timeout_seconds()?,
                &self.output_opts,
            ),
            Command::Template(command) => command.run(self.get_client_config()?),
            Command::Readme(command) => command.run(self.get_client_config()?),
            Command::Subgraph(command) => command.run(
                self.get_client_config()?,
                self.get_git_context()?,
                self.get_checks_timeout_seconds()?,
                &self.output_opts,
            ),
            Command::Update(command) => {
                command.run(self.get_rover_config()?, self.get_reqwest_client()?)
            }
            Command::Install(command) => {
                command.do_install(self.get_install_override_path()?, self.get_client_config()?)
            }
            Command::Info(command) => command.run(),
            Command::Explain(command) => command.run(),
        }
    }

    pub(crate) fn get_rover_config(&self) -> RoverResult<Config> {
        let override_home: Option<Utf8PathBuf> = self
            .get_env_var(RoverEnvKey::ConfigHome)?
            .map(|p| Utf8PathBuf::from(&p));
        let override_api_key = self.get_env_var(RoverEnvKey::Key)?;
        Ok(Config::new(override_home.as_ref(), override_api_key)?)
    }

    pub(crate) fn get_client_config(&self) -> RoverResult<StudioClientConfig> {
        let override_endpoint = self.get_env_var(RoverEnvKey::RegistryUrl)?;
        let is_sudo = if let Some(fire_flower) = self.get_env_var(RoverEnvKey::FireFlower)? {
            let fire_flower = fire_flower.to_lowercase();
            fire_flower == "true" || fire_flower == "1"
        } else {
            false
        };
        let config = self.get_rover_config()?;
        Ok(StudioClientConfig::new(
            override_endpoint,
            config,
            is_sudo,
            self.get_reqwest_client_builder()?,
        ))
    }

    pub(crate) fn get_install_override_path(&self) -> RoverResult<Option<Utf8PathBuf>> {
        Ok(self
            .get_env_var(RoverEnvKey::Home)?
            .map(|p| Utf8PathBuf::from(&p)))
    }

    pub(crate) fn get_git_context(&self) -> RoverResult<GitContext> {
        // constructing GitContext with a set of overrides from env vars
        let override_git_context = GitContext {
            branch: self.get_env_var(RoverEnvKey::VcsBranch)?,
            commit: self.get_env_var(RoverEnvKey::VcsCommit)?,
            author: self.get_env_var(RoverEnvKey::VcsAuthor)?,
            remote_url: self.get_env_var(RoverEnvKey::VcsRemoteUrl)?,
        };

        let git_context = GitContext::new_with_override(override_git_context);
        tracing::debug!(?git_context);
        Ok(git_context)
    }

    pub(crate) fn get_reqwest_client(&self) -> RoverResult<Client> {
        if let Some(client) = self.client.borrow() {
            Ok(client.clone())
        } else {
            self.client
                .fill(self.get_reqwest_client_builder()?.build()?)
                .expect("Could not overwrite existing request client");
            self.get_reqwest_client()
        }
    }

    pub(crate) fn get_reqwest_client_builder(&self) -> RoverResult<ClientBuilder> {
        // return a copy of the underlying client builder if it's already been populated
        if let Some(client_builder) = self.client_builder.borrow() {
            Ok(*client_builder)
        } else {
            // if a request hasn't been made yet, this cell won't be populated yet
            self.client_builder
                .fill(
                    ClientBuilder::new()
                        .accept_invalid_certs(self.accept_invalid_certs)
                        .accept_invalid_hostnames(self.accept_invalid_hostnames)
                        .with_timeout(self.client_timeout.get_duration()),
                )
                .expect("Could not overwrite existing request client builder");
            self.get_reqwest_client_builder()
        }
    }

    pub(crate) fn get_checks_timeout_seconds(&self) -> RoverResult<u64> {
        if let Some(seconds) = self.get_env_var(RoverEnvKey::ChecksTimeoutSeconds)? {
            Ok(seconds.parse::<u64>()?)
        } else {
            // default to 5 minutes
            Ok(300)
        }
    }

    pub(crate) fn get_env_var(&self, key: RoverEnvKey) -> io::Result<Option<String>> {
        Ok(if let Some(env_store) = self.env_store.borrow() {
            env_store.get(key)
        } else {
            let env_store = RoverEnv::new()?;
            let val = env_store.get(key);
            self.env_store
                .fill(env_store)
                .expect("Could not overwrite the existing environment variable store");
            val
        })
    }

    #[cfg(test)]
    pub(crate) fn insert_env_var(&mut self, key: RoverEnvKey, value: &str) -> io::Result<()> {
        if let Some(env_store) = self.env_store.borrow_mut() {
            env_store.insert(key, value)
        } else {
            let mut env_store = RoverEnv::new()?;
            env_store.insert(key, value);
            self.env_store
                .fill(env_store)
                .expect("Could not overwrite the existing environment variable store");
        };
        Ok(())
    }
}

#[derive(Debug, Serialize, Parser)]
pub enum Command {
    /// Configuration profile commands
    Config(command::Config),

    /// Combine multiple subgraphs into a local supergraph
    ///
    /// This command starts a local router that can query across one or more
    /// running GraphQL APIs (subgraphs) through one endpoint (supergraph).
    /// As you add, edit, and remove subgraphs, `rover dev` automatically
    /// composes all of their schemas into a new supergraph schema, and the
    /// router reloads.
    ///
    /// ⚠️ Do not run this command in production!
    /// ⚠️ It is intended for local development.
    ///
    /// The first time you run `rover dev`, a supergraph is created from the
    /// GraphQL API you provide. This GraphQL API is the first subgraph
    /// inside of the larger supergraph. As you make changes to the subgraph
    /// schema, the supergraph schema will be re-composed and the router will
    /// reload.
    ///
    /// You can navigate to the supergraph endpoint in your browser
    /// to execute operations and see query plans using Apollo Sandbox.
    ///
    /// You can add more subgraphs by running `rover dev` again in a new
    /// terminal. Subsequent subgraphs are composed into the supergraph and
    /// can be queried alongside all other subgraphs from the original endpoint.
    /// Changes to these schemas will also cause the supergraph schema to be
    /// re-composed and the router to reload.
    ///
    /// Terminating the first `rover dev` process terminates the entire supergraph.
    /// Terminating one of the subsequent `rover dev` processes (i.e. your second
    /// or third subgraph) will decompose that subgraph from your supergraph.
    ///
    /// Think plug-n-play USB devices but with your GraphQL APIs!
    Dev(command::Dev),

    /// (deprecated) Federation 2 Alpha commands
    #[command(hide = true)]
    Fed2(command::Fed2),

    /// Supergraph schema commands
    Supergraph(command::Supergraph),

    /// Graph API schema commands
    Graph(command::Graph),

    /// Commands for working with templates
    Template(command::Template),

    /// Readme commands
    Readme(command::Readme),

    /// Subgraph schema commands
    Subgraph(command::Subgraph),

    /// Interact with Rover's documentation
    Docs(command::Docs),

    /// Commands related to updating rover
    Update(command::Update),

    /// Installs Rover
    #[command(hide = true)]
    Install(command::Install),

    /// Get system information
    #[command(hide = true)]
    Info(command::Info),

    /// Explain error codes
    Explain(command::Explain),
}

#[derive(ValueEnum, Debug, Serialize, Clone, Eq, PartialEq)]
pub enum RoverOutputFormatKind {
    Plain,
    Json,
}

#[derive(ValueEnum, Debug, Serialize, Clone, Eq, PartialEq)]
pub enum RoverOutputKind {
    RoverOutput,
    RoverError,
}

impl Default for RoverOutputFormatKind {
    fn default() -> Self {
        RoverOutputFormatKind::Plain
    }
}