From 3846d1379a496b68e65a502a84dd617b8a434ecc Mon Sep 17 00:00:00 2001
From: Lucas Pickering <lucas@lucaspickering.me>
Date: Tue, 4 Jun 2024 17:20:56 -0400
Subject: [PATCH] Add support for URL-encoded forms

Closes #244
---
 CHANGELOG.md                                  |   7 +-
 README.md                                     |   5 +
 .../src/api/request_collection/recipe_body.md |   7 +-
 slumber.yml                                   |   5 +-
 src/collection.rs                             |  15 +
 src/collection/cereal.rs                      |  68 ++++-
 src/collection/insomnia.rs                    |  36 ++-
 src/collection/models.rs                      |  16 +-
 src/http.rs                                   | 260 ++++++++++++------
 src/http/models.rs                            |  22 +-
 src/tui/view/component/recipe_pane.rs         | 170 +++++++++---
 src/tui/view/state/persistence.rs             |   8 +
 test_data/insomnia.json                       |  82 ++----
 test_data/insomnia_imported.yml               |   4 +-
 test_data/regression.yml                      |   8 +
 15 files changed, 473 insertions(+), 240 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e83962da..0b030a1f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,9 +8,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ### Added
 
-- JSON bodies can now be defined with the `!json` tag [#242](https://github.com/LucasPickering/slumber/issues/242)
-  - This should make JSON requests more convenient to write, because you no longer have to specify the `Content-Type` header yourself
-  - [See docs](https://slumber.lucaspickering.me/book/api/request_collection/recipe_body.html)
+- Structured bodies can now be defined with tags on the `body` field of a recipe, making it more convenient to construct bodies of common types. Supported types are:
+  - `!json` [#242](https://github.com/LucasPickering/slumber/issues/242)
+  - `!form_urlencoded` [#244](https://github.com/LucasPickering/slumber/issues/244)
+  - [See docs](https://slumber.lucaspickering.me/book/api/request_collection/recipe_body.html) for usage instructions
 - Templates can now render binary values in certain contexts
   - [See docs](https://slumber.lucaspickering.me/book/user_guide/templates.html#binary-templates)
 
diff --git a/README.md b/README.md
index 204d635c..83fb5966 100644
--- a/README.md
+++ b/README.md
@@ -40,6 +40,11 @@ requests:
   get: !request
     method: GET
     url: https://httpbin.org/get
+
+  post: !request
+    method: POST
+    url: https://httpbin.org/post
+    body: !json { "id": 3, "name": "Slumber" }
 ```
 
 Create this file, then run the TUI with `slumber`.
diff --git a/docs/src/api/request_collection/recipe_body.md b/docs/src/api/request_collection/recipe_body.md
index 61db4b5e..f80743bb 100644
--- a/docs/src/api/request_collection/recipe_body.md
+++ b/docs/src/api/request_collection/recipe_body.md
@@ -8,9 +8,10 @@ In addition, you can pass any [`Template`](./template.md) to render any text or
 
 The following content types have first-class support. Slumber will automatically set the `Content-Type` header to the specified value, but you can override this simply by providing your own value for the header.
 
-| Variant | Type | `Content-Type` Header | Description                                                      |
-| ------- | ---- | --------------------- | ---------------------------------------------------------------- |
-| `!json` | Any  | `application/json`    | Structured JSON body, where all strings are treated as templates |
+| Variant            | Type                                         | `Content-Type`                      | Description                                                                                               |
+| ------------------ | -------------------------------------------- | ----------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `!json`            | Any                                          | `application/json`                  | Structured JSON body; all strings are treated as templates                                                |
+| `!form_urlencoded` | [`mapping[string, Template]`](./template.md) | `application/x-www-form-urlencoded` | URL-encoded form data; [see here for more](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST |
 
 ## Examples
 
diff --git a/slumber.yml b/slumber.yml
index 2718091c..b1fa56e3 100644
--- a/slumber.yml
+++ b/slumber.yml
@@ -45,8 +45,9 @@ requests:
       fast: no_thanks
     headers:
       Accept: application/json
-    body:
-      !json { "username": "{{username}}", "password": "{{chains.password}}" }
+    body: !form_urlencoded
+      username: "{{username}}"
+      password: "{{chains.password}}"
 
   users: !folder
     name: Users
diff --git a/src/collection.rs b/src/collection.rs
index 8649696a..fbb87010 100644
--- a/src/collection.rs
+++ b/src/collection.rs
@@ -523,6 +523,21 @@ mod tests {
                                 "Accept".into() => "application/json".into(),
                             },
                         }),
+                        RecipeNode::Recipe(Recipe {
+                            id: "form_urlencoded_body".into(),
+                            name: Some("Modify User".into()),
+                            method: Method::Put,
+                            url: "{{host}}/anything/{{user_guid}}".into(),
+
+                            body: Some(RecipeBody::FormUrlencoded(indexmap! {
+                                "username".into() => "new username".into()
+                            })),
+                            authentication: None,
+                            query: indexmap! {},
+                            headers: indexmap! {
+                                "Accept".into() => "application/json".into(),
+                            },
+                        }),
                     ]),
                 }),
             ])
diff --git a/src/collection/cereal.rs b/src/collection/cereal.rs
index d5498a6a..a29610ff 100644
--- a/src/collection/cereal.rs
+++ b/src/collection/cereal.rs
@@ -2,8 +2,8 @@
 
 use crate::{
     collection::{
-        recipe_tree::RecipeNode, Chain, ChainId, JsonBody, Profile, ProfileId,
-        Recipe, RecipeBody, RecipeId,
+        recipe_tree::RecipeNode, Chain, ChainId, Profile, ProfileId, Recipe,
+        RecipeBody, RecipeId,
     },
     template::Template,
 };
@@ -160,7 +160,9 @@ impl RecipeBody {
     // by macros, but we need custom implementation
     const STRUCT_NAME: &'static str = "RecipeBody";
     const VARIANT_JSON: &'static str = "json";
-    const ALL_VARIANTS: &'static [&'static str] = &[Self::VARIANT_JSON];
+    const VARIANT_FORM_URLENCODED: &'static str = "form_urlencoded";
+    const ALL_VARIANTS: &'static [&'static str] =
+        &[Self::VARIANT_JSON, Self::VARIANT_FORM_URLENCODED];
 }
 
 /// Custom serialization for RecipeBody, so the `Raw` variant serializes as a
@@ -180,6 +182,13 @@ impl Serialize for RecipeBody {
                 Self::VARIANT_JSON,
                 value,
             ),
+            RecipeBody::FormUrlencoded(value) => serializer
+                .serialize_newtype_variant(
+                    Self::STRUCT_NAME,
+                    2,
+                    Self::VARIANT_FORM_URLENCODED,
+                    value,
+                ),
         }
     }
 }
@@ -235,9 +244,12 @@ impl<'de> Deserialize<'de> for RecipeBody {
             {
                 let (tag, value) = data.variant::<String>()?;
                 match tag.as_str() {
-                    RecipeBody::VARIANT_JSON => Ok(RecipeBody::Json(
-                        value.newtype_variant::<JsonBody>()?,
-                    )),
+                    RecipeBody::VARIANT_JSON => {
+                        Ok(RecipeBody::Json(value.newtype_variant()?))
+                    }
+                    RecipeBody::VARIANT_FORM_URLENCODED => {
+                        Ok(RecipeBody::FormUrlencoded(value.newtype_variant()?))
+                    }
                     other => Err(A::Error::unknown_variant(
                         other,
                         RecipeBody::ALL_VARIANTS,
@@ -340,6 +352,7 @@ pub mod serde_duration {
 mod tests {
     use super::*;
     use crate::test_util::assert_err;
+    use indexmap::indexmap;
     use rstest::rstest;
     use serde::Serialize;
     use serde_json::json;
@@ -380,20 +393,31 @@ mod tests {
     )]
     #[case::json(
         RecipeBody::Json(json!({"user": "{{user_id}}"}).into()),
-        serde_yaml::Value::Tagged(Box::new(TaggedValue{
+        serde_yaml::Value::Tagged(Box::new(TaggedValue {
             tag: Tag::new("json"),
-            value: [
-                (serde_yaml::Value::from("user"), "{{user_id}}".into())
-            ].into_iter().collect::<Mapping>().into()
+            value: mapping([("user", "{{user_id}}")])
         })),
     )]
     #[case::json_nested(
         RecipeBody::Json(json!(r#"{"warning": "NOT an object"}"#).into()),
-        serde_yaml::Value::Tagged(Box::new(TaggedValue{
+        serde_yaml::Value::Tagged(Box::new(TaggedValue {
             tag: Tag::new("json"),
             value: r#"{"warning": "NOT an object"}"#.into()
         })),
     )]
+    #[case::form_urlencoded(
+        RecipeBody::FormUrlencoded(indexmap! {
+            "username".into() => "{{username}}".into(),
+            "password".into() => "{{chains.password}}".into(),
+        }),
+        serde_yaml::Value::Tagged(Box::new(TaggedValue {
+            tag: Tag::new("form_urlencoded"),
+            value: mapping([
+                ("username", "{{username}}"),
+                ("password", "{{chains.password}}"),
+            ])
+        }))
+    )]
     fn test_serde_recipe_body(
         #[case] body: RecipeBody,
         #[case] yaml: impl Into<serde_yaml::Value>,
@@ -429,7 +453,14 @@ mod tests {
             tag: Tag::new("raw"),
             value: "{{user_id}}".into()
         })),
-        "unknown variant `raw`, expected `json`",
+        "unknown variant `raw`, expected `json` or `form_urlencoded`",
+    )]
+    #[case::form_urlencoded_wrong_type(
+        serde_yaml::Value::Tagged(Box::new(TaggedValue{
+            tag: Tag::new("form_urlencoded"),
+            value: "{{user_id}}".into()
+        })),
+        "invalid type: string \"{{user_id}}\", expected a map"
     )]
     fn test_deserialize_recipe_error(
         #[case] yaml: impl Into<serde_yaml::Value>,
@@ -501,4 +532,17 @@ mod tests {
     ) {
         assert_de_tokens_error::<WrapDuration>(&[Token::Str(s)], error)
     }
+
+    /// Build a YAML mapping
+    fn mapping(
+        fields: impl IntoIterator<Item = (&'static str, &'static str)>,
+    ) -> serde_yaml::Value {
+        fields
+            .into_iter()
+            .map(|(k, v)| {
+                (serde_yaml::Value::from(k), serde_yaml::Value::from(v))
+            })
+            .collect::<Mapping>()
+            .into()
+    }
 }
diff --git a/src/collection/insomnia.rs b/src/collection/insomnia.rs
index f9e190c0..78e79375 100644
--- a/src/collection/insomnia.rs
+++ b/src/collection/insomnia.rs
@@ -189,6 +189,23 @@ struct Body {
     /// This field is only present for text-like bodies (e.g. *not* forms)
     #[serde(default)]
     text: Option<Template>,
+    /// Present for form-like bodies
+    #[serde(default)]
+    params: Vec<FormParam>,
+}
+
+impl Body {
+    fn try_text(self) -> anyhow::Result<Template> {
+        self.text
+            .ok_or_else(|| anyhow!("Body missing `text` field"))
+    }
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct FormParam {
+    name: String,
+    value: String,
 }
 
 impl Grouped {
@@ -335,18 +352,25 @@ impl TryFrom<Body> for RecipeBody {
     type Error = anyhow::Error;
 
     fn try_from(body: Body) -> anyhow::Result<Self> {
-        let text = body.text.ok_or_else(|| anyhow!("Missing `text` field"))?;
-
         let body = if body.mime_type == mime::APPLICATION_JSON {
             // Parse JSON to our own JSON equivalent
             let json: JsonBody<String> =
-                serde_json::from_str::<serde_json::Value>(text.as_str())
-                    .context("Error parsing body as JSON")?
-                    .into();
+                serde_json::from_str::<serde_json::Value>(
+                    body.try_text()?.as_str(),
+                )
+                .context("Error parsing body as JSON")?
+                .into();
             // Convert each string into a template *without* parsing
             RecipeBody::Json(json.map(Template::dangerous))
+        } else if body.mime_type == mime::APPLICATION_WWW_FORM_URLENCODED {
+            RecipeBody::FormUrlencoded(
+                body.params
+                    .into_iter()
+                    .map(|param| (param.name, Template::dangerous(param.value)))
+                    .collect(),
+            )
         } else {
-            RecipeBody::Raw(text)
+            RecipeBody::Raw(body.try_text()?)
         };
         Ok(body)
     }
diff --git a/src/collection/models.rs b/src/collection/models.rs
index 399746f2..6a3871e7 100644
--- a/src/collection/models.rs
+++ b/src/collection/models.rs
@@ -13,6 +13,7 @@ use derive_more::{Deref, Display, From, FromStr};
 use equivalent::Equivalent;
 use indexmap::IndexMap;
 use itertools::Itertools;
+use mime::Mime;
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use strum::{EnumIter, IntoEnumIterator};
@@ -288,17 +289,24 @@ pub enum Authentication<T = Template> {
 #[derive(Clone, Debug)]
 #[cfg_attr(test, derive(PartialEq))]
 pub enum RecipeBody {
+    /// Plain string/bytes body
     Raw(Template),
+    /// Strutured JSON, which will be stringified and sent as text
     Json(JsonBody),
+    /// `application/x-www-form-urlencoded` fields
+    FormUrlencoded(IndexMap<String, Template>),
 }
 
 impl RecipeBody {
-    /// For structured bodies, get the corresponding [ContentType]. Return
-    /// `None` for raw bodies
-    pub fn content_type(&self) -> Option<ContentType> {
+    /// Get the MIME type of this body. For raw bodies we have no idea, but for
+    /// structured bodies we can make a very educated guess
+    pub fn mime(&self) -> Option<Mime> {
         match self {
             RecipeBody::Raw(_) => None,
-            RecipeBody::Json(_) => Some(ContentType::Json),
+            RecipeBody::Json(_) => Some(mime::APPLICATION_JSON),
+            RecipeBody::FormUrlencoded(_) => {
+                Some(mime::APPLICATION_WWW_FORM_URLENCODED)
+            }
         }
     }
 }
diff --git a/src/http.rs b/src/http.rs
index 2818bd9c..96a1b4cc 100644
--- a/src/http.rs
+++ b/src/http.rs
@@ -53,11 +53,13 @@ use anyhow::Context;
 use async_recursion::async_recursion;
 use bytes::Bytes;
 use chrono::Utc;
-use futures::future::{self, try_join_all, OptionFuture};
-use indexmap::IndexMap;
+use futures::{
+    future::{self, try_join_all, OptionFuture},
+    Future,
+};
 use reqwest::{
     header::{self, HeaderMap, HeaderName, HeaderValue},
-    Client, Response, Url,
+    Client, RequestBuilder, Response, Url,
 };
 use std::{collections::HashSet, sync::Arc};
 use tokio::try_join;
@@ -119,14 +121,14 @@ impl HttpEngine {
             info_span!("Build request", request_id = %id, ?recipe, ?options)
                 .entered();
 
-        let (client, request) = async {
+        let future = async {
             // Render everything up front so we can parallelize it
             let (url, query, headers, authentication, body) = try_join!(
                 recipe.render_url(template_context),
                 recipe.render_query(options, template_context),
                 recipe.render_headers(options, template_context),
                 recipe.render_authentication(template_context),
-                recipe.render_body(template_context),
+                recipe.render_body(options, template_context),
             )?;
 
             // Build the reqwest request first, so we can have it do all the
@@ -134,36 +136,23 @@ impl HttpEngine {
             // We'll just copy its homework at the end to get our
             // RequestRecord
             let client = self.get_client(&url);
-            let mut builder = client
-                .request(recipe.method.into(), url)
-                .query(&query)
-                .headers(headers);
-
-            match authentication {
-                Some(Authentication::Basic { username, password }) => {
-                    builder = builder.basic_auth(username, password)
-                }
-                Some(Authentication::Bearer(token)) => {
-                    builder = builder.bearer_auth(token)
-                }
-                None => {}
-            };
+            let mut builder =
+                client.request(recipe.method.into(), url).query(&query);
             if let Some(body) = body {
-                builder = builder.body(body);
+                builder = body.apply(builder);
+            }
+            // Set headers *after* body so the use can override the Content-Type
+            // header that was set if they want to
+            builder = builder.headers(headers);
+            if let Some(authentication) = authentication {
+                builder = authentication.apply(builder);
             }
 
             let request = builder.build()?;
             Ok((client, request))
-        }
-        .await
-        .traced()
-        .map_err(|error| {
-            RequestBuildError::new(
-                error,
-                &seed,
-                template_context.selected_profile.clone(),
-            )
-        })?;
+        };
+        let (client, request) =
+            seed.convert_error(future, template_context).await?;
 
         Ok(RequestTicket {
             record: RequestRecord::new(
@@ -192,7 +181,7 @@ impl HttpEngine {
             info_span!("Build request URL", request_id = %id, ?recipe, ?options)
                 .entered();
 
-        let request = async {
+        let future = async {
             // Parallelization!
             let (url, query) = try_join!(
                 recipe.render_url(template_context),
@@ -206,16 +195,8 @@ impl HttpEngine {
                 .query(&query)
                 .build()?;
             Ok(request)
-        }
-        .await
-        .traced()
-        .map_err(|error| {
-            RequestBuildError::new(
-                error,
-                &seed,
-                template_context.selected_profile.clone(),
-            )
-        })?;
+        };
+        let request = seed.convert_error(future, template_context).await?;
 
         Ok(request.url().clone())
     }
@@ -226,23 +207,49 @@ impl HttpEngine {
         seed: RequestSeed,
         template_context: &TemplateContext,
     ) -> Result<Option<Bytes>, RequestBuildError> {
-        let RequestSeed { id, recipe, .. } = &seed;
-        let _ = info_span!("Build request body", request_id = %id, ?recipe)
-            .entered();
+        let RequestSeed {
+            id,
+            recipe,
+            options,
+        } = &seed;
+        let _ =
+            info_span!("Build request body", request_id = %id, ?recipe, ?options)
+                .entered();
 
-        let body = recipe
-            .render_body(template_context)
-            .await
-            .traced()
-            .map_err(|error| {
-                RequestBuildError::new(
-                    error,
-                    &seed,
-                    template_context.selected_profile.clone(),
-                )
-            })?;
+        let future = async {
+            let Some(body) =
+                recipe.render_body(options, template_context).await?
+            else {
+                return Ok(None);
+            };
 
-        Ok(body)
+            match body {
+                // If we have the bytes, we don't need to bother building a
+                // request
+                RenderedBody::Raw(bytes) => Ok(Some(bytes)),
+                // The body is complex - offload the hard work to RequestBuilder
+                RenderedBody::FormUrlencoded(_) => {
+                    let url = Url::parse("http://localhost").unwrap();
+                    let client = self.get_client(&url);
+                    let mut builder = client.request(reqwest::Method::GET, url);
+                    builder = body.apply(builder);
+                    let request = builder.build()?;
+                    // We just added a body so we know it's present, and we
+                    // know it's not a stream. This requires a clone which sucks
+                    // because the bytes are going to get thrown away anyway,
+                    // but nothing we can do about that because of reqwest's API
+                    let bytes = request
+                        .body()
+                        .expect("Body should be present")
+                        .as_bytes()
+                        .expect("Body should be raw bytes")
+                        .to_owned()
+                        .into();
+                    Ok(Some(bytes))
+                }
+            }
+        };
+        seed.convert_error(future, template_context).await
     }
 
     /// Get the appropriate client to use for this request. If the request URL's
@@ -258,6 +265,23 @@ impl HttpEngine {
     }
 }
 
+impl RequestSeed {
+    /// Run the given future and convert any error into [RequestBuildError]
+    async fn convert_error<T>(
+        &self,
+        future: impl Future<Output = anyhow::Result<T>>,
+        template_context: &TemplateContext,
+    ) -> Result<T, RequestBuildError> {
+        future.await.traced().map_err(|error| RequestBuildError {
+            profile_id: template_context.selected_profile.clone(),
+            recipe_id: self.recipe.id.clone(),
+            id: self.id,
+            time: Utc::now(),
+            error,
+        })
+    }
+}
+
 impl RequestTicket {
     /// Launch an HTTP request. Upon completion, it will automatically be
     /// registered in the database for posterity.
@@ -361,7 +385,7 @@ impl Recipe {
         &self,
         options: &BuildOptions,
         template_context: &TemplateContext,
-    ) -> anyhow::Result<IndexMap<String, String>> {
+    ) -> anyhow::Result<Vec<(String, String)>> {
         let iter = self
             .query
             .iter()
@@ -377,10 +401,7 @@ impl Recipe {
                     )?,
                 ))
             });
-        Ok(future::try_join_all(iter)
-            .await?
-            .into_iter()
-            .collect::<IndexMap<String, String>>())
+        future::try_join_all(iter).await
     }
 
     /// Render all headers specified by the user. This will *not* include
@@ -395,12 +416,11 @@ impl Recipe {
         // Set Content-Type based on the body type. This can be overwritten
         // below if the user explicitly passed a Content-Type value
         if let Some(content_type) =
-            self.body.as_ref().and_then(|body| body.content_type())
+            self.body.as_ref().and_then(|body| body.mime())
         {
             headers.insert(
                 header::CONTENT_TYPE,
                 content_type
-                    .mime()
                     .as_ref()
                     // A MIME type should always be a valid header value
                     .try_into()
@@ -501,27 +521,58 @@ impl Recipe {
     /// Render request body
     async fn render_body(
         &self,
+        options: &BuildOptions,
         template_context: &TemplateContext,
-    ) -> anyhow::Result<Option<Bytes>> {
+    ) -> anyhow::Result<Option<RenderedBody>> {
         let Some(body) = &self.body else {
             return Ok(None);
         };
 
-        let bytes = match body {
-            RecipeBody::Raw(body) => body
-                .render(template_context)
-                .await
-                .context("Error rendering body")?
-                .into(),
+        let rendered = match body {
+            RecipeBody::Raw(body) => RenderedBody::Raw(
+                body.render(template_context)
+                    .await
+                    .context("Error rendering body")?
+                    .into(),
+            ),
             // Recursively render the JSON body
-            RecipeBody::Json(value) => value
-                .render(template_context)
-                .await
-                .context("Error rendering body")?
-                .to_string()
-                .into(),
+            RecipeBody::Json(value) => RenderedBody::Raw(
+                value
+                    .render(template_context)
+                    .await
+                    .context("Error rendering body")?
+                    .to_string()
+                    .into(),
+            ),
+            RecipeBody::FormUrlencoded(fields) => {
+                let iter = fields
+                    .iter()
+                    // Remove disabled fields
+                    .filter(|(k, _)| !options.disabled_form_fields.contains(*k))
+                    .map(|(k, v)| async move {
+                        Ok::<_, anyhow::Error>((
+                            k.clone(),
+                            v.render_string(template_context).await.context(
+                                format!("Error rendering form field `{k}`"),
+                            )?,
+                        ))
+                    });
+                let rendered = try_join_all(iter).await?;
+                RenderedBody::FormUrlencoded(rendered)
+            }
         };
-        Ok(Some(bytes))
+        Ok(Some(rendered))
+    }
+}
+
+impl Authentication<String> {
+    fn apply(self, builder: RequestBuilder) -> RequestBuilder {
+        match self {
+            Authentication::Basic { username, password } => {
+                builder.basic_auth(username, password)
+            }
+            Authentication::Bearer(token) => builder.bearer_auth(token),
+        }
     }
 }
 
@@ -564,6 +615,25 @@ impl JsonBody {
     }
 }
 
+/// Body ready to be added to the request. Each variant corresponds to a method
+/// by which we'll add it to the request. This means it is **not** 1:1 with
+/// [RecipeBody]
+enum RenderedBody {
+    Raw(Bytes),
+    /// Value is `String` because only string data can be URL-encoded
+    FormUrlencoded(Vec<(String, String)>),
+}
+
+impl RenderedBody {
+    fn apply(self, builder: RequestBuilder) -> RequestBuilder {
+        // Set body. The variant tells us _how_ to set it
+        match self {
+            RenderedBody::Raw(bytes) => builder.body(bytes),
+            RenderedBody::FormUrlencoded(fields) => builder.form(&fields),
+        }
+    }
+}
+
 impl From<Method> for reqwest::Method {
     fn from(method: Method) -> Self {
         match method {
@@ -610,7 +680,7 @@ mod tests {
         },
         test_util::{by_id, header_map, Factory},
     };
-    use indexmap::indexmap;
+    use indexmap::{indexmap, IndexMap};
     use pretty_assertions::assert_eq;
     use reqwest::{Method, StatusCode};
     use rstest::{fixture, rstest};
@@ -842,12 +912,29 @@ mod tests {
         "application/json"
     )]
     // Content-Type has been overridden by an explicit header
-    #[case::content_type_override(
+    #[case::json_content_type_override(
         RecipeBody::Json(json!({"group_id": "{{group_id}}"}).into()),
         Some("text/plain"),
         br#"{"group_id":"3"}"#,
         "text/plain"
     )]
+    #[case::form_urlencoded(
+        RecipeBody::FormUrlencoded(indexmap! {
+            "user_id".into() => "{{user_id}}".into(),
+            "token".into() => "{{token}}".into()
+        }),
+        None,
+        b"user_id=1&token=hunter2",
+        "application/x-www-form-urlencoded"
+    )]
+    // reqwest sets the content type when initializing the body, so make sure
+    // that doesn't override the user's value
+    #[case::form_urlencoded_content_type_override(
+        RecipeBody::FormUrlencoded(Default::default()),
+        Some("text/plain"),
+        b"",
+        "text/plain"
+    )]
     #[tokio::test]
     async fn test_structured_body(
         http_engine: HttpEngine,
@@ -888,9 +975,10 @@ mod tests {
         );
     }
 
+    /// Test disabling query params, headers, and form fields
     #[rstest]
     #[tokio::test]
-    async fn test_disable_headers_and_query_params(
+    async fn test_build_options(
         http_engine: HttpEngine,
         template_context: TemplateContext,
     ) {
@@ -908,7 +996,10 @@ mod tests {
                 "content-type".into() => "text/plain".into(),
             },
             // This should implicitly set the content-type header
-            body: Some(RecipeBody::Json(json!("{{group_id}}").into())),
+            body: Some(RecipeBody::FormUrlencoded(indexmap! {
+                "user_id".into() => "{{user_id}}".into(),
+                "token".into() => "{{token}}".into(),
+            })),
             ..Recipe::factory(())
         };
         let recipe_id = recipe.id.clone();
@@ -916,10 +1007,9 @@ mod tests {
         let seed = RequestSeed::new(
             recipe,
             BuildOptions {
-                // By disabling this one, we allow the implicit content type to
-                // show through
                 disabled_headers: ["content-type".to_owned()].into(),
                 disabled_query_parameters: ["fast".to_owned()].into(),
+                disabled_form_fields: ["token".to_owned()].into(),
             },
         );
         let ticket = http_engine.build(seed, &template_context).await.unwrap();
@@ -934,9 +1024,9 @@ mod tests {
                 url: "http://localhost/url?mode=sudo".parse().unwrap(),
                 headers: header_map([
                     ("accept", "application/json"),
-                    ("content-type", "application/json"),
+                    ("content-type", "application/x-www-form-urlencoded"),
                 ]),
-                body: Some(b"\"3\"".as_slice().into()),
+                body: Some(b"user_id=1".as_slice().into()),
             }
         );
     }
diff --git a/src/http/models.rs b/src/http/models.rs
index 03f5e680..ed381b97 100644
--- a/src/http/models.rs
+++ b/src/http/models.rs
@@ -86,12 +86,15 @@ pub struct BuildOptions {
     /// Which query parameters should be excluded?  A blacklist allows the
     /// default to be "include all".
     pub disabled_query_parameters: HashSet<String>,
+    /// For form bodies, which form fields should be excluded?
+    pub disabled_form_fields: HashSet<String>,
 }
 
 /// A request ready to be launched into through the stratosphere. This is
 /// basically a two-part ticket: the request is the part we'll hand to the HTTP
 /// engine to be launched, and the record is the ticket stub we'll keep for
-/// ourselves (to display to the user).
+/// ourselves (to display to the user
+#[derive(Debug)]
 pub struct RequestTicket {
     /// A record of the request that we can hang onto and persist
     pub(super) record: Arc<RequestRecord>,
@@ -522,23 +525,6 @@ pub struct RequestBuildError {
     pub time: DateTime<Utc>,
 }
 
-impl RequestBuildError {
-    /// Wrap a given error with context from the build process
-    pub fn new(
-        error: anyhow::Error,
-        seed: &RequestSeed,
-        profile_id: Option<ProfileId>,
-    ) -> Self {
-        Self {
-            profile_id,
-            recipe_id: seed.recipe.id.clone(),
-            id: seed.id,
-            time: Utc::now(),
-            error,
-        }
-    }
-}
-
 #[cfg(test)]
 impl PartialEq for RequestBuildError {
     fn eq(&self, other: &Self) -> bool {
diff --git a/src/tui/view/component/recipe_pane.rs b/src/tui/view/component/recipe_pane.rs
index d06b589a..c584e734 100644
--- a/src/tui/view/component/recipe_pane.rs
+++ b/src/tui/view/component/recipe_pane.rs
@@ -74,7 +74,7 @@ struct RecipeState {
     url: TemplatePreview,
     query: Component<Persistent<SelectState<RowState, TableState>>>,
     headers: Component<Persistent<SelectState<RowState, TableState>>>,
-    body: Option<Component<TextWindow<TemplatePreview>>>,
+    body: Option<Component<RecipeBodyDisplay>>,
     authentication: Option<Component<AuthenticationDisplay>>,
 }
 
@@ -99,14 +99,6 @@ enum Tab {
 }
 impl FixedSelect for Tab {}
 
-/// One row in the query/header table
-#[derive(Debug)]
-struct RowState {
-    key: String,
-    value: TemplatePreview,
-    enabled: Persistent<bool>,
-}
-
 /// Items in the actions popup menu. This is also used by the recipe list
 /// component, so the action is handled in the parent.
 #[derive(Copy, Clone, Debug, Display, EnumCount, EnumIter, PartialEq)]
@@ -138,9 +130,21 @@ impl RecipePane {
                     .collect()
             }
 
+            let disabled_form_fields = state
+                .body
+                .as_ref()
+                .and_then(|body| match body.data() {
+                    RecipeBodyDisplay::Raw(_) => None,
+                    RecipeBodyDisplay::Form(form) => {
+                        Some(to_disabled_set(form.data()))
+                    }
+                })
+                .unwrap_or_default();
+
             BuildOptions {
                 disabled_headers: to_disabled_set(state.headers.data()),
                 disabled_query_parameters: to_disabled_set(state.query.data()),
+                disabled_form_fields,
             }
         } else {
             // Shouldn't be possible, because state is initialized on first
@@ -250,12 +254,7 @@ impl<'a> Draw<RecipePaneProps<'a>> for RecipePane {
             match self.tabs.data().selected() {
                 Tab::Body => {
                     if let Some(body) = &recipe_state.body {
-                        body.draw(
-                            frame,
-                            TextWindowProps::default(),
-                            content_area,
-                            true,
-                        );
+                        body.draw(frame, (), content_area, true);
                     }
                 }
                 Tab::Query => recipe_state.query.draw(
@@ -347,10 +346,11 @@ impl RecipeState {
             )
             .into(),
             body: recipe.body.as_ref().map(|body| {
-                TextWindow::new(preview_body(
+                RecipeBodyDisplay::new(
                     body,
                     selected_profile_id.cloned(),
-                ))
+                    &recipe.id,
+                )
                 .into()
             }),
             // Map authentication type
@@ -436,31 +436,119 @@ impl Draw for AuthenticationDisplay {
     }
 }
 
-/// Generate [TemplatePreview] for a body
-fn preview_body(
-    body: &RecipeBody,
-    profile_id: Option<ProfileId>,
-) -> TemplatePreview {
-    let template = match body {
-        RecipeBody::Raw(body) => body.clone(),
-        RecipeBody::Json(value) => {
-            // We want to pretty-print the JSON body. We *could* map from
-            // JsonBody<Template> -> JsonBody<TemplatePreview> then stringify
-            // that on every render, but then we'd have to implement JSON pretty
-            // printing ourselves. The easier method is to just turn this whole
-            // JSON struct into a single string (with unrendered templates),
-            // then parse that back as one big template. If it's stupid but it
-            // works, it's not stupid.
-            let value: serde_json::Value =
-                value.map_ref(|template| template.to_string()).into();
-            let stringified = format!("{value:#}");
-            // This template is composed valid templates, surrounded by JSON
-            // syntax. In no world should that result in an invalid template
-            Template::parse(stringified)
-                .expect("Unexpected template parse failure")
+/// Render recipe body. The variant is based on the incoming body type, and
+/// determines the representation
+#[derive(Debug)]
+enum RecipeBodyDisplay {
+    Raw(Component<TextWindow<TemplatePreview>>),
+    Form(Component<Persistent<SelectState<RowState, TableState>>>),
+}
+
+impl RecipeBodyDisplay {
+    fn new(
+        body: &RecipeBody,
+        selected_profile_id: Option<ProfileId>,
+        recipe_id: &RecipeId,
+    ) -> Self {
+        match body {
+            RecipeBody::Raw(body) => Self::Raw(
+                TextWindow::new(TemplatePreview::new(
+                    body.clone(),
+                    selected_profile_id,
+                ))
+                .into(),
+            ),
+            RecipeBody::Json(value) => {
+                // We want to pretty-print the JSON body. We *could* map from
+                // JsonBody<Template> -> JsonBody<TemplatePreview> then
+                // stringify that on every render, but then we'd have to
+                // implement JSON pretty printing ourselves. The easier method
+                // is to just turn this whole JSON struct into a single string
+                // (with unrendered templates), then parse that back as one big
+                // template. If it's stupid but it works, it's not stupid.
+                let value: serde_json::Value =
+                    value.map_ref(|template| template.to_string()).into();
+                let stringified = format!("{value:#}");
+                // This template is composed valid templates, surrounded by JSON
+                // syntax. In no world should that result in an invalid template
+                let template = Template::parse(stringified)
+                    .expect("Unexpected template parse failure");
+                Self::Raw(
+                    TextWindow::new(TemplatePreview::new(
+                        template,
+                        selected_profile_id,
+                    ))
+                    .into(),
+                )
+            }
+            RecipeBody::FormUrlencoded(fields) => {
+                let form_items = fields
+                    .iter()
+                    .map(|(field, value)| {
+                        RowState::new(
+                            field.clone(),
+                            TemplatePreview::new(
+                                value.clone(),
+                                selected_profile_id.clone(),
+                            ),
+                            PersistentKey::RecipeFormField {
+                                recipe: recipe_id.clone(),
+                                field: field.clone(),
+                            },
+                        )
+                    })
+                    .collect();
+                let select = SelectState::builder(form_items)
+                    .on_submit(RowState::on_submit)
+                    .build();
+                Self::Form(
+                    Persistent::new(
+                        PersistentKey::RecipeSelectedFormField(
+                            recipe_id.clone(),
+                        ),
+                        select,
+                    )
+                    .into(),
+                )
+            }
+        }
+    }
+}
+
+impl EventHandler for RecipeBodyDisplay {
+    fn children(&mut self) -> Vec<Component<&mut dyn EventHandler>> {
+        match self {
+            RecipeBodyDisplay::Raw(preview) => vec![preview.as_child()],
+            RecipeBodyDisplay::Form(form) => vec![form.as_child()],
+        }
+    }
+}
+
+impl Draw for RecipeBodyDisplay {
+    fn draw(&self, frame: &mut Frame, _: (), metadata: DrawMetadata) {
+        match self {
+            RecipeBodyDisplay::Raw(preview) => preview.draw(
+                frame,
+                TextWindowProps::default(),
+                metadata.area(),
+                true,
+            ),
+            RecipeBodyDisplay::Form(form) => form.draw(
+                frame,
+                to_table(form.data(), ["", "Field", "Value"]).generate(),
+                metadata.area(),
+                true,
+            ),
         }
-    };
-    TemplatePreview::new(template, profile_id)
+    }
+}
+
+/// One row in the query/header table
+#[derive(Debug)]
+struct RowState {
+    key: String,
+    value: TemplatePreview,
+    enabled: Persistent<bool>,
 }
 
 impl RowState {
diff --git a/src/tui/view/state/persistence.rs b/src/tui/view/state/persistence.rs
index c383e5e7..942737a2 100644
--- a/src/tui/view/state/persistence.rs
+++ b/src/tui/view/state/persistence.rs
@@ -98,14 +98,22 @@ pub enum PersistentKey {
     RecipeCollapsed,
     /// Selected tab in the recipe pane
     RecipeTab,
+
     /// Selected query param, per recipe. Value is the query param name
     RecipeSelectedQuery(RecipeId),
     /// Toggle state for a single recipe+query param
     RecipeQuery { recipe: RecipeId, param: String },
+
     /// Selected header, per recipe. Value is the header name
     RecipeSelectedHeader(RecipeId),
     /// Toggle state for a single recipe+header
     RecipeHeader { recipe: RecipeId, header: String },
+
+    /// Selected form field, per recipe. Value is the field name
+    RecipeSelectedFormField(RecipeId),
+    /// Toggle state for a single recipe+form field
+    RecipeFormField { recipe: RecipeId, field: String },
+
     /// Response body JSONPath query (**not** related to query params)
     ResponseBodyQuery(RecipeId),
 }
diff --git a/test_data/insomnia.json b/test_data/insomnia.json
index 30d5fb37..2c91e0cf 100644
--- a/test_data/insomnia.json
+++ b/test_data/insomnia.json
@@ -1,7 +1,7 @@
 {
   "_type": "export",
   "__export_format": 4,
-  "__export_date": "2024-06-02T00:00:08.951Z",
+  "__export_date": "2024-06-04T21:09:14.812Z",
   "__export_source": "insomnia.desktop.app:v9.2.0",
   "resources": [
     {
@@ -37,13 +37,10 @@
           "name": "Content-Type",
           "value": "application/x-www-form-urlencoded"
         },
-        {
-          "name": "User-Agent",
-          "value": "insomnia/8.6.1"
-        }
+        { "name": "User-Agent", "value": "insomnia/8.6.1" }
       ],
       "authentication": {},
-      "metaSortKey": -1712668704494,
+      "metaSortKey": -1712668704594,
       "isPrivate": false,
       "pathParameters": [],
       "settingStoreCookies": true,
@@ -73,21 +70,12 @@
       "name": "With Text Body",
       "description": "",
       "method": "POST",
-      "body": {
-        "mimeType": "text/plain",
-        "text": "hello!"
-      },
+      "body": { "mimeType": "text/plain", "text": "hello!" },
       "preRequestScript": "",
       "parameters": [],
       "headers": [
-        {
-          "name": "Content-Type",
-          "value": "text/plain"
-        },
-        {
-          "name": "User-Agent",
-          "value": "insomnia/8.6.1"
-        }
+        { "name": "Content-Type", "value": "text/plain" },
+        { "name": "User-Agent", "value": "insomnia/8.6.1" }
       ],
       "authentication": {},
       "metaSortKey": -1712668712522,
@@ -110,7 +98,7 @@
       "description": "",
       "environment": {},
       "environmentPropertyOrder": null,
-      "metaSortKey": -1712668700000,
+      "metaSortKey": -1712668704494,
       "_type": "request_group"
     },
     {
@@ -129,14 +117,8 @@
       "preRequestScript": "",
       "parameters": [],
       "headers": [
-        {
-          "name": "Content-Type",
-          "value": "application/json"
-        },
-        {
-          "name": "User-Agent",
-          "value": "insomnia/8.6.1"
-        }
+        { "name": "Content-Type", "value": "application/json" },
+        { "name": "User-Agent", "value": "insomnia/8.6.1" }
       ],
       "authentication": {},
       "metaSortKey": -1712668712422,
@@ -162,12 +144,7 @@
       "body": {},
       "preRequestScript": "",
       "parameters": [],
-      "headers": [
-        {
-          "name": "User-Agent",
-          "value": "insomnia/8.6.1"
-        }
-      ],
+      "headers": [{ "name": "User-Agent", "value": "insomnia/8.6.1" }],
       "authentication": {
         "type": "bearer",
         "token": " {% response 'body', 'req_3bc2de939f1a4d1ebc00835cbefd6b5d', 'b64::JC5oZWFkZXJzLkhvc3Q=::46b', 'when-expired', 60 %}"
@@ -207,12 +184,7 @@
       "body": {},
       "preRequestScript": "",
       "parameters": [],
-      "headers": [
-        {
-          "name": "User-Agent",
-          "value": "insomnia/8.6.1"
-        }
-      ],
+      "headers": [{ "name": "User-Agent", "value": "insomnia/8.6.1" }],
       "authentication": {
         "type": "digest",
         "disabled": false,
@@ -242,12 +214,7 @@
       "body": {},
       "preRequestScript": "",
       "parameters": [],
-      "headers": [
-        {
-          "name": "User-Agent",
-          "value": "insomnia/8.6.1"
-        }
-      ],
+      "headers": [{ "name": "User-Agent", "value": "insomnia/8.6.1" }],
       "authentication": {
         "type": "basic",
         "useISO88591": false,
@@ -278,12 +245,7 @@
       "body": {},
       "preRequestScript": "",
       "parameters": [],
-      "headers": [
-        {
-          "name": "User-Agent",
-          "value": "insomnia/8.6.1"
-        }
-      ],
+      "headers": [{ "name": "User-Agent", "value": "insomnia/8.6.1" }],
       "authentication": {},
       "metaSortKey": -1712668873967,
       "isPrivate": false,
@@ -329,11 +291,9 @@
         "greeting": "hello!"
       },
       "dataPropertyOrder": {
-        "&": [
-          "host",
-          "greeting"
-        ]
+        "&": ["host", "greeting"]
       },
+      "dataPropertyOrder": { "&": ["host"] },
       "color": null,
       "isPrivate": false,
       "metaSortKey": 1710624684621,
@@ -345,16 +305,8 @@
       "modified": 1713480842495,
       "created": 1710624689589,
       "name": "Remote",
-      "data": {
-        "host": "https://httpbin.org",
-        "greeting": "howdy"
-      },
-      "dataPropertyOrder": {
-        "&": [
-          "host",
-          "greeting"
-        ]
-      },
+      "data": { "host": "https://httpbin.org", "greeting": "howdy" },
+      "dataPropertyOrder": { "&": ["host", "greeting"] },
       "color": null,
       "isPrivate": false,
       "metaSortKey": 1710624689589,
diff --git a/test_data/insomnia_imported.yml b/test_data/insomnia_imported.yml
index 184c6921..b654464a 100644
--- a/test_data/insomnia_imported.yml
+++ b/test_data/insomnia_imported.yml
@@ -82,7 +82,9 @@ requests:
     name: Login
     method: POST
     url: https://httpbin.org/anything/login
-    body: null
+    body: !form_urlencoded
+      username: user
+      password: pass
     authentication: null
     query: {}
     headers:
diff --git a/test_data/regression.yml b/test_data/regression.yml
index c7e7fde3..5ea04032 100644
--- a/test_data/regression.yml
+++ b/test_data/regression.yml
@@ -129,3 +129,11 @@ requests:
           password: "{{password}}"
         # Nested JSON is *not* parsed
         body: !json '{"warning": "NOT an object"}'
+
+      form_urlencoded_body: !request
+        <<: *base_recipe
+        name: Modify User
+        method: PUT
+        url: "{{host}}/anything/{{user_guid}}"
+        body: !form_urlencoded
+          username: "new username"