chore: DRY up reused CLI options (#1155)

* chore: DRY up reused CLI options

* fixup architecture.md

* chore: factors out SchemaOpt

* factor out CheckConfigOpts

Author: EverlastingBugstopper

ARCHITECTURE.md

@@ -191,18 +191,15 @@ All commands under the `graph` namespace accept a required, positional argument
 To add these to our new `graph hello` command, we can copy and paste the field from any other `graph` command like so:
 
 ```rust
+use crate::options::{ProfileOpt, GraphRefOpt};
+
 #[derive(Debug, Serialize, StructOpt)]
 pub struct Hello {
-    /// <NAME>@<VARIANT> of graph in Apollo Studio to publish to.
-    /// @<VARIANT> may be left off, defaulting to @current
-    #[structopt(name = "GRAPH_REF"))]
-    #[serde(skip_serializing)]
-    graph: GraphRef,
-
-    /// Name of configuration profile to use
-    #[structopt(long = "profile", default_value = "default")]
-    #[serde(skip_serializing)]
-    profile_name: String,
+    #[structopt(flatten)]
+    graph: GraphRefOpt,
+
+    #[structop(flatten)]
+    profile: ProfileOpt,
 }
 ```
 
@@ -228,7 +225,7 @@ To access functionality from `rover-client` in our `rover graph hello` command,
 
 You can do this by changing the `Command::Hello(command) => command.run(),` line to `Command::Hello(command) => command.run(client_config),`.
 
-Then you'll need to change `Hello::run` to accept a `client_config: StudioClientConfig` parameter in `src/command/graph/hello.rs`, and add `use crate::utils::client::StudioClientConfig` and `use rover_client::shared::GraphRef` import statements. Then, at the top of the run function, you can create a `StudioClient` by adding `let client = client_config.get_authenticated_client(&self.profile_name)?;`. You can see examples of this in the other commands.
+Then you'll need to change `Hello::run` to accept a `client_config: StudioClientConfig` parameter in `src/command/graph/hello.rs`, and add `use crate::utils::client::StudioClientConfig` and `use rover_client::shared::GraphRef` import statements. Then, at the top of the run function, you can create a `StudioClient` by adding `let client = client_config.get_authenticated_client(&self.profile.name)?;`. You can see examples of this in the other commands.
 
 ##### Auto-generated help command
 
@@ -357,16 +354,16 @@ It should look something like this (you should make sure you are following the s
 
 ```rust
 pub fn run(&self, client_config: StudioClientConfig) -> Result<RoverOutput> {
-    let client = client_config.get_client(&self.profile_name)?;
-    let graph_ref = self.graph.to_string();
+    let client = client_config.get_client(&self.profile.name)?;
+    let graph_ref = self.graph.graph_ref.to_string();
     eprintln!(
         "Checking deletion of graph {} using credentials from the {} profile.",
         Cyan.normal().paint(&graph_ref),
-        Yellow.normal().paint(&self.profile_name)
+        Yellow.normal().paint(&self.profile.name)
     );
     let deleted_at = hello::run(
         hello::graph_hello::Variables {
-            graph_id: self.graph.name.clone(),
+            graph_id: self.graph.graph_ref.clone(),
         },
         &client,
     )?;

crates/rover-client/src/shared/check_response.rs

@@ -6,7 +6,7 @@ use crate::shared::GraphRef;
 use crate::RoverClientError;
 
 use prettytable::format::consts::FORMAT_BOX_CHARS;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
 use prettytable::{cell, row, Table};
 use serde_json::{json, Value};
@@ -162,7 +162,7 @@ pub struct CheckConfig {
     pub validation_period: Option<ValidationPeriod>,
 }
 
-#[derive(Debug, PartialEq, Eq, Serialize, Clone)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone)]
 pub struct ValidationPeriod {
     pub from: Period,
     pub to: Period,
@@ -187,7 +187,7 @@ impl FromStr for ValidationPeriod {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Period {
     Now,
     Past(i64),

crates/rover-client/src/shared/graph_ref.rs

@@ -4,9 +4,9 @@ use std::str::FromStr;
 use crate::RoverClientError;
 
 use regex::Regex;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Serialize, Clone, PartialEq)]
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
 pub struct GraphRef {
     pub name: String,
     pub variant: String,

src/command/config/auth.rs

@@ -6,7 +6,7 @@ use config::Profile;
 use houston as config;
 
 use crate::command::RoverOutput;
-use crate::{anyhow, Result};
+use crate::{anyhow, options::ProfileOpt, Result};
 
 #[derive(Debug, Serialize, StructOpt)]
 /// Authenticate a configuration profile with an API key
@@ -20,16 +20,15 @@ use crate::{anyhow, Result};
 ///
 /// Run `rover docs open api-keys` for more details on Apollo's API keys.
 pub struct Auth {
-    #[structopt(long = "profile", default_value = "default")]
-    #[serde(skip_serializing)]
-    profile_name: String,
+    #[structopt(flatten)]
+    profile: ProfileOpt,
 }
 
 impl Auth {
     pub fn run(&self, config: config::Config) -> Result<RoverOutput> {
         let api_key = api_key_prompt()?;
-        Profile::set_api_key(&self.profile_name, &config, &api_key)?;
-        Profile::get_credential(&self.profile_name, &config).map(|_| {
+        Profile::set_api_key(&self.profile.profile_name, &config, &api_key)?;
+        Profile::get_credential(&self.profile.profile_name, &config).map(|_| {
             eprintln!("Successfully saved API key.");
         })?;
         Ok(RoverOutput::EmptySuccess)

src/command/config/whoami.rs

@@ -7,6 +7,7 @@ use houston::{mask_key, CredentialOrigin};
 
 use crate::anyhow;
 use crate::command::RoverOutput;
+use crate::options::ProfileOpt;
 use crate::utils::client::StudioClientConfig;
 use crate::utils::env::RoverEnvKey;
 use crate::Result;
@@ -15,10 +16,8 @@ use houston as config;
 
 #[derive(Debug, Serialize, StructOpt)]
 pub struct WhoAmI {
-    /// Name of configuration profile to use
-    #[structopt(long = "profile", default_value = "default")]
-    #[serde(skip_serializing)]
-    profile_name: String,
+    #[structopt(flatten)]
+    profile: ProfileOpt,
 
     /// Unmask the API key that will be sent to Apollo Studio
     ///
@@ -31,7 +30,7 @@ pub struct WhoAmI {
 
 impl WhoAmI {
     pub fn run(&self, client_config: StudioClientConfig) -> Result<RoverOutput> {
-        let client = client_config.get_authenticated_client(&self.profile_name)?;
+        let client = client_config.get_authenticated_client(&self.profile.profile_name)?;
         eprintln!("Checking identity of your API key against the registry.");
 
         let identity = who_am_i::run(ConfigWhoAmIInput {}, &client)?;
@@ -79,7 +78,7 @@ impl WhoAmI {
         message.push_str(&format!("{}: {}", Green.normal().paint("Origin"), &origin));
 
         let credential =
-            config::Profile::get_credential(&self.profile_name, &client_config.config)?;
+            config::Profile::get_credential(&self.profile.profile_name, &client_config.config)?;
 
         let maybe_masked_key = if self.insecure_unmask_key {
             credential.api_key

src/command/fed2/supergraph/compose.rs

@@ -1,9 +1,12 @@
-use crate::utils::{
-    client::StudioClientConfig,
-    parsers::{parse_file_descriptor, FileDescriptorType},
-};
 use crate::Suggestion;
 use crate::{anyhow, command::RoverOutput, error::RoverError, Result};
+use crate::{
+    options::ProfileOpt,
+    utils::{
+        client::StudioClientConfig,
+        parsers::{parse_file_descriptor, FileDescriptorType},
+    },
+};
 
 use serde::Serialize;
 use structopt::StructOpt;
@@ -15,10 +18,9 @@ pub struct Compose {
     #[serde(skip_serializing)]
     supergraph_yaml: FileDescriptorType,
 
-    /// Name of configuration profile to use
-    #[structopt(long = "profile", default_value = "default")]
-    #[serde(skip_serializing)]
-    _profile_name: String,
+    #[structopt(flatten)]
+    #[allow(unused)]
+    profile: ProfileOpt,
 }
 
 impl Compose {

src/command/graph/check.rs

@@ -2,48 +2,27 @@ use serde::Serialize;
 use structopt::StructOpt;
 
 use rover_client::operations::graph::check::{self, GraphCheckInput};
-use rover_client::shared::{CheckConfig, GitContext, GraphRef, ValidationPeriod};
+use rover_client::shared::{CheckConfig, GitContext};
 
 use crate::command::RoverOutput;
+use crate::options::{CheckConfigOpts, GraphRefOpt, ProfileOpt, SchemaOpt};
 use crate::utils::client::StudioClientConfig;
-use crate::utils::parsers::{
-    parse_file_descriptor, parse_query_count_threshold, parse_query_percentage_threshold,
-    FileDescriptorType,
-};
 use crate::Result;
 
 #[derive(Debug, Serialize, StructOpt)]
 pub struct Check {
-    /// <NAME>@<VARIANT> of graph in Apollo Studio to validate.
-    /// @<VARIANT> may be left off, defaulting to @current
-    #[structopt(name = "GRAPH_REF")]
-    #[serde(skip_serializing)]
-    graph: GraphRef,
+    #[structopt(flatten)]
+    graph: GraphRefOpt,
 
-    /// Name of configuration profile to use
-    #[structopt(long = "profile", default_value = "default")]
-    #[serde(skip_serializing)]
-    profile_name: String,
+    #[structopt(flatten)]
+    profile: ProfileOpt,
 
-    /// The schema file to check. You can pass `-` to use stdin instead of a file.
-    #[structopt(long, short = "s", parse(try_from_str = parse_file_descriptor))]
+    #[structopt(flatten)]
     #[serde(skip_serializing)]
-    schema: FileDescriptorType,
-
-    /// The minimum number of times a query or mutation must have been executed
-    /// in order to be considered in the check operation
-    #[structopt(long, parse(try_from_str = parse_query_count_threshold))]
-    query_count_threshold: Option<i64>,
-
-    /// Minimum percentage of times a query or mutation must have been executed
-    /// in the time window, relative to total request count, for it to be
-    /// considered in the check. Valid numbers are in the range 0 <= x <= 100
-    #[structopt(long, parse(try_from_str = parse_query_percentage_threshold))]
-    query_percentage_threshold: Option<f64>,
+    schema: SchemaOpt,
 
-    /// Size of the time window with which to validate schema against (i.e "24h" or "1w 2d 5h")
-    #[structopt(long)]
-    validation_period: Option<ValidationPeriod>,
+    #[structopt(flatten)]
+    config: CheckConfigOpts,
 }
 
 impl Check {
@@ -52,25 +31,25 @@ impl Check {
         client_config: StudioClientConfig,
         git_context: GitContext,
     ) -> Result<RoverOutput> {
-        let client = client_config.get_authenticated_client(&self.profile_name)?;
+        let client = client_config.get_authenticated_client(&self.profile.profile_name)?;
         let proposed_schema = self
             .schema
             .read_file_descriptor("SDL", &mut std::io::stdin())?;
 
         eprintln!(
             "Checking the proposed schema against metrics from {}",
-            &self.graph
+            &self.graph.graph_ref
         );
 
         let res = check::run(
             GraphCheckInput {
-                graph_ref: self.graph.clone(),
+                graph_ref: self.graph.graph_ref.clone(),
                 proposed_schema,
                 git_context,
                 config: CheckConfig {
-                    query_count_threshold: self.query_count_threshold,
-                    query_count_threshold_percentage: self.query_percentage_threshold,
-                    validation_period: self.validation_period.clone(),
+                    query_count_threshold: self.config.query_count_threshold,
+                    query_count_threshold_percentage: self.config.query_percentage_threshold,
+                    validation_period: self.config.validation_period.clone(),
                 },
             },
             &client,

src/command/graph/delete.rs

@@ -3,24 +3,19 @@ use serde::Serialize;
 use structopt::StructOpt;
 
 use rover_client::operations::graph::delete::{self, GraphDeleteInput};
-use rover_client::shared::GraphRef;
 
 use crate::command::RoverOutput;
+use crate::options::{GraphRefOpt, ProfileOpt};
 use crate::utils::{self, client::StudioClientConfig};
 use crate::Result;
 
 #[derive(Debug, Serialize, StructOpt)]
 pub struct Delete {
-    /// <NAME>@<VARIANT> of graph in Apollo Studio to fetch from.
-    /// @<VARIANT> may be left off, defaulting to @current
-    #[structopt(name = "GRAPH_REF")]
-    #[serde(skip_serializing)]
-    graph: GraphRef,
+    #[structopt(flatten)]
+    graph: GraphRefOpt,
 
-    /// Name of configuration profile to use
-    #[structopt(long = "profile", default_value = "default")]
-    #[serde(skip_serializing)]
-    profile_name: String,
+    #[structopt(flatten)]
+    profile: ProfileOpt,
 
     /// Skips the step where the command asks for user confirmation before
     /// deleting the graph.
@@ -30,13 +25,13 @@ pub struct Delete {
 
 impl Delete {
     pub fn run(&self, client_config: StudioClientConfig) -> Result<RoverOutput> {
-        let client = client_config.get_authenticated_client(&self.profile_name)?;
-        let graph_ref = self.graph.to_string();
+        let client = client_config.get_authenticated_client(&self.profile.profile_name)?;
+        let graph_ref = self.graph.graph_ref.to_string();
 
         eprintln!(
             "Deleting {} using credentials from the {} profile.",
             Cyan.normal().paint(&graph_ref),
-            Yellow.normal().paint(&self.profile_name)
+            Yellow.normal().paint(&self.profile.profile_name)
         );
 
         if !self.confirm && !utils::confirm_delete()? {
@@ -46,7 +41,7 @@ impl Delete {
 
         delete::run(
             GraphDeleteInput {
-                graph_ref: self.graph.clone(),
+                graph_ref: self.graph.graph_ref.clone(),
             },
             &client,
         )?;

src/command/graph/fetch.rs

@@ -3,39 +3,34 @@ use serde::Serialize;
 use structopt::StructOpt;
 
 use rover_client::operations::graph::fetch::{self, GraphFetchInput};
-use rover_client::shared::GraphRef;
 
 use crate::command::RoverOutput;
+use crate::options::{GraphRefOpt, ProfileOpt};
 use crate::utils::client::StudioClientConfig;
 use crate::Result;
 
 #[derive(Debug, Serialize, StructOpt)]
 pub struct Fetch {
-    /// <NAME>@<VARIANT> of graph in Apollo Studio to fetch from.
-    /// @<VARIANT> may be left off, defaulting to @current
-    #[structopt(name = "GRAPH_REF")]
-    #[serde(skip_serializing)]
-    graph: GraphRef,
+    #[structopt(flatten)]
+    graph: GraphRefOpt,
 
-    /// Name of configuration profile to use
-    #[structopt(long = "profile", default_value = "default")]
-    #[serde(skip_serializing)]
-    profile_name: String,
+    #[structopt(flatten)]
+    profile: ProfileOpt,
 }
 
 impl Fetch {
     pub fn run(&self, client_config: StudioClientConfig) -> Result<RoverOutput> {
-        let client = client_config.get_authenticated_client(&self.profile_name)?;
-        let graph_ref = self.graph.to_string();
+        let client = client_config.get_authenticated_client(&self.profile.profile_name)?;
+        let graph_ref = self.graph.graph_ref.to_string();
         eprintln!(
             "Fetching SDL from {} using credentials from the {} profile.",
             Cyan.normal().paint(&graph_ref),
-            Yellow.normal().paint(&self.profile_name)
+            Yellow.normal().paint(&self.profile.profile_name)
         );
 
         let fetch_response = fetch::run(
             GraphFetchInput {
-                graph_ref: self.graph.clone(),
+                graph_ref: self.graph.graph_ref.clone(),
             },
             &client,
         )?;