Skip to main content

sendmock_core/template/
template_renderer.rs

1use minijinja::value::Serde;
2use minijinja::{Error, ErrorKind};
3use serde_json::Value;
4
5use super::template_environment::build_template_environment;
6use super::template_functions::TemplateFunctions;
7use super::template_postman_aliases::rewrite_postman_aliases;
8use super::template_problems::{build_problem, find_template_problems};
9
10/// The largest text one render may produce (1 MB), so a bad template cannot fill memory.
11pub const MAXIMUM_RENDERED_BYTES: usize = 1024 * 1024;
12
13/// How rendered values are written: as they are, or escaped for a place inside a JSON string,
14/// so a message body with quotes keeps a JSON answer valid.
15#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16pub enum TemplateEscape {
17    None,
18    JsonString,
19}
20
21/// Lenient renders an undefined value as nothing with a warning; strict stops with an error.
22#[derive(Debug, Clone, Copy, PartialEq, Eq)]
23pub enum TemplateRenderMode {
24    Lenient,
25    Strict,
26}
27
28#[derive(Debug, Clone, Copy, PartialEq, Eq)]
29pub enum TemplateProblemSeverity {
30    /// An undefined value in lenient mode; it renders empty.
31    Warning,
32    /// An unknown function or filter, a syntax error, or a failed render; saving is refused.
33    Error,
34}
35
36#[derive(Debug, Clone, PartialEq, Eq)]
37pub struct TemplateProblem {
38    pub severity: TemplateProblemSeverity,
39    pub message: String,
40    /// Where in the template the problem starts (from 1), when known.
41    pub line: Option<usize>,
42    pub column: Option<usize>,
43}
44
45#[derive(Debug, Clone, PartialEq, Eq)]
46pub struct RenderedTemplate {
47    pub text: String,
48    pub problems: Vec<TemplateProblem>,
49}
50
51impl RenderedTemplate {
52    pub fn has_errors(&self) -> bool {
53        self.problems
54            .iter()
55            .any(|problem| problem.severity == TemplateProblemSeverity::Error)
56    }
57}
58
59/// Renders leniently, as the UI preview does: an undefined value renders empty with a warning.
60pub fn render_template(
61    template_text: &str,
62    template_context: &Value,
63    template_functions: &dyn TemplateFunctions,
64    escape: TemplateEscape,
65) -> RenderedTemplate {
66    render_template_in_mode(
67        template_text,
68        template_context,
69        template_functions,
70        escape,
71        TemplateRenderMode::Lenient,
72    )
73}
74
75/// Renders in a mode. Unknown names and unbalanced braces are found before rendering and
76/// stop it (the text is returned as written); a failed render returns no text.
77pub fn render_template_in_mode(
78    template_text: &str,
79    template_context: &Value,
80    template_functions: &dyn TemplateFunctions,
81    escape: TemplateEscape,
82    render_mode: TemplateRenderMode,
83) -> RenderedTemplate {
84    let template_text: &str = &rewrite_postman_aliases(template_text);
85    let function_names = template_functions.function_names();
86    let mut problems = find_template_problems(
87        template_text,
88        template_context,
89        &function_names,
90        render_mode == TemplateRenderMode::Lenient,
91    );
92    let static_result = RenderedTemplate {
93        text: template_text.to_owned(),
94        problems: problems.clone(),
95    };
96    if static_result.has_errors() {
97        return static_result;
98    }
99    let environment =
100        build_template_environment(template_functions.to_shared(), escape, render_mode);
101    let render_result = environment.render_str(
102        template_text,
103        minijinja::Value::from(Serde(template_context)),
104    );
105    let rendered_text = match render_result {
106        Ok(rendered_text) if rendered_text.len() > MAXIMUM_RENDERED_BYTES => {
107            let message = "The rendered text is over 1 MB".to_owned();
108            problems.push(build_problem(
109                template_text,
110                TemplateProblemSeverity::Error,
111                message,
112                0,
113            ));
114            String::new()
115        }
116        Ok(rendered_text) => rendered_text,
117        Err(render_error) => {
118            problems.push(describe_render_error(template_text, &render_error));
119            String::new()
120        }
121    };
122    RenderedTemplate {
123        text: rendered_text,
124        problems,
125    }
126}
127
128/// The expression an error points at, without its `{{ }}`.
129fn read_error_source(template_text: &str, render_error: &Error) -> Option<String> {
130    let error_range = render_error.range()?;
131    // A failed lookup such as `.missing.address` points after its root; reach back to it.
132    let path_start = template_text
133        .get(..error_range.start)?
134        .rfind(|character: char| {
135            !(character.is_ascii_alphanumeric() || matches!(character, '_' | '.' | '[' | ']'))
136        })
137        .map_or(0, |boundary_index| boundary_index + 1);
138    let source_text = template_text.get(path_start..error_range.end)?;
139    let expression_text = source_text
140        .trim()
141        .trim_start_matches("{{")
142        .trim_end_matches("}}")
143        .trim();
144    (!expression_text.is_empty()).then(|| expression_text.to_owned())
145}
146
147pub(super) fn describe_render_error(template_text: &str, render_error: &Error) -> TemplateProblem {
148    let detail = render_error.detail().unwrap_or_default();
149    let message = match render_error.kind() {
150        ErrorKind::UndefinedError => match read_error_source(template_text, render_error) {
151            Some(expression_text) => format!("Undefined variable: {expression_text}"),
152            None => "Undefined variable".to_owned(),
153        },
154        ErrorKind::SyntaxError => format!("Syntax error: {detail}"),
155        ErrorKind::OutOfFuel => "The template ran too long and was stopped".to_owned(),
156        ErrorKind::UnknownFilter => format!("Unknown filter: {detail}"),
157        ErrorKind::UnknownFunction => format!("Unknown function: {detail}"),
158        other_kind if detail.is_empty() => other_kind.to_string(),
159        _ => detail.to_owned(),
160    };
161    let byte_offset = render_error
162        .range()
163        .map(|error_range| error_range.start)
164        .or_else(|| {
165            let error_line = render_error.line()?;
166            Some(line_start_offset(template_text, error_line))
167        })
168        .unwrap_or(0);
169    build_problem(
170        template_text,
171        TemplateProblemSeverity::Error,
172        message,
173        byte_offset,
174    )
175}
176
177fn line_start_offset(template_text: &str, line: usize) -> usize {
178    template_text
179        .match_indices('\n')
180        .nth(line.saturating_sub(2))
181        .filter(|_| line > 1)
182        .map_or(0, |(newline_index, _)| newline_index + 1)
183}