Toggle query/header rows in recipe

CHANGELOG.md

@@ -6,6 +6,8 @@
 
 - Move app-level configuration into a file ([#89](https://github.com/LucasPickering/slumber/issues/89))
   - Right now the only supported field is `preview_templates`
+- Toggle query parameters and headers in recipe pane ([#30](https://github.com/LucasPickering/slumber/issues/30))
+  - You can easily enable/disable parameters and headers without having to modify the collection file now
 
 ### Changed
 

src/cli/request.rs

@@ -2,7 +2,7 @@ use crate::{
     cli::Subcommand,
     collection::{CollectionFile, ProfileId, RecipeId},
     db::Database,
-    http::{HttpEngine, RequestBuilder},
+    http::{HttpEngine, RecipeOptions, RequestBuilder},
     template::{Prompt, Prompter, TemplateContext},
     util::ResultExt,
     GlobalArgs,
@@ -75,6 +75,7 @@ impl Subcommand for RequestCommand {
         let overrides: IndexMap<_, _> = self.overrides.into_iter().collect();
         let request = RequestBuilder::new(
             recipe,
+            RecipeOptions::default(),
             TemplateContext {
                 profile,
                 chains: collection.chains.clone(),

src/db.rs

@@ -110,9 +110,9 @@ impl Database {
             )
             .down("DROP TABLE requests"),
             M::up(
-                // Values will be serialized as msgpack
+                // keys+values will be serialized as msgpack
                 "CREATE TABLE ui_state (
-                    key             TEXT NOT NULL,
+                    key             BLOB NOT NULL,
                     collection_id   UUID NOT NULL,
                     value           BLOB NOT NULL,
                     PRIMARY KEY (key, collection_id),
@@ -355,7 +355,7 @@ impl CollectionDatabase {
     /// Get the value of a UI state field
     pub fn get_ui<K, V>(&self, key: K) -> anyhow::Result<Option<V>>
     where
-        K: Display,
+        K: Debug + Serialize,
         V: Debug + DeserializeOwned,
     {
         let value = self
@@ -366,7 +366,7 @@ impl CollectionDatabase {
                 WHERE collection_id = :collection_id AND key = :key",
                 named_params! {
                     ":collection_id": self.collection_id,
-                    ":key": key.to_string(),
+                    ":key": Bytes(&key),
                 },
                 |row| {
                     let value: Bytes<V> = row.get("value")?;
@@ -376,17 +376,17 @@ impl CollectionDatabase {
             .optional()
             .context("Error fetching UI state from database")
             .traced()?;
-        debug!(%key, ?value, "Fetched UI state");
+        debug!(?key, ?value, "Fetched UI state");
         Ok(value)
     }
 
     /// Set the value of a UI state field
     pub fn set_ui<K, V>(&self, key: K, value: V) -> anyhow::Result<()>
     where
-        K: Display,
+        K: Debug + Serialize,
         V: Debug + Serialize,
     {
-        debug!(%key, ?value, "Setting UI state");
+        debug!(?key, ?value, "Setting UI state");
         self.database
             .connection()
             .execute(
@@ -396,7 +396,7 @@ impl CollectionDatabase {
                 ON CONFLICT DO UPDATE SET value = excluded.value",
                 named_params! {
                     ":collection_id": self.collection_id,
-                    ":key": key.to_string(),
+                    ":key": Bytes(key),
                     ":value": Bytes(value),
                 },
             )

src/http.rs

@@ -40,9 +40,7 @@ pub use parse::*;
 pub use record::*;
 
 use crate::{
-    collection::Recipe,
-    db::CollectionDatabase,
-    template::{Template, TemplateContext},
+    collection::Recipe, db::CollectionDatabase, template::TemplateContext,
     util::ResultExt,
 };
 use anyhow::Context;
@@ -53,6 +51,7 @@ use reqwest::{
     header::{HeaderMap, HeaderName, HeaderValue},
     Client,
 };
+use std::collections::HashSet;
 use tokio::try_join;
 use tracing::{debug, info, info_span};
 
@@ -220,22 +219,43 @@ pub struct RequestBuilder {
     id: RequestId,
     // We need this during the build
     recipe: Recipe,
+    options: RecipeOptions,
     template_context: TemplateContext,
 }
 
+/// OPtions for modifying a recipe during a build. This is helpful for applying
+/// temporary modifications made by the user. By providing this in a separate
+/// struct, we prevent the need to clone, modify, and pass recipes everywhere.
+/// Recipes could be very large so cloning may be expensive, and this options
+/// layer makes the available modifications clear and restricted.
+#[derive(Clone, Debug, Default)]
+pub struct RecipeOptions {
+    /// Which headers should be excluded? A blacklist allows the default to be
+    /// "include all".
+    pub disabled_headers: HashSet<String>,
+    /// Which query parameters should be excluded?  A blacklist allows the
+    /// default to be "include all".
+    pub disabled_query_parameters: HashSet<String>,
+}
+
 impl RequestBuilder {
     /// Instantiate new request builder for the given recipe. Use [Self::build]
     /// to build it.
     ///
     /// This needs an owned recipe and context so they can be moved into a
     /// subtask for the build.
-    pub fn new(recipe: Recipe, template_context: TemplateContext) -> Self {
+    pub fn new(
+        recipe: Recipe,
+        options: RecipeOptions,
+        template_context: TemplateContext,
+    ) -> Self {
         debug!(recipe_id = %recipe.id, "Building request from recipe");
         let request_id = RequestId::new();
 
         Self {
             id: request_id,
             recipe,
+            options,
             template_context,
         }
     }
@@ -258,20 +278,20 @@ impl RequestBuilder {
 
     /// Outsourced build function, to make error conversion easier later
     async fn build_helper(self) -> anyhow::Result<Request> {
-        let recipe = self.recipe;
+        // let recipe = self.recipe;
         let template_context = &self.template_context;
-        let method = recipe.method.parse()?;
+        let method = self.recipe.method.parse()?;
 
         // Render everything in parallel
         let (url, headers, query, body) = try_join!(
-            Self::render_url(template_context, &recipe.url),
-            Self::render_headers(template_context, &recipe.headers),
-            Self::render_query(template_context, &recipe.query),
-            Self::render_body(template_context, recipe.body.as_ref()),
+            self.render_url(),
+            self.render_headers(),
+            self.render_query(),
+            self.render_body(),
         )?;
 
         info!(
-            recipe_id = %recipe.id,
+            recipe_id = %self.recipe.id,
             "Built request from recipe",
         );
 
@@ -281,7 +301,7 @@ impl RequestBuilder {
                 .profile
                 .as_ref()
                 .map(|profile| profile.id.clone()),
-            recipe_id: recipe.id.clone(),
+            recipe_id: self.recipe.id,
             method,
             url,
             query,
@@ -290,70 +310,79 @@ impl RequestBuilder {
         })
     }
 
-    async fn render_url(
-        template_context: &TemplateContext,
-        url: &Template,
-    ) -> anyhow::Result<String> {
-        url.render(template_context)
+    async fn render_url(&self) -> anyhow::Result<String> {
+        self.recipe
+            .url
+            .render(&self.template_context)
             .await
             .context("Error rendering URL")
     }
 
-    async fn render_headers(
-        template_context: &TemplateContext,
-        headers: &IndexMap<String, Template>,
-    ) -> anyhow::Result<HeaderMap> {
-        let iter = headers.iter().map(|(header, value_template)| async move {
-            let value = value_template
-                .render(template_context)
-                .await
-                .context(format!("Error rendering header `{header}`"))?;
-            // Strip leading/trailing line breaks because they're going to
-            // trigger a validation error and are probably a mistake. This is
-            // a balance between convenience and explicitness
-            let value = value.trim_matches(|c| c == '\n' || c == '\r');
-            // String -> header conversions are fallible, if headers
-            // are invalid
-            Ok::<(HeaderName, HeaderValue), anyhow::Error>((
-                header
-                    .try_into()
-                    .context(format!("Error parsing header name `{header}`"))?,
-                value.try_into().context(format!(
-                    "Error parsing value for header `{header}`"
-                ))?,
-            ))
-        });
+    async fn render_headers(&self) -> anyhow::Result<HeaderMap> {
+        let template_context = &self.template_context;
+        let iter = self
+            .recipe
+            .headers
+            .iter()
+            // Filter out disabled headers
+            .filter(|(header, _)| {
+                !self.options.disabled_headers.contains(*header)
+            })
+            .map(|(header, value_template)| async move {
+                let value = value_template
+                    .render(template_context)
+                    .await
+                    .context(format!("Error rendering header `{header}`"))?;
+                // Strip leading/trailing line breaks because they're going to
+                // trigger a validation error and are probably a mistake. This
+                // is a balance between convenience and
+                // explicitness
+                let value = value.trim_matches(|c| c == '\n' || c == '\r');
+                // String -> header conversions are fallible, if headers
+                // are invalid
+                Ok::<(HeaderName, HeaderValue), anyhow::Error>((
+                    header.try_into().context(format!(
+                        "Error parsing header name `{header}`"
+                    ))?,
+                    value.try_into().context(format!(
+                        "Error parsing value for header `{header}`"
+                    ))?,
+                ))
+            });
         Ok(future::try_join_all(iter)
             .await?
             .into_iter()
             .collect::<HeaderMap>())
     }
 
-    async fn render_query(
-        template_context: &TemplateContext,
-        query: &IndexMap<String, Template>,
-    ) -> anyhow::Result<IndexMap<String, String>> {
-        let iter = query.iter().map(|(k, v)| async move {
-            Ok::<_, anyhow::Error>((
-                k.clone(),
-                v.render(template_context).await.context(format!(
-                    "Error rendering query parameter `{k}`"
-                ))?,
-            ))
-        });
+    async fn render_query(&self) -> anyhow::Result<IndexMap<String, String>> {
+        let template_context = &self.template_context;
+        let iter = self
+            .recipe
+            .query
+            .iter()
+            // Filter out disabled params
+            .filter(|(param, _)| {
+                !self.options.disabled_query_parameters.contains(*param)
+            })
+            .map(|(k, v)| async move {
+                Ok::<_, anyhow::Error>((
+                    k.clone(),
+                    v.render(template_context).await.context(format!(
+                        "Error rendering query parameter `{k}`"
+                    ))?,
+                ))
+            });
         Ok(future::try_join_all(iter)
             .await?
             .into_iter()
             .collect::<IndexMap<String, String>>())
     }
 
-    async fn render_body(
-        template_context: &TemplateContext,
-        body: Option<&Template>,
-    ) -> anyhow::Result<Option<String>> {
-        match body {
+    async fn render_body(&self) -> anyhow::Result<Option<String>> {
+        match &self.recipe.body {
             Some(body) => Ok(Some(
-                body.render(template_context)
+                body.render(&self.template_context)
                     .await
                     .context("Error rendering body")?,
             )),

src/tui.rs

@@ -7,7 +7,7 @@ use crate::{
     collection::{Collection, CollectionFile, ProfileId, RecipeId},
     config::Config,
     db::{CollectionDatabase, Database},
-    http::{HttpEngine, RequestBuilder},
+    http::{HttpEngine, RecipeOptions, RequestBuilder},
     template::{Prompter, Template, TemplateChunk, TemplateContext},
     tui::{
         context::TuiContext,
@@ -206,7 +206,8 @@ impl Tui {
             Message::HttpBeginRequest {
                 recipe_id,
                 profile_id,
-            } => self.send_request(profile_id, recipe_id)?,
+                options,
+            } => self.send_request(profile_id, recipe_id, options)?,
             Message::HttpBuildError {
                 profile_id,
                 recipe_id,
@@ -313,6 +314,7 @@ impl Tui {
         &mut self,
         profile_id: Option<ProfileId>,
         recipe_id: RecipeId,
+        options: RecipeOptions,
     ) -> anyhow::Result<()> {
         let recipe = self
             .collection_file
@@ -327,7 +329,7 @@ impl Tui {
         let template_context = self
             .template_context(profile_id.as_ref(), self.messages_tx.clone())?;
         let http_engine = self.http_engine.clone();
-        let builder = RequestBuilder::new(recipe, template_context);
+        let builder = RequestBuilder::new(recipe, options, template_context);
         let messages_tx = self.messages_tx.clone();
 
         // Mark request state as building

src/tui/message.rs

@@ -3,7 +3,10 @@
 
 use crate::{
     collection::{Collection, ProfileId, RecipeId},
-    http::{RequestBuildError, RequestError, RequestId, RequestRecord},
+    http::{
+        RecipeOptions, RequestBuildError, RequestError, RequestId,
+        RequestRecord,
+    },
     template::{Prompt, Prompter, Template, TemplateChunk},
     util::ResultExt,
 };
@@ -61,6 +64,7 @@ pub enum Message {
     HttpBeginRequest {
         profile_id: Option<ProfileId>,
         recipe_id: RecipeId,
+        options: RecipeOptions,
     },
     /// Request failed to build
     HttpBuildError {

src/tui/view/common/text_window.rs

@@ -170,7 +170,10 @@ struct TextWindowActionsModal {
 
 impl Default for TextWindowActionsModal {
     fn default() -> Self {
-        fn on_submit(context: &mut UpdateContext, action: &TextWindowAction) {
+        fn on_submit(
+            context: &mut UpdateContext,
+            action: &mut TextWindowAction,
+        ) {
             // Close the modal *first*, so the action event gets handled by our
             // parent rather than the modal. Jank but it works
             context.queue_event(Event::CloseModal);

src/tui/view/component/primary.rs

@@ -168,6 +168,7 @@ impl EventHandler for PrimaryView {
                         profile_id: self
                             .selected_profile()
                             .map(|profile| profile.id.clone()),
+                        options: self.request_pane.recipe_options(),
                     });
                 }
                 Update::Consumed

src/tui/view/component/profile_list.rs

@@ -26,7 +26,7 @@ pub struct ProfileListPaneProps {
 impl ProfileListPane {
     pub fn new(profiles: Vec<Profile>) -> Self {
         // Loaded request depends on the profile, so refresh on change
-        fn on_select(context: &mut UpdateContext, _: &Profile) {
+        fn on_select(context: &mut UpdateContext, _: &mut Profile) {
             context.queue_event(Event::HttpLoadRequest);
         }