Merge pull request #53 from zaghaghi/feat/global-headers

feat: global request headers via -H/--header

Author: zaghaghi

src/app.rs

@@ -42,8 +42,8 @@ pub struct App {
 }
 
 impl App {
-  pub async fn new(input: String) -> Result<Self> {
-    let state = State::from_input(input).await?;
+  pub async fn new(input: String, global_headers: Vec<(String, String)>) -> Result<Self> {
+    let state = State::from_input(input, global_headers).await?;
     let home = Home::new()?;
     let config = Config::new()?;
     let mode = Mode::Home;

src/cli.rs

@@ -12,4 +12,12 @@ pub struct Cli {
     help = "Input file or url, in json or yaml format with openapi specification"
   )]
   pub input: String,
+
+  #[arg(
+    short = 'H',
+    long = "header",
+    value_name = "NAME: VALUE",
+    help = "Global header to attach to every request, in `Name: Value` form. May be repeated."
+  )]
+  pub headers: Vec<String>,
 }

src/main.rs

@@ -14,20 +14,30 @@ pub mod utils;
 
 use clap::Parser;
 use cli::Cli;
-use color_eyre::eyre::Result;
+use color_eyre::eyre::{eyre, Result};
 
 use crate::{
   app::App,
   utils::{initialize_logging, initialize_panic_handler},
 };
 
+fn parse_header(raw: &str) -> Result<(String, String)> {
+  let (name, value) = raw.split_once(':').ok_or_else(|| eyre!("invalid header `{raw}`: expected `Name: Value`"))?;
+  let name = name.trim();
+  if name.is_empty() {
+    return Err(eyre!("invalid header `{raw}`: empty name"));
+  }
+  Ok((name.to_string(), value.trim().to_string()))
+}
+
 async fn tokio_main() -> Result<()> {
   initialize_logging()?;
 
   initialize_panic_handler()?;
 
   let args = Cli::parse();
-  let mut app = App::new(args.input).await?;
+  let global_headers = args.headers.iter().map(|h| parse_header(h)).collect::<Result<Vec<_>>>()?;
+  let mut app = App::new(args.input, global_headers).await?;
   app.run().await?;
 
   Ok(())

src/panes/parameter_editor.rs

@@ -105,6 +105,14 @@ impl ParameterEditor {
           schema: parameter.schema.clone(),
         });
       });
+
+      for (name, value) in &state.global_headers {
+        if header_items.iter().any(|item: &ParameterItem| item.name.eq_ignore_ascii_case(name)) {
+          continue;
+        }
+        header_items.push(ParameterItem { name: name.clone(), value: Some(value.clone()), ..Default::default() });
+      }
+
       if !path_items.is_empty() {
         self.parameters.push(ParameterTab {
           location: "Path".to_string(),

src/state.rs

@@ -20,6 +20,7 @@ pub struct State {
   pub responses: HashMap<String, Response>,
   pub pending_operations: HashSet<String>,
   pub spinner_frame: usize,
+  pub global_headers: Vec<(String, String)>,
 }
 
 #[derive(Debug, Default, Clone)]
@@ -72,6 +73,7 @@ impl State {
       responses: HashMap::default(),
       pending_operations: HashSet::default(),
       spinner_frame: 0,
+      global_headers: Vec::new(),
     })
   }
 
@@ -104,15 +106,18 @@ impl State {
       responses: HashMap::default(),
       pending_operations: HashSet::default(),
       spinner_frame: 0,
+      global_headers: Vec::new(),
     })
   }
 
-  pub async fn from_input(input: String) -> Result<Self> {
-    if let Ok(url) = reqwest::Url::parse(input.as_str()) {
-      State::from_url(url).await
+  pub async fn from_input(input: String, global_headers: Vec<(String, String)>) -> Result<Self> {
+    let mut state = if let Ok(url) = reqwest::Url::parse(input.as_str()) {
+      State::from_url(url).await?
     } else {
-      State::from_path(input).await
-    }
+      State::from_path(input).await?
+    };
+    state.global_headers = global_headers;
+    Ok(state)
   }
 
   pub fn get_operation(&self, operation_id: Option<String>) -> Option<&OperationItem> {