From 2445ae54b28b6f15fdf7e23a24651467e3d5334c Mon Sep 17 00:00:00 2001
From: Lucas Pickering <lucas@lucaspickering.me>
Date: Sat, 11 Nov 2023 05:47:36 -0500
Subject: [PATCH] Pre-parse template strings and switch to nom for parsing

Wow it's a big refactor
---
 CHANGELOG.md                                  |   8 +
 Cargo.lock                                    |   2 +-
 Cargo.toml                                    |   2 +-
 docs/src/SUMMARY.md                           |   2 +-
 docs/src/api/chain.md                         |   2 +-
 docs/src/api/request_recipe.md                |  18 +-
 .../api/{template_string.md => template.md}   |   6 +-
 docs/src/user_guide/templates.md              |   4 +-
 src/collection.rs                             |  33 +-
 src/collection/insomnia.rs                    |  19 +-
 src/factory.rs                                |   8 +-
 src/http/record.rs                            |   6 +
 src/template.rs                               | 596 +++++-------------
 src/template/error.rs                         |  13 +
 src/template/parse.rs                         | 213 +++++++
 src/template/render.rs                        | 346 ++++++++++
 src/tui.rs                                    |   4 +-
 src/tui/message.rs                            |   4 +-
 src/tui/view/component/request.rs             |   4 +-
 src/tui/view/component/template_preview.rs    |  83 ++-
 src/tui/view/util.rs                          |  12 +-
 src/util.rs                                   |   2 +-
 22 files changed, 843 insertions(+), 544 deletions(-)
 rename docs/src/api/{template_string.md => template.md} (58%)
 create mode 100644 src/template/parse.rs
 create mode 100644 src/template/render.rs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9724bfda..1c035666 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Changelog
 
+## [Unreleased] - ReleaseDate
+
+### Changed
+
+- Parse templates up front instead of during render
+- Switch to nom for template parsing
+  - Parse errors should be better now
+
 ## [0.6.0] - 2023-11-11
 
 ### Added
diff --git a/Cargo.lock b/Cargo.lock
index cf902915..b5e07328 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1579,9 +1579,9 @@ dependencies = [
  "futures",
  "indexmap 2.1.0",
  "itertools",
+ "nom",
  "notify",
  "ratatui",
- "regex",
  "reqwest",
  "rmp-serde",
  "rstest",
diff --git a/Cargo.toml b/Cargo.toml
index e3d3c073..523f9352 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,9 +22,9 @@ dirs = "^5.0.1"
 futures = "^0.3.28"
 indexmap = {version = "^2.0.1", features = ["serde"]}
 itertools = "^0.11.0"
+nom = "7.1.3"
 notify = {version = "^6.1.1", default-features = false, features = ["macos_fsevent"]}
 ratatui = "^0.24.0"
-regex = {version = "^1.9.5", features = ["pattern"]}
 reqwest = {version = "^0.11.20", default-features = false, features = ["rustls-tls"]}
 rmp-serde = "^1.1.2"
 rusqlite = {version = "^0.29.0", default-features = false, features = ["bundled", "chrono", "uuid"]}
diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md
index f75cc048..ab10c26c 100644
--- a/docs/src/SUMMARY.md
+++ b/docs/src/SUMMARY.md
@@ -18,4 +18,4 @@
   - [Request Recipe](./api/request_recipe.md)
   - [Chain](./api/chain.md)
   - [Chain Source](./api/chain_source.md)
-  - [Template String](./api/template_string.md)
+  - [Template](./api/template.md)
diff --git a/docs/src/api/chain.md b/docs/src/api/chain.md
index a7cb05d9..b5207354 100644
--- a/docs/src/api/chain.md
+++ b/docs/src/api/chain.md
@@ -2,7 +2,7 @@
 
 A chain is a intermediate data type to enable complex template values. Chains enable complex value sources and additional customization, such as much values as sensitive to be masked in the UI.
 
-To use a chain in a template string, reference it as `{{chains.<id>}}`.
+To use a chain in a template, reference it as `{{chains.<id>}}`.
 
 ## Fields
 
diff --git a/docs/src/api/request_recipe.md b/docs/src/api/request_recipe.md
index 33bdd755..e8ff346d 100644
--- a/docs/src/api/request_recipe.md
+++ b/docs/src/api/request_recipe.md
@@ -4,15 +4,15 @@ A request recipe defines how to make a particular request. For a REST API, you'l
 
 ## Fields
 
-| Field     | Type                                                      | Description                       | Default       |
-| --------- | --------------------------------------------------------- | --------------------------------- | ------------- |
-| `id`      | `string`                                                  | Unique identifier for this recipe | Required      |
-| `name`    | `string`                                                  | Descriptive name to use in the UI | Value of `id` |
-| `method`  | [`TemplateString`](./template_string.md)                  | HTTP request method               | Required      |
-| `url`     | [`TemplateString`](./template_string.md)                  | HTTP request URL                  | Required      |
-| `query`   | [`mapping[string, TemplateString]`](./template_string.md) | HTTP request query parameters     | `{}`          |
-| `headers` | [`mapping[string, TemplateString]`](./template_string.md) | HTTP request headers              | `{}`          |
-| `body`    | [`TemplateString`](./template_string.md)                  | HTTP request body                 | `null`        |
+| Field     | Type                                         | Description                       | Default       |
+| --------- | -------------------------------------------- | --------------------------------- | ------------- |
+| `id`      | `string`                                     | Unique identifier for this recipe | Required      |
+| `name`    | `string`                                     | Descriptive name to use in the UI | Value of `id` |
+| `method`  | `string`                                     | HTTP request method               | Required      |
+| `url`     | [`Template`](./template.md)                  | HTTP request URL                  | Required      |
+| `query`   | [`mapping[string, Template]`](./template.md) | HTTP request query parameters     | `{}`          |
+| `headers` | [`mapping[string, Template]`](./template.md) | HTTP request headers              | `{}`          |
+| `body`    | [`Template`](./template.md)                  | HTTP request body                 | `null`        |
 
 ## Examples
 
diff --git a/docs/src/api/template_string.md b/docs/src/api/template.md
similarity index 58%
rename from docs/src/api/template_string.md
rename to docs/src/api/template.md
index 6f27dcf1..be7798e9 100644
--- a/docs/src/api/template_string.md
+++ b/docs/src/api/template.md
@@ -1,8 +1,8 @@
-# Template String
+# Template
 
-A template string is represented in YAML as a normal string, and thus supports [all of YAML's string syntaxes](https://www.educative.io/answers/how-to-represent-strings-in-yaml). Template strings receive post-processing that injects dynamic values into the string. A templated value is represented with `{{...}}`.
+A template is represented in YAML as a normal string, and thus supports [all of YAML's string syntaxes](https://www.educative.io/answers/how-to-represent-strings-in-yaml). Templates receive post-processing that injects dynamic values into the string. A templated value is represented with `{{...}}`.
 
-Template strings can generally be used in any _value_ in a request recipe (_not_ in keys). They _cannot_ be used in profiles or chains, to avoid the potential for recursive templating. If this feature would be useful to you, [le tme know](https://github.com/LucasPickering/slumber/issues/15).
+Templates can generally be used in any _value_ in a request recipe (_not_ in keys). They _cannot_ be used in profiles or chains, to avoid the potential for recursive templating. If this feature would be useful to you, [le tme know](https://github.com/LucasPickering/slumber/issues/15).
 
 ## Template Sources
 
diff --git a/docs/src/user_guide/templates.md b/docs/src/user_guide/templates.md
index 0727428f..333a7317 100644
--- a/docs/src/user_guide/templates.md
+++ b/docs/src/user_guide/templates.md
@@ -2,10 +2,10 @@
 
 Templates enable dynamic string construction. Slumber's template language is relatively simple, compared to complex HTML templating languages like Handlebars or Jinja. The goal is to be intuitive and unsurprising. It doesn't support complex features like for loops, conditionals, etc.
 
-All string _values_ (i.e. _not_ keys) in a request collection are template strings, meaning they support templating. The syntax for templating a value into a string is double curly braces `{{...}}`. The contents inside the braces tell Slumber how to retrieve the dynamic value.
+All string _values_ (i.e. _not_ keys) in a request collection are templates, meaning they support templating. The syntax for templating a value into a string is double curly braces `{{...}}`. The contents inside the braces tell Slumber how to retrieve the dynamic value.
 
 TODO add some more content here
 
 ## API Reference
 
-For more detailed configuration info, see the [API reference docs](../api/template_string.md) on template strings.
+For more detailed configuration info, see the [API reference docs](../api/template.md) on templates.
diff --git a/src/collection.rs b/src/collection.rs
index 3343bd64..bd0d6ab8 100644
--- a/src/collection.rs
+++ b/src/collection.rs
@@ -3,7 +3,7 @@
 
 mod insomnia;
 
-use crate::template::TemplateString;
+use crate::template::Template;
 use anyhow::{anyhow, Context};
 use derive_more::{Deref, Display, From};
 use indexmap::IndexMap;
@@ -86,12 +86,12 @@ pub struct RequestRecipe {
     /// *Not* a template string because the usefulness doesn't justify the
     /// complexity
     pub method: String,
-    pub url: TemplateString,
-    pub body: Option<TemplateString>,
+    pub url: Template,
+    pub body: Option<Template>,
     #[serde(default)]
-    pub query: IndexMap<String, TemplateString>,
+    pub query: IndexMap<String, Template>,
     #[serde(default)]
-    pub headers: IndexMap<String, TemplateString>,
+    pub headers: IndexMap<String, Template>,
 }
 
 #[derive(
@@ -114,7 +114,7 @@ pub struct RequestRecipeId(String);
 /// can use it in a template via `{{chains.<chain_id>}}`.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Chain {
-    pub id: String,
+    pub id: ChainId,
     pub source: ChainSource,
     /// Mask chained value in the UI
     #[serde(default)]
@@ -123,6 +123,27 @@ pub struct Chain {
     pub selector: Option<JsonPath>,
 }
 
+#[derive(
+    Clone,
+    Debug,
+    Deref,
+    Default,
+    Display,
+    Eq,
+    From,
+    Hash,
+    PartialEq,
+    Serialize,
+    Deserialize,
+)]
+pub struct ChainId(String);
+
+impl From<&str> for ChainId {
+    fn from(value: &str) -> Self {
+        Self(value.into())
+    }
+}
+
 /// The source of data for a chain
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
diff --git a/src/collection/insomnia.rs b/src/collection/insomnia.rs
index 6411de4c..b7d4f937 100644
--- a/src/collection/insomnia.rs
+++ b/src/collection/insomnia.rs
@@ -3,7 +3,7 @@
 
 use crate::{
     collection::{Profile, RequestCollection, RequestRecipe},
-    template::TemplateString,
+    template::Template,
 };
 use anyhow::Context;
 use indexmap::IndexMap;
@@ -96,7 +96,7 @@ struct Request {
     #[serde(rename = "_id")]
     id: String,
     name: String,
-    url: TemplateString,
+    url: Template,
     method: String,
     authentication: Authentication,
     headers: Vec<Header>,
@@ -114,13 +114,13 @@ enum Authentication {
 #[derive(Debug, Deserialize)]
 struct Header {
     name: String,
-    value: TemplateString,
+    value: Template,
 }
 
 #[derive(Debug, Deserialize)]
 struct Parameter {
     name: String,
-    value: TemplateString,
+    value: Template,
 }
 
 /// This can't be an `Option` because the empty case is an empty object, not
@@ -132,7 +132,7 @@ enum Body {
     #[serde(rename_all = "camelCase")]
     Body {
         mime_type: String,
-        text: TemplateString,
+        text: Template,
     },
     // This matches empty object, so it has to be a struct variant
     Empty {},
@@ -150,17 +150,20 @@ impl From<Environment> for Profile {
 
 impl From<Request> for RequestRecipe {
     fn from(request: Request) -> Self {
-        let mut headers: IndexMap<String, TemplateString> = IndexMap::new();
+        let mut headers: IndexMap<String, Template> = IndexMap::new();
 
         // Preload headers from implicit sources
         if let Body::Body { mime_type, .. } = &request.body {
-            headers.insert("content-type".into(), mime_type.clone().into());
+            headers.insert(
+                "content-type".into(),
+                Template::dangerous_new(mime_type.clone()),
+            );
         }
         match request.authentication {
             Authentication::Bearer { token } => {
                 headers.insert(
                     "authorization".into(),
-                    format!("Bearer {token}").into(),
+                    Template::dangerous_new(format!("Bearer {token}")),
                 );
             }
         }
diff --git a/src/factory.rs b/src/factory.rs
index 5fbd6ab2..08a010b5 100644
--- a/src/factory.rs
+++ b/src/factory.rs
@@ -1,7 +1,7 @@
 use crate::{
     collection::{Chain, ChainSource, RequestRecipeId},
     http::{Body, Repository, Request, RequestId, RequestRecord, Response},
-    template::{Prompt, Prompter, TemplateContext, TemplateString},
+    template::{Prompt, Prompter, Template, TemplateContext},
 };
 use chrono::Utc;
 use factori::{create, factori};
@@ -49,7 +49,7 @@ factori!(RequestRecord, {
 
 factori!(Chain, {
     default {
-        id = String::from("chain1"),
+        id = "chain1".into(),
         source = ChainSource::Request(RequestRecipeId::default()),
         sensitive = false,
         selector = None,
@@ -96,8 +96,8 @@ impl From<&str> for RequestRecipeId {
     }
 }
 
-impl From<&str> for TemplateString {
+impl From<&str> for Template {
     fn from(value: &str) -> Self {
-        value.to_owned().into()
+        value.to_owned().try_into().unwrap()
     }
 }
diff --git a/src/http/record.rs b/src/http/record.rs
index 25e00af6..0f09b41a 100644
--- a/src/http/record.rs
+++ b/src/http/record.rs
@@ -69,6 +69,12 @@ impl RequestId {
     }
 }
 
+impl Default for RequestId {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 /// A complete request+response pairing. This is generated by [HttpEngine::send]
 /// when a response is received successfully for a sent request.
 #[derive(Debug)]
diff --git a/src/template.rs b/src/template.rs
index 7eeff212..af780da7 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -1,37 +1,24 @@
 mod error;
+mod parse;
 mod prompt;
+mod render;
 
 pub use error::{ChainError, TemplateError, TemplateResult};
+pub use parse::Span;
 pub use prompt::{Prompt, Prompter};
 
 use crate::{
-    collection::{Chain, ChainSource, RequestRecipeId},
-    http::{ContentType, Json, Repository},
-    util::ResultExt,
+    collection::Chain,
+    http::Repository,
+    template::{
+        error::TemplateParseError,
+        parse::{TemplateInputChunk, CHAIN_PREFIX, ENV_PREFIX},
+    },
 };
-use anyhow::Context;
-use async_trait::async_trait;
-use derive_more::{Deref, From};
+use derive_more::{Deref, Display};
 use indexmap::IndexMap;
-use regex::Regex;
 use serde::{Deserialize, Serialize};
-use serde_json_path::JsonPath;
-use std::{
-    env::{self},
-    fmt::Debug,
-    ops::Deref as _,
-    path::Path,
-    sync::OnceLock,
-};
-use tokio::{fs, process::Command, sync::oneshot};
-use tracing::{info, instrument, trace};
-
-static TEMPLATE_REGEX: OnceLock<Regex> = OnceLock::new();
-
-/// A string that can contain templated content
-#[derive(Clone, Debug, Deref, From, PartialEq, Serialize, Deserialize)]
-#[deref(forward)]
-pub struct TemplateString(String);
+use std::fmt::Debug;
 
 /// A little container struct for all the data that the user can access via
 /// templating. Unfortunately this has to own all data so templating can be
@@ -50,144 +37,73 @@ pub struct TemplateContext {
     pub prompter: Box<dyn Prompter>,
 }
 
-/// A piece of a rendered template string. A collection of chunks collectively
-/// constitutes a rendered string, and those chunks should be contiguous.
-#[derive(Debug)]
-#[cfg_attr(test, derive(PartialEq))]
-pub enum TemplateChunk {
-    /// Raw unprocessed text, i.e. something **outside** the `{{ }}`. This is
-    /// stored as indexes into the original string, rather than a string
-    /// slice, to allow this to be passed between tasks/threads easily. We
-    /// could store an owned copy here but that would require copying what
-    /// could be a very large block of text.
-    Raw { start: usize, end: usize },
-    /// Outcome of rendering a template key
-    Rendered(String),
-    /// An error occurred while rendering a template key
-    Error(TemplateError),
+/// A immutable string that can contain templated content. The string is parsed
+/// during creation to identify template keys, hence the immutability.
+#[derive(Clone, Debug, Deref, Display, Serialize, Deserialize)]
+#[display(fmt = "{template}")]
+#[serde(try_from = "String", into = "String")]
+pub struct Template {
+    #[deref(forward)]
+    template: String,
+    /// Pre-parsed chunks of the template. We can't store slices here because
+    /// that would be self-referential, so just store locations. These chunks
+    /// are contiguous and span the whole template.
+    chunks: Vec<TemplateInputChunk<Span>>,
 }
 
-impl TemplateString {
-    /// Render the template string using values from the given context. If an
-    /// error occurs, it is returned as general `anyhow` error. If you need a
-    /// more specific error, use [Self::render_borrow].
-    pub async fn render(
-        &self,
-        context: &TemplateContext,
-        name: &str,
-    ) -> anyhow::Result<String> {
-        self.render_stitched(context)
-            .await
-            .with_context(|| format!("Error rendering {name} {:?}", self.0))
-            .traced()
+impl Template {
+    /// Get a substring of this template. Panics if the span is out of range
+    pub fn substring(&self, span: Span) -> &str {
+        &self.template[span.start()..span.end()]
     }
 
-    /// Render the template string using values from the given context,
-    /// returning the individual rendered chunks. This is useful in any
-    /// application where rendered chunks need to be handled differently from
-    /// raw chunks, e.g. in render previews.
-    #[instrument]
-    pub async fn render_chunks(
-        &self,
-        context: &TemplateContext,
-    ) -> Vec<TemplateChunk> {
-        // Template syntax is simple so it's easiest to just implement it with
-        // a regex
-        let re = TEMPLATE_REGEX
-            .get_or_init(|| Regex::new(r"\{\{\s*([\w\d._-]+)\s*\}\}").unwrap());
-
-        // Regex::replace_all doesn't support fallible replacement, so we
-        // have to do it ourselves.
-        // https://docs.rs/regex/1.9.5/regex/struct.Regex.html#method.replace_all
-
-        let mut chunks = Vec::new();
-        let mut last_match_end = 0;
-        for captures in re.captures_iter(self) {
-            let mtch = captures.get(0).unwrap();
-            let key_raw =
-                captures.get(1).expect("Missing key capture group").as_str();
-
-            // Add the raw string between the last match and this once
-            if last_match_end < mtch.start() {
-                chunks.push(TemplateChunk::Raw {
-                    start: last_match_end,
-                    end: mtch.start(),
-                });
-            }
-
-            // If the key is in the overrides, use the given value without
-            // parsing it
-            let result = match context.overrides.get(key_raw) {
-                Some(value) => {
-                    trace!(
-                        key = key_raw,
-                        value = value,
-                        "Rendered template key from override"
-                    );
-                    Ok(value.into())
-                }
-                None => {
-                    // Standard case - parse the key and render it
-                    try {
-                        let key = TemplateKey::parse(key_raw)?;
-                        let value = key.into_value().render(context).await?;
-                        trace!(
-                            key = key_raw,
-                            value = value.deref(),
-                            "Rendered template key"
-                        );
-                        value
-                    }
-                }
-            };
-
-            // Store the result (success or failure) of rendering
-            chunks.push(result.into());
-            last_match_end = mtch.end();
+    /// Create a new template **without parsing**. The created template should
+    /// *never* be rendered. This is only useful when creating templates purely
+    /// for the purpose of being serialized, e.g. when importing an external
+    /// config into a request collection.
+    ///
+    /// If you try to render this thing, you'll get garbage. The "correct" thing
+    /// to do would be to add some safeguards to make that impossible (either
+    /// type state or a runtime check), but it's not worth the extra code for
+    /// something that is very unlikely to happen. It says "dangerous", don't be
+    /// stupid.
+    pub(crate) fn dangerous_new(template: String) -> Self {
+        Self {
+            template,
+            chunks: Vec::new(),
         }
+    }
+}
 
-        // Add the chunk between the last render and the end
-        if last_match_end < self.len() {
-            chunks.push(TemplateChunk::Raw {
-                start: last_match_end,
-                end: self.len(),
-            });
-        }
+impl TryFrom<String> for Template {
+    type Error = TemplateParseError;
 
-        chunks
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        Self::parse(value)
     }
+}
 
-    /// Helper for stitching chunks together into a single string. If any chunk
-    /// failed to render, return an error.
-    async fn render_stitched(
-        &self,
-        context: &TemplateContext,
-    ) -> TemplateResult {
-        // Render each individual template chunk in the string
-        let chunks = self.render_chunks(context).await;
-
-        // Stitch the rendered chunks together into one string
-        let mut buffer = String::with_capacity(self.len());
-        for chunk in chunks {
-            match chunk {
-                TemplateChunk::Raw { start, end } => {
-                    buffer.push_str(&self.0[start..end]);
-                }
-                TemplateChunk::Rendered(value) => buffer.push_str(&value),
-                TemplateChunk::Error(error) => return Err(error),
-            }
-        }
-        Ok(buffer)
+impl From<Template> for String {
+    fn from(value: Template) -> Self {
+        value.template
     }
 }
 
-impl From<TemplateResult> for TemplateChunk {
-    fn from(result: TemplateResult) -> Self {
-        match result {
-            Ok(value) => Self::Rendered(value),
-            Err(error) => Self::Error(error),
-        }
-    }
+/// A piece of a rendered template string. A collection of chunks collectively
+/// constitutes a rendered string, and those chunks should be contiguous.
+#[derive(Debug)]
+#[cfg_attr(test, derive(PartialEq))]
+pub enum TemplateChunk {
+    /// Raw unprocessed text, i.e. something **outside** the `{{ }}`. This is
+    /// stored as a span in the original string, rather than a string slice, to
+    /// allow this to be passed between tasks/threads easily. We could store an
+    /// owned copy here but that would require copying what could be a very
+    /// large block of text.
+    Raw(Span),
+    /// Outcome of rendering a template key
+    Rendered(String),
+    /// An error occurred while rendering a template key
+    Error(TemplateError),
 }
 
 /// A parsed template key. The variant of this determines how the key will be
@@ -196,260 +112,44 @@ impl From<TemplateResult> for TemplateChunk {
 /// This also serves as an enumeration of all possible value types. Once a key
 /// is parsed, we know its value type and can dynamically dispatch for rendering
 /// based on that.
-#[derive(Clone, Debug, PartialEq)]
-enum TemplateKey<'a> {
+///
+/// The generic parameter defines *how* the key data is stored. Ideally we could
+/// just store a `&str`, but that isn't possible when this is part of a
+/// `Template`, because it would create a self-referential pointer. In that
+/// case, we can store a `Span` which points back to its source in the template.
+///
+/// The `Display` impl here should return exactly what this was parsed from.
+/// This is important for matching override keys during rendering.
+#[derive(Copy, Clone, Debug, Display)]
+#[cfg_attr(test, derive(PartialEq))]
+enum TemplateKey<T> {
     /// A plain field, which can come from the profile or an override
-    Field(&'a str),
-    /// A value chained from the response of another recipe
-    Chain(&'a str),
+    Field(T),
+    /// A value from a predefined chain of another recipe
+    #[display(fmt = "{}{}", "CHAIN_PREFIX", "_0")]
+    Chain(T),
     /// A value pulled from the process environment
-    Environment(&'a str),
+    #[display(fmt = "{}{}", "ENV_PREFIX", "_0")]
+    Environment(T),
 }
 
-impl<'a> TemplateKey<'a> {
-    const CHAINS_PREFIX: &'static str = "chains";
-    const ENVIRONMENT_PREFIX: &'static str = "env";
-
-    /// Parse a string into a key. It'd be nice if this was a `FromStr`
-    /// implementation, but that doesn't allow us to attach to the lifetime of
-    /// the input `str`.
-    fn parse(s: &'a str) -> Result<Self, TemplateError> {
-        match s.split('.').collect::<Vec<_>>().as_slice() {
-            [key] => Ok(Self::Field(key)),
-            [Self::CHAINS_PREFIX, chain_id] => Ok(Self::Chain(chain_id)),
-            [Self::ENVIRONMENT_PREFIX, variable] => {
-                Ok(Self::Environment(variable))
-            }
-            _ => Err(TemplateError::InvalidKey { key: s.to_owned() }),
-        }
-    }
-
-    /// Convert this key into a renderable value type
-    fn into_value(self) -> Box<dyn TemplateSource<'a>> {
+impl<T> TemplateKey<T> {
+    /// Map the internal data using the given function. Useful for mapping
+    /// string slices to spans and vice versa.
+    fn map<U>(self, f: impl Fn(T) -> U) -> TemplateKey<U> {
         match self {
-            TemplateKey::Field(field) => {
-                Box::new(FieldTemplateSource { field })
-            }
-            TemplateKey::Chain(chain_id) => {
-                Box::new(ChainTemplateSource { chain_id })
-            }
-            TemplateKey::Environment(variable) => {
-                Box::new(EnvironmentTemplateSource { variable })
-            }
-        }
-    }
-}
-
-/// A single-type parsed template key, which can be rendered into a string.
-/// This should be one implementation of this for each variant of [TemplateKey].
-///
-/// By breaking `TemplateKey` apart into multiple types, we can split the
-/// render logic easily amongst a bunch of functions. It's not technically
-/// necessary, just a code organization thing.
-#[async_trait]
-trait TemplateSource<'a>: 'a + Send + Sync {
-    /// Render this intermediate value into a string. Return a Cow because
-    /// sometimes this can be a reference to the template context, but
-    /// other times it has to be owned data (e.g. when pulling response data
-    /// from the repository).
-    async fn render(&self, context: &'a TemplateContext) -> TemplateResult;
-}
-
-/// A simple field value (e.g. from the profile or an override)
-struct FieldTemplateSource<'a> {
-    field: &'a str,
-}
-
-#[async_trait]
-impl<'a> TemplateSource<'a> for FieldTemplateSource<'a> {
-    async fn render(&self, context: &'a TemplateContext) -> TemplateResult {
-        let field = self.field;
-        context.profile.get(field).cloned().ok_or_else(|| {
-            TemplateError::FieldUnknown {
-                field: field.to_owned(),
-            }
-        })
-    }
-}
-
-/// A chained value from a complex source. Could be an HTTP response, file, etc.
-struct ChainTemplateSource<'a> {
-    chain_id: &'a str,
-}
-
-#[async_trait]
-impl<'a> TemplateSource<'a> for ChainTemplateSource<'a> {
-    async fn render(&self, context: &'a TemplateContext) -> TemplateResult {
-        let chain_id = self.chain_id;
-
-        // Any error in here is the chain error subtype
-        let result: Result<_, ChainError> = try {
-            // Resolve chained value
-            let chain = context
-                .chains
-                .iter()
-                .find(|chain| chain.id == chain_id)
-                .ok_or(ChainError::Unknown)?;
-
-            // Resolve the value based on the source type
-            let value = match &chain.source {
-                ChainSource::Request(recipe_id) => {
-                    self.render_request(context, recipe_id).await?
-                }
-                ChainSource::File(path) => self.render_file(path).await?,
-                ChainSource::Command(command) => {
-                    self.render_command(command).await?
-                }
-                ChainSource::Prompt(label) => {
-                    self.render_prompt(
-                        context,
-                        label.as_deref(),
-                        chain.sensitive,
-                    )
-                    .await?
-                }
-            };
-
-            // If a selector path is present, filter down the value
-            match &chain.selector {
-                Some(path) => self.apply_selector(&value, path)?,
-                None => value,
-            }
-        };
-
-        // Wrap the chain error into a TemplateError
-        result.map_err(|error| TemplateError::Chain {
-            chain_id: chain_id.to_owned(),
-            error,
-        })
-    }
-}
-
-impl<'a> ChainTemplateSource<'a> {
-    /// Render a chained template value from a response
-    async fn render_request(
-        &self,
-        context: &'a TemplateContext,
-        recipe_id: &RequestRecipeId,
-    ) -> Result<String, ChainError> {
-        let record = context
-            .repository
-            .get_last(recipe_id)
-            .await
-            .map_err(ChainError::Repository)?
-            .ok_or(ChainError::NoResponse)?;
-
-        Ok(record.response.body.into_text())
-    }
-
-    /// Render a chained value from a file
-    async fn render_file(&self, path: &'a Path) -> Result<String, ChainError> {
-        fs::read_to_string(path)
-            .await
-            .map_err(|error| ChainError::File {
-                path: path.to_owned(),
-                error,
-            })
-    }
-
-    /// Render a chained value from an external command
-    async fn render_command(
-        &self,
-        command: &[String],
-    ) -> Result<String, ChainError> {
-        match command {
-            [] => Err(ChainError::CommandMissing),
-            [program, args @ ..] => {
-                let output =
-                    Command::new(program).args(args).output().await.map_err(
-                        |error| ChainError::Command {
-                            command: command.to_owned(),
-                            error,
-                        },
-                    )?;
-                info!(
-                    ?command,
-                    stdout = %String::from_utf8_lossy(&output.stdout),
-                    stderr = %String::from_utf8_lossy(&output.stderr),
-                    "Executing subcommand"
-                );
-                String::from_utf8(output.stdout).map_err(|error| {
-                    ChainError::CommandInvalidUtf8 {
-                        command: command.to_owned(),
-                        error,
-                    }
-                })
-            }
+            Self::Field(value) => TemplateKey::Field(f(value)),
+            Self::Chain(value) => TemplateKey::Chain(f(value)),
+            Self::Environment(value) => TemplateKey::Environment(f(value)),
         }
     }
-
-    /// Render a value by asking the user to provide it
-    async fn render_prompt(
-        &self,
-        context: &'a TemplateContext,
-        label: Option<&str>,
-        sensitive: bool,
-    ) -> Result<String, ChainError> {
-        // Use the prompter to ask the user a question, and wait for a response
-        // on the prompt channel
-        let (tx, rx) = oneshot::channel();
-        context.prompter.prompt(Prompt {
-            label: label.unwrap_or(self.chain_id).into(),
-            sensitive,
-            channel: tx,
-        });
-        rx.await.map_err(|_| ChainError::PromptNoResponse)
-    }
-
-    /// Apply a selector path to a string value to filter it down. Right now
-    /// this only supports JSONpath but we could add support for more in the
-    /// future. The string value will be parsed as a JSON value.
-    fn apply_selector(
-        &self,
-        value: &str,
-        selector: &JsonPath,
-    ) -> Result<String, ChainError> {
-        // Parse the response as JSON. Intentionally ignore the
-        // content-type. If the user wants to treat it as JSON, we
-        // should allow that even if the server is wrong.
-        let json_value = Json::parse(value)
-            .map_err(|err| ChainError::ParseResponse { error: err })?;
-
-        // Apply the path to the json
-        let found_value = selector
-            .query(&json_value)
-            .exactly_one()
-            .map_err(|err| ChainError::InvalidResult { error: err })?;
-
-        match found_value {
-            serde_json::Value::String(s) => Ok(s.clone()),
-            other => Ok(other.to_string()),
-        }
-    }
-}
-
-/// A value sourced from the process's environment
-struct EnvironmentTemplateSource<'a> {
-    variable: &'a str,
-}
-
-#[async_trait]
-impl<'a> TemplateSource<'a> for EnvironmentTemplateSource<'a> {
-    async fn render(&self, _: &'a TemplateContext) -> TemplateResult {
-        env::var(self.variable).map_err(|err| {
-            TemplateError::EnvironmentVariable {
-                variable: self.variable.to_owned(),
-                error: err,
-            }
-        })
-    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::{
-        collection::RequestRecipeId,
+        collection::{ChainSource, RequestRecipeId},
         factory::*,
         http::{Request, Response},
         util::assert_err,
@@ -458,37 +158,70 @@ mod tests {
     use indexmap::indexmap;
     use rstest::rstest;
     use serde_json::json;
+    use std::env;
+    use tokio::fs;
 
-    /// Test that a field key renders correctly
+    /// Test overriding all key types, as well as missing keys
     #[tokio::test]
-    async fn test_field() {
-        let profile = [
-            ("user_id".into(), "1".into()),
-            ("group_id".into(), "3".into()),
-        ]
-        .into_iter()
-        .collect();
-        let overrides = [("user_id".into(), "2".into())].into_iter().collect();
+    async fn test_override() {
+        let profile = indexmap! {"field1".into() => "field".into()};
+        let source = ChainSource::Command(
+            ["echo", "chain"]
+                .iter()
+                .cloned()
+                .map(String::from)
+                .collect(),
+        );
+        let overrides = indexmap! {
+            "field1".into() => "override".into(),
+            "chains.chain1".into() => "override".into(),
+            "env.ENV1".into() => "override".into(),
+            "override1".into() => "override".into(),
+        };
+        let chains = vec![create!(Chain, source: source)];
         let context = create!(
             TemplateContext,
             profile: profile,
+            chains: chains,
             overrides: overrides,
         );
 
+        assert_eq!(
+            render!("{{field1}}", context).unwrap(),
+            "override".to_owned()
+        );
+        assert_eq!(
+            render!("{{chains.chain1}}", context).unwrap(),
+            "override".to_owned()
+        );
+        assert_eq!(
+            render!("{{env.ENV1}}", context).unwrap(),
+            "override".to_owned()
+        );
+        assert_eq!(
+            render!("{{override1}}", context).unwrap(),
+            "override".to_owned()
+        );
+    }
+
+    /// Test that a field key renders correctly
+    #[tokio::test]
+    async fn test_field() {
+        let profile = indexmap! {
+            "user_id".into() => "1".into(),
+            "group_id".into() => "3".into(),
+        };
+        let context = create!(TemplateContext, profile: profile);
+
         // Success cases
         assert_eq!(render!("", context).unwrap(), "".to_owned());
         assert_eq!(render!("plain", context).unwrap(), "plain".to_owned());
-        assert_eq!(
-            // Pull from overrides for user_id, profile for group_id
-            render!("{{user_id}} {{group_id}}", context).unwrap(),
-            "2 3".to_owned()
-        );
         assert_eq!(
             // Test complex stitching. Emoji is important to test because the
             // stitching uses character indexes
             render!("start {{user_id}} 🧡💛 {{group_id}} end", context)
                 .unwrap(),
-            "start 2 🧡💛 3 end".to_owned()
+            "start 1 🧡💛 3 end".to_owned()
         );
 
         // Error cases
@@ -736,60 +469,27 @@ mod tests {
         );
     }
 
-    /// Test successful parsing *inside* the {{ }}
-    #[rstest]
-    #[case("field_id", TemplateKey::Field("field_id"))]
-    #[case("chains.chain_id", TemplateKey::Chain("chain_id"))]
-    // This is "valid", but probably won't match anything
-    #[case("chains.", TemplateKey::Chain(""))]
-    #[case("env.TEST", TemplateKey::Environment("TEST"))]
-    fn test_parse_template_key_success(
-        #[case] input: &str,
-        #[case] expected_value: TemplateKey,
-    ) {
-        assert_eq!(TemplateKey::parse(input).unwrap(), expected_value);
-    }
-
-    /// Test errors when parsing inside the {{ }}
-    #[rstest]
-    #[case(".")]
-    #[case(".bad")]
-    #[case("bad.")]
-    #[case("chains.good.bad")]
-    fn test_parse_template_key_error(#[case] input: &str) {
-        assert_err!(
-            TemplateKey::parse(input),
-            &format!("Failed to parse template key {input:?}"),
-            true
-        );
-    }
-
-    /// Test rendering into individual chunks
+    /// Test rendering into individual chunks with complex unicode
     #[tokio::test]
     async fn test_render_chunks() {
-        let profile = indexmap! {
-            "user_id".into() => "🧡💛".into()
-        };
-        let context = create!(
-            TemplateContext,
-            profile: profile,
-        );
+        let profile = indexmap! { "user_id".into() => "🧡💛".into() };
+        let context = create!(TemplateContext, profile: profile);
 
         let chunks =
-            TemplateString("intro {{user_id}} 💚💙💜 {{unknown}} outro".into())
+            Template::from("intro {{user_id}} 💚💙💜 {{unknown}} outro")
                 .render_chunks(&context)
                 .await;
         assert_eq!(
             chunks,
             vec![
-                TemplateChunk::Raw { start: 0, end: 6 },
+                TemplateChunk::Raw(Span::new(0, 6)),
                 TemplateChunk::Rendered("🧡💛".into()),
                 // Each emoji is 4 bytes
-                TemplateChunk::Raw { start: 17, end: 31 },
+                TemplateChunk::Raw(Span::new(17, 14)),
                 TemplateChunk::Error(TemplateError::FieldUnknown {
                     field: "unknown".into()
                 }),
-                TemplateChunk::Raw { start: 42, end: 48 },
+                TemplateChunk::Raw(Span::new(42, 6)),
             ]
         );
     }
@@ -797,9 +497,7 @@ mod tests {
     /// Helper for rendering a string
     macro_rules! render {
         ($template:expr, $context:expr) => {
-            TemplateString($template.into())
-                .render_stitched(&$context)
-                .await
+            Template::from($template).render_stitched(&$context).await
         };
     }
 
diff --git a/src/template/error.rs b/src/template/error.rs
index ef009318..9887e767 100644
--- a/src/template/error.rs
+++ b/src/template/error.rs
@@ -1,9 +1,22 @@
+use nom::error::VerboseError;
 use serde_json_path::ExactlyOneError;
 use std::{env::VarError, io, path::PathBuf, string::FromUtf8Error};
 use thiserror::Error;
 
 pub type TemplateResult = Result<String, TemplateError>;
 
+/// An error while parsing a template. This is derived from a nom error
+#[derive(Debug, Error)]
+#[error("{0}")]
+pub struct TemplateParseError(String);
+
+impl TemplateParseError {
+    /// Create a user-friendly parse error
+    pub(super) fn new(template: &str, error: VerboseError<&str>) -> Self {
+        Self(nom::error::convert_error(template, error))
+    }
+}
+
 /// Any error that can occur during template rendering. The purpose of having a
 /// structured error here (while the rest of the app just uses `anyhow`) is to
 /// support localized error display in the UI, e.g. showing just one portion of
diff --git a/src/template/parse.rs b/src/template/parse.rs
new file mode 100644
index 00000000..be3b7c4d
--- /dev/null
+++ b/src/template/parse.rs
@@ -0,0 +1,213 @@
+//! Template string parser
+
+use crate::template::{error::TemplateParseError, Template, TemplateKey};
+use nom::{
+    branch::alt,
+    bytes::complete::{tag, take_while1},
+    combinator::{all_consuming, cut},
+    error::{context, ErrorKind, ParseError, VerboseError},
+    multi::many0,
+    sequence::{preceded, terminated},
+    FindSubstring, Finish, IResult, InputLength, InputTake, Offset, Parser,
+};
+
+const KEY_OPEN: &str = "{{";
+const KEY_CLOSE: &str = "}}";
+// Export these so they can be used in TemplateKey's Display impl
+pub const CHAIN_PREFIX: &str = "chains.";
+pub const ENV_PREFIX: &str = "env.";
+
+type ParseResult<'a, T> = IResult<&'a str, T, VerboseError<&'a str>>;
+
+impl Template {
+    /// Parse a template, extracting all template keys
+    pub fn parse(template: String) -> Result<Self, TemplateParseError> {
+        // Parse everything as string slices
+        let (_, chunks) = all_chunks(&template)
+            .finish()
+            .map_err(|error| TemplateParseError::new(&template, error))?;
+
+        // Map all the string slices to spans to avoid self-references. It would
+        // be better to track the spans as we go, but that's a bit harder
+        let mapper = |s: &str| Span::new(template.offset(s), s.len());
+        let chunks =
+            chunks.into_iter().map(|chunk| chunk.map(mapper)).collect();
+
+        Ok(Self { template, chunks })
+    }
+}
+
+/// A parsed piece of a template. After parsing, each chunk is either raw text
+/// or a parsed key, ready to be rendered.
+#[derive(Copy, Clone, Debug)]
+#[cfg_attr(test, derive(PartialEq))]
+pub enum TemplateInputChunk<T> {
+    Raw(T),
+    Key(TemplateKey<T>),
+}
+
+impl<T> TemplateInputChunk<T> {
+    /// Map the internal data using the given function. Useful for mapping
+    /// string slices to spans and vice versa.
+    fn map<U>(self, f: impl Fn(T) -> U) -> TemplateInputChunk<U> {
+        match self {
+            Self::Raw(value) => TemplateInputChunk::Raw(f(value)),
+            Self::Key(key) => TemplateInputChunk::Key(key.map(f)),
+        }
+    }
+}
+
+/// Indexes defining a substring of text within some string. This is a useful
+/// alternative to string slices when avoiding self-referential structs.
+#[derive(Copy, Clone, Debug)]
+#[cfg_attr(test, derive(PartialEq))]
+pub struct Span {
+    start: usize,
+    /// Store length instead of end so it can never be invalid
+    len: usize,
+}
+
+impl Span {
+    pub(super) fn new(start: usize, len: usize) -> Self {
+        Self { start, len }
+    }
+
+    /// Starting index of the span, inclusive
+    pub fn start(&self) -> usize {
+        self.start
+    }
+
+    /// Ending index of the span, exclusive
+    pub fn end(&self) -> usize {
+        self.start + self.len
+    }
+}
+
+/// Parse a template into keys and raw text
+fn all_chunks(input: &str) -> ParseResult<Vec<TemplateInputChunk<&str>>> {
+    all_consuming(many0(alt((
+        key.map(TemplateInputChunk::Key),
+        raw.map(TemplateInputChunk::Raw),
+    ))))(input)
+}
+
+/// Parse raw text, until we hit a key or end of input
+fn raw(input: &str) -> ParseResult<&str> {
+    context("raw", take_until_or_eof(KEY_OPEN))(input)
+}
+
+/// Parse a template key
+fn key(input: &str) -> ParseResult<TemplateKey<&str>> {
+    context(
+        "key",
+        preceded(
+            tag(KEY_OPEN),
+            // Any error inside a template key is fatal, including an unclosed
+            // key
+            cut(terminated(key_contents, tag(KEY_CLOSE))),
+        ),
+    )(input)
+}
+
+/// Parse the contents of a key (inside the `{{ }}`)
+fn key_contents(input: &str) -> ParseResult<TemplateKey<&str>> {
+    alt((
+        context(
+            "chain",
+            preceded(tag(CHAIN_PREFIX), identifier).map(TemplateKey::Chain),
+        ),
+        context(
+            "environment",
+            preceded(tag(ENV_PREFIX), identifier).map(TemplateKey::Environment),
+        ),
+        context("field", identifier.map(TemplateKey::Field)),
+    ))(input)
+}
+
+/// Parse a field name/chain ID/env variable etc, inside a key
+fn identifier(input: &str) -> ParseResult<&str> {
+    context(
+        "identifier",
+        take_while1(|c: char| c.is_alphanumeric() || "-_".contains(c)),
+    )(input)
+}
+
+/// A copy pasta of nom's `take_until` that will take up to the end of a string
+/// if the terminator never appears, instead of erroring out. I couldn't
+/// figure out how to do this with other combinators, so here we go
+fn take_until_or_eof<'a>(
+    tag: &'a str,
+) -> impl Fn(&'a str) -> ParseResult<&'a str> {
+    |i| match i.find_substring(tag) {
+        Some(index) => Ok(i.take_split(index)),
+        None if i.input_len() > 0 => Ok(i.take_split(i.input_len())),
+        None => Err(nom::Err::Error(VerboseError::from_error_kind(
+            i,
+            ErrorKind::TakeUntil,
+        ))),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::util::assert_err;
+    use itertools::Itertools;
+    use rstest::rstest;
+
+    /// Test parsing success cases
+    #[rstest]
+    #[case("", vec![])]
+    #[case("raw", vec![TemplateInputChunk::Raw("raw")])]
+    #[case(
+        "{{field1}}",
+        vec![TemplateInputChunk::Key(TemplateKey::Field("field1"))]
+    )]
+    #[case("{{1}}", vec![TemplateInputChunk::Key(TemplateKey::Field("1"))])]
+    #[case(
+        "{{chains.chain1}}",
+        vec![TemplateInputChunk::Key(TemplateKey::Chain("chain1"))]
+    )]
+    #[case(
+        "{{env.ENV}}",
+        vec![TemplateInputChunk::Key(TemplateKey::Environment("ENV"))]
+    )]
+    #[case(
+        "intro\n{{user_id}} 💚💙💜 {{chains.chain}}\noutro\r\nmore outro",
+        vec![
+            TemplateInputChunk::Raw("intro\n"),
+            TemplateInputChunk::Key(TemplateKey::Field("user_id")),
+            TemplateInputChunk::Raw(" 💚💙💜 "),
+            TemplateInputChunk::Key(TemplateKey::Chain("chain")),
+            TemplateInputChunk::Raw("\noutro\r\nmore outro"),
+        ]
+    )]
+    fn test_parse(
+        #[case] template: &str,
+        #[case] expected_chunks: Vec<TemplateInputChunk<&str>>,
+    ) {
+        let parsed =
+            Template::parse(template.to_owned()).expect("Parsing failed");
+        // Map from spans to strings to make test creation easier
+        let chunks = parsed
+            .chunks
+            .iter()
+            .map(|chunk| chunk.map(|span| parsed.substring(span)))
+            .collect_vec();
+        assert_eq!(chunks, expected_chunks);
+    }
+
+    /// Test parsing error cases. The error messages are not very descriptive
+    /// so don't even bother looking for particular content
+    #[rstest]
+    #[case("{{")]
+    #[case("{{}}")]
+    #[case("{{.}}")]
+    #[case("{{bogus.}}")]
+    #[case("{{bogus.one}}")]
+    #[case("{{chains.one.two}}")]
+    #[case("{{env.one.two}}")]
+    fn test_parse_error(#[case] template: &str) {
+        assert_err!(Template::parse(template.into()), "at line 1");
+    }
+}
diff --git a/src/template/render.rs b/src/template/render.rs
new file mode 100644
index 00000000..4d3954c5
--- /dev/null
+++ b/src/template/render.rs
@@ -0,0 +1,346 @@
+//! Template rendering implementation
+
+use crate::{
+    collection::{ChainSource, RequestRecipeId},
+    http::{ContentType, Json},
+    template::{
+        parse::TemplateInputChunk, ChainError, Prompt, Template, TemplateChunk,
+        TemplateContext, TemplateError, TemplateKey, TemplateResult,
+    },
+    util::ResultExt,
+};
+use anyhow::Context;
+use async_trait::async_trait;
+use futures::future::join_all;
+use serde_json_path::JsonPath;
+use std::{
+    env::{self},
+    ops::Deref as _,
+    path::Path,
+};
+use tokio::{fs, process::Command, sync::oneshot};
+use tracing::{info, instrument, trace};
+
+impl Template {
+    /// Render the template string using values from the given context. If an
+    /// error occurs, it is returned as general `anyhow` error. If you need a
+    /// more specific error, use [Self::render_borrow].
+    pub async fn render(
+        &self,
+        context: &TemplateContext,
+        name: &str,
+    ) -> anyhow::Result<String> {
+        self.render_stitched(context)
+            .await
+            .with_context(|| {
+                format!("Error rendering {name} {:?}", self.template)
+            })
+            .traced()
+    }
+
+    /// Render the template string using values from the given context,
+    /// returning the individual rendered chunks. This is useful in any
+    /// application where rendered chunks need to be handled differently from
+    /// raw chunks, e.g. in render previews.
+    #[instrument]
+    pub async fn render_chunks(
+        &self,
+        context: &TemplateContext,
+    ) -> Vec<TemplateChunk> {
+        // Map over each parsed chunk, and render the keys into strings. The
+        // raw text chunks will be mapped 1:1
+        let futures = self.chunks.iter().copied().map(|chunk| async move {
+            match chunk {
+                TemplateInputChunk::Raw(span) => TemplateChunk::Raw(span),
+                TemplateInputChunk::Key(key) => {
+                    // Grab the string corresponding to the span
+                    let key = key.map(|span| self.substring(span));
+
+                    // The formatted key should match the source that it was
+                    // parsed from, therefore we can use it to match the
+                    // override key
+                    let raw = key.to_string();
+                    // If the key is in the overrides, use the given value
+                    // without parsing it
+                    let result = match context.overrides.get(&raw) {
+                        Some(value) => {
+                            trace!(
+                                key = raw,
+                                value,
+                                "Rendered template key from override"
+                            );
+                            Ok(value.into())
+                        }
+                        None => {
+                            // Standard case - parse the key and render it
+                            try {
+                                let value =
+                                    key.into_source().render(context).await?;
+                                trace!(
+                                    key = raw,
+                                    value = value.deref(),
+                                    "Rendered template key"
+                                );
+                                value
+                            }
+                        }
+                    };
+                    result.into()
+                }
+            }
+        });
+
+        // Parallelization!
+        join_all(futures).await
+    }
+
+    /// Helper for stitching chunks together into a single string. If any chunk
+    /// failed to render, return an error.
+    pub(super) async fn render_stitched(
+        &self,
+        context: &TemplateContext,
+    ) -> TemplateResult {
+        // Render each individual template chunk in the string
+        let chunks = self.render_chunks(context).await;
+
+        // Stitch the rendered chunks together into one string
+        let mut buffer = String::with_capacity(self.len());
+        for chunk in chunks {
+            match chunk {
+                TemplateChunk::Raw(span) => {
+                    buffer.push_str(self.substring(span));
+                }
+                TemplateChunk::Rendered(value) => buffer.push_str(&value),
+                TemplateChunk::Error(error) => return Err(error),
+            }
+        }
+        Ok(buffer)
+    }
+}
+
+impl From<TemplateResult> for TemplateChunk {
+    fn from(result: TemplateResult) -> Self {
+        match result {
+            Ok(value) => Self::Rendered(value),
+            Err(error) => Self::Error(error),
+        }
+    }
+}
+
+impl<'a> TemplateKey<&'a str> {
+    /// Convert this key into a renderable value type
+    fn into_source(self) -> Box<dyn TemplateSource<'a>> {
+        match self {
+            Self::Field(field) => Box::new(FieldTemplateSource { field }),
+            Self::Chain(chain_id) => Box::new(ChainTemplateSource { chain_id }),
+            Self::Environment(variable) => {
+                Box::new(EnvironmentTemplateSource { variable })
+            }
+        }
+    }
+}
+
+/// A single-type parsed template key, which can be rendered into a string.
+/// This should be one implementation of this for each variant of [TemplateKey].
+///
+/// By breaking `TemplateKey` apart into multiple types, we can split the
+/// render logic easily amongst a bunch of functions. It's not technically
+/// necessary, just a code organization thing.
+#[async_trait]
+trait TemplateSource<'a>: 'a + Send + Sync {
+    /// Render this intermediate value into a string. Return a Cow because
+    /// sometimes this can be a reference to the template context, but
+    /// other times it has to be owned data (e.g. when pulling response data
+    /// from the repository).
+    async fn render(&self, context: &'a TemplateContext) -> TemplateResult;
+}
+
+/// A simple field value (e.g. from the profile or an override)
+struct FieldTemplateSource<'a> {
+    pub field: &'a str,
+}
+
+#[async_trait]
+impl<'a> TemplateSource<'a> for FieldTemplateSource<'a> {
+    async fn render(&self, context: &'a TemplateContext) -> TemplateResult {
+        let field = self.field;
+        context.profile.get(field).cloned().ok_or_else(|| {
+            TemplateError::FieldUnknown {
+                field: field.to_owned(),
+            }
+        })
+    }
+}
+
+/// A chained value from a complex source. Could be an HTTP response, file, etc.
+struct ChainTemplateSource<'a> {
+    pub chain_id: &'a str,
+}
+
+#[async_trait]
+impl<'a> TemplateSource<'a> for ChainTemplateSource<'a> {
+    async fn render(&self, context: &'a TemplateContext) -> TemplateResult {
+        let chain_id = self.chain_id;
+
+        // Any error in here is the chain error subtype
+        let result: Result<_, ChainError> = try {
+            // Resolve chained value
+            let chain = context
+                .chains
+                .iter()
+                .find(|chain| chain.id.deref() == chain_id)
+                .ok_or(ChainError::Unknown)?;
+
+            // Resolve the value based on the source type
+            let value = match &chain.source {
+                ChainSource::Request(recipe_id) => {
+                    self.render_request(context, recipe_id).await?
+                }
+                ChainSource::File(path) => self.render_file(path).await?,
+                ChainSource::Command(command) => {
+                    self.render_command(command).await?
+                }
+                ChainSource::Prompt(label) => {
+                    self.render_prompt(
+                        context,
+                        label.as_deref(),
+                        chain.sensitive,
+                    )
+                    .await?
+                }
+            };
+
+            // If a selector path is present, filter down the value
+            match &chain.selector {
+                Some(path) => self.apply_selector(&value, path)?,
+                None => value,
+            }
+        };
+
+        // Wrap the chain error into a TemplateError
+        result.map_err(|error| TemplateError::Chain {
+            chain_id: chain_id.to_owned(),
+            error,
+        })
+    }
+}
+
+impl<'a> ChainTemplateSource<'a> {
+    /// Render a chained template value from a response
+    async fn render_request(
+        &self,
+        context: &'a TemplateContext,
+        recipe_id: &RequestRecipeId,
+    ) -> Result<String, ChainError> {
+        let record = context
+            .repository
+            .get_last(recipe_id)
+            .await
+            .map_err(ChainError::Repository)?
+            .ok_or(ChainError::NoResponse)?;
+
+        Ok(record.response.body.into_text())
+    }
+
+    /// Render a chained value from a file
+    async fn render_file(&self, path: &'a Path) -> Result<String, ChainError> {
+        fs::read_to_string(path)
+            .await
+            .map_err(|error| ChainError::File {
+                path: path.to_owned(),
+                error,
+            })
+    }
+
+    /// Render a chained value from an external command
+    async fn render_command(
+        &self,
+        command: &[String],
+    ) -> Result<String, ChainError> {
+        match command {
+            [] => Err(ChainError::CommandMissing),
+            [program, args @ ..] => {
+                let output =
+                    Command::new(program).args(args).output().await.map_err(
+                        |error| ChainError::Command {
+                            command: command.to_owned(),
+                            error,
+                        },
+                    )?;
+                info!(
+                    ?command,
+                    stdout = %String::from_utf8_lossy(&output.stdout),
+                    stderr = %String::from_utf8_lossy(&output.stderr),
+                    "Executing subcommand"
+                );
+                String::from_utf8(output.stdout).map_err(|error| {
+                    ChainError::CommandInvalidUtf8 {
+                        command: command.to_owned(),
+                        error,
+                    }
+                })
+            }
+        }
+    }
+
+    /// Render a value by asking the user to provide it
+    async fn render_prompt(
+        &self,
+        context: &'a TemplateContext,
+        label: Option<&str>,
+        sensitive: bool,
+    ) -> Result<String, ChainError> {
+        // Use the prompter to ask the user a question, and wait for a response
+        // on the prompt channel
+        let (tx, rx) = oneshot::channel();
+        context.prompter.prompt(Prompt {
+            label: label.unwrap_or(self.chain_id).into(),
+            sensitive,
+            channel: tx,
+        });
+        rx.await.map_err(|_| ChainError::PromptNoResponse)
+    }
+
+    /// Apply a selector path to a string value to filter it down. Right now
+    /// this only supports JSONpath but we could add support for more in the
+    /// future. The string value will be parsed as a JSON value.
+    fn apply_selector(
+        &self,
+        value: &str,
+        selector: &JsonPath,
+    ) -> Result<String, ChainError> {
+        // Parse the response as JSON. Intentionally ignore the
+        // content-type. If the user wants to treat it as JSON, we
+        // should allow that even if the server is wrong.
+        let json_value = Json::parse(value)
+            .map_err(|err| ChainError::ParseResponse { error: err })?;
+
+        // Apply the path to the json
+        let found_value = selector
+            .query(&json_value)
+            .exactly_one()
+            .map_err(|err| ChainError::InvalidResult { error: err })?;
+
+        match found_value {
+            serde_json::Value::String(s) => Ok(s.clone()),
+            other => Ok(other.to_string()),
+        }
+    }
+}
+
+/// A value sourced from the process's environment
+struct EnvironmentTemplateSource<'a> {
+    pub variable: &'a str,
+}
+
+#[async_trait]
+impl<'a> TemplateSource<'a> for EnvironmentTemplateSource<'a> {
+    async fn render(&self, _: &'a TemplateContext) -> TemplateResult {
+        env::var(self.variable).map_err(|err| {
+            TemplateError::EnvironmentVariable {
+                variable: self.variable.to_owned(),
+                error: err,
+            }
+        })
+    }
+}
diff --git a/src/tui.rs b/src/tui.rs
index 784f8530..59f84ed2 100644
--- a/src/tui.rs
+++ b/src/tui.rs
@@ -5,7 +5,7 @@ mod view;
 use crate::{
     collection::{ProfileId, RequestCollection, RequestRecipeId},
     http::{HttpEngine, Repository, RequestBuilder},
-    template::{Prompter, TemplateChunk, TemplateContext, TemplateString},
+    template::{Prompter, Template, TemplateChunk, TemplateContext},
     tui::{
         input::{Action, InputEngine},
         message::{Message, MessageSender},
@@ -354,7 +354,7 @@ impl Tui {
     /// input. A placeholder value will be used for any prompts.
     fn render_template_preview(
         &self,
-        template: TemplateString,
+        template: Template,
         profile_id: Option<&ProfileId>,
         destination: Arc<OnceLock<Vec<TemplateChunk>>>,
     ) -> anyhow::Result<()> {
diff --git a/src/tui/message.rs b/src/tui/message.rs
index 5296408f..5fee7fbe 100644
--- a/src/tui/message.rs
+++ b/src/tui/message.rs
@@ -4,7 +4,7 @@
 use crate::{
     collection::{ProfileId, RequestCollection, RequestRecipeId},
     http::{RequestBuildError, RequestError, RequestId, RequestRecord},
-    template::{Prompt, Prompter, TemplateChunk, TemplateString},
+    template::{Prompt, Prompter, Template, TemplateChunk},
     util::ResultExt,
 };
 use anyhow::Context;
@@ -92,7 +92,7 @@ pub enum Message {
     /// By specifying the destination inline, we avoid having to plumb the
     /// result all the way back down the component tree.
     TemplatePreview {
-        template: TemplateString,
+        template: Template,
         profile_id: Option<ProfileId>,
         destination: Arc<OnceLock<Vec<TemplateChunk>>>,
     },
diff --git a/src/tui/view/component/request.rs b/src/tui/view/component/request.rs
index 64e87304..801368f9 100644
--- a/src/tui/view/component/request.rs
+++ b/src/tui/view/component/request.rs
@@ -1,6 +1,6 @@
 use crate::{
     collection::{ProfileId, RequestRecipe, RequestRecipeId},
-    template::TemplateString,
+    template::Template,
     tui::{
         input::Action,
         view::{
@@ -212,7 +212,7 @@ impl<'a> Draw<RequestPaneProps<'a>> for RequestPane {
 fn to_template_previews<'a>(
     context: &DrawContext,
     profile_id: Option<&ProfileId>,
-    iter: impl IntoIterator<Item = (&'a String, &'a TemplateString)>,
+    iter: impl IntoIterator<Item = (&'a String, &'a Template)>,
 ) -> Vec<(String, TemplatePreview)> {
     iter.into_iter()
         .map(|(k, v)| {
diff --git a/src/tui/view/component/template_preview.rs b/src/tui/view/component/template_preview.rs
index dd34e3d2..6e8046db 100644
--- a/src/tui/view/component/template_preview.rs
+++ b/src/tui/view/component/template_preview.rs
@@ -1,6 +1,6 @@
 use crate::{
     collection::ProfileId,
-    template::{TemplateChunk, TemplateString},
+    template::{Template, TemplateChunk},
     tui::{
         message::Message,
         view::{
@@ -16,11 +16,10 @@ use ratatui::{
     text::{Line, Span, Text},
     widgets::Paragraph,
 };
-use regex::Regex;
 use std::{
     mem,
     ops::Deref,
-    sync::{Arc, LazyLock, OnceLock},
+    sync::{Arc, OnceLock},
 };
 
 /// A preview of a template string, which can show either the raw text or the
@@ -28,7 +27,7 @@ use std::{
 /// changed globally.
 #[derive(Debug)]
 pub struct TemplatePreview {
-    template: TemplateString,
+    template: Template,
     /// Rendered chunks. On init we send a message which will trigger a task to
     /// start the render. When the task is done, it'll dump its result back
     /// here.
@@ -41,7 +40,7 @@ impl TemplatePreview {
     /// render.
     pub fn new(
         context: &DrawContext,
-        template: TemplateString,
+        template: Template,
         profile_id: Option<ProfileId>,
     ) -> Self {
         // Tell the controller to start rendering the preview, and it'll store
@@ -73,9 +72,11 @@ impl ToTui for TemplatePreview {
             // If the preview render is ready, show it. Otherwise fall back to
             // the raw
             match self.chunks.get() {
-                Some(chunks) => {
-                    TextStitcher::stitch_chunks(raw, chunks, context.theme)
-                }
+                Some(chunks) => TextStitcher::stitch_chunks(
+                    &self.template,
+                    chunks,
+                    context.theme,
+                ),
                 // Preview still rendering
                 None => raw.into(),
             }
@@ -108,7 +109,7 @@ struct TextStitcher<'a> {
 impl<'a> TextStitcher<'a> {
     /// Convert chunks into a series of spans, which can be turned into a line
     fn stitch_chunks(
-        raw: &'a str,
+        template: &'a Template,
         chunks: &'a [TemplateChunk],
         theme: &Theme,
     ) -> Text<'a> {
@@ -120,8 +121,8 @@ impl<'a> TextStitcher<'a> {
         let mut stitcher = Self::default();
         for chunk in chunks {
             let (chunk_text, style) = match &chunk {
-                TemplateChunk::Raw { start, end } => {
-                    (&raw[*start..*end], Style::default())
+                TemplateChunk::Raw(span) => {
+                    (template.substring(*span), Style::default())
                 }
                 TemplateChunk::Rendered(value) => {
                     (value.as_str(), theme.template_preview_text)
@@ -140,11 +141,9 @@ impl<'a> TextStitcher<'a> {
     /// Add one chunk to the text. This will recursively split on any line
     /// breaks in the text until it reaches the end.
     fn add_chunk(&mut self, chunk_text: &'a str, style: Style) {
-        static LINE_ENDING: LazyLock<Regex> =
-            LazyLock::new(|| Regex::new("\r?\n").unwrap());
-
-        // If we've reached a line ending, push the line and start a new one
-        match chunk_text.split_once(LINE_ENDING.deref()) {
+        // If we've reached a line ending, push the line and start a new one.
+        // Intentionally ignore \r; it won't cause any harm in the output text
+        match chunk_text.split_once('\n') {
             Some((a, b)) => {
                 self.add_span(a, style);
                 self.end_line();
@@ -179,35 +178,33 @@ impl<'a> TextStitcher<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::template::TemplateError;
-
-    /// Test line breaks and styling when stitching together template chunks.
+    use crate::factory::*;
+    use factori::create;
+    use indexmap::indexmap;
+
+    /// Test these cases related to line breaks:
+    /// - Line break within a raw chunk
+    /// - Line break within a rendered chunk
+    /// - Line break at chunk boundary
+    /// - NO line break at chunk boundary
     /// Ratatui is fucky with how it handles line breaks in text, so we need
     /// to make sure our output reflects the input
-    #[test]
-    fn test_template_stitch() {
-        // Test these cases related to line breaks:
-        // - Line break within a raw chunk
-        // - Line break within a rendered chunk
-        // - Line break at chunk boundary
-        // - NO line break at chunk boundary
-        let raw = "intro\n{{user_id}} 💚💙💜 {{unknown}}\noutro\r\nmore outro";
+    ///
+    /// Additionally, test multi-byte unicode characters to make sure string
+    /// offset indexes work correctly
+    #[tokio::test]
+    async fn test_template_stitch() {
+        // Render a template
+        let template = Template::parse(
+            "intro\n{{user_id}} 💚💙💜 {{unknown}}\noutro\r\nmore outro".into(),
+        )
+        .unwrap();
+        let profile = indexmap! { "user_id".into() => "🧡\n💛".into() };
+        let context = create!(TemplateContext, profile: profile);
+        let chunks = template.render_chunks(&context).await;
         let theme = Theme::default();
-        let chunks = vec![
-            TemplateChunk::Raw { start: 0, end: 6 },
-            TemplateChunk::Rendered("🧡\n💛".into()),
-            // Each emoji is 4 bytes
-            TemplateChunk::Raw { start: 17, end: 31 },
-            TemplateChunk::Error(TemplateError::FieldUnknown {
-                field: "unknown".into(),
-            }),
-            TemplateChunk::Raw {
-                start: 42,
-                end: raw.len(),
-            },
-        ];
-
-        let text = TextStitcher::stitch_chunks(raw, &chunks, &theme);
+
+        let text = TextStitcher::stitch_chunks(&template, &chunks, &theme);
         let rendered_style = theme.template_preview_text;
         let error_style = theme.template_preview_error;
         let expected = Text::from(vec![
@@ -218,7 +215,7 @@ mod tests {
                 Span::raw(" 💚💙💜 "),
                 Span::styled("Error", error_style),
             ]),
-            Line::from("outro"),
+            Line::from("outro\r"), // \r shouldn't create any issues
             Line::from("more outro"),
         ]);
         assert_eq!(text, expected);
diff --git a/src/tui/view/util.rs b/src/tui/view/util.rs
index 11bdca82..c4e9481b 100644
--- a/src/tui/view/util.rs
+++ b/src/tui/view/util.rs
@@ -10,9 +10,10 @@ use crate::{
     },
 };
 use chrono::{DateTime, Duration, Local, Utc};
+use itertools::Itertools;
 use ratatui::{
     prelude::*,
-    text::{Line, Span, Text},
+    text::{Span, Text},
     widgets::{Block, Borders, List, ListItem},
 };
 use reqwest::header::HeaderValue;
@@ -195,14 +196,7 @@ impl ToTui for anyhow::Error {
     type Output<'this> = Text<'static>;
 
     fn to_tui(&self, _context: &DrawContext) -> Self::Output<'_> {
-        self.chain()
-            .enumerate()
-            .map(|(i, err)| {
-                // Add indentation to parent errors
-                format!("{}{err}", if i > 0 { "  " } else { "" }).into()
-            })
-            .collect::<Vec<Line>>()
-            .into()
+        self.chain().map(|err| err.to_string()).join("\n").into()
     }
 }
 
diff --git a/src/util.rs b/src/util.rs
index 0cdf4d3b..fd98d752 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -72,7 +72,7 @@ macro_rules! assert_err {
 
         let msg = $msg;
         // Include all source errors so wrappers don't hide the important stuff
-        let error: anyhow::Error = $e.unwrap_err();
+        let error: anyhow::Error = $e.unwrap_err().into();
         let actual = error.chain().map(ToString::to_string).join(": ");
         assert!(
             actual.contains(msg),