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
10pub const MAXIMUM_RENDERED_BYTES: usize = 1024 * 1024;
12
13#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16pub enum TemplateEscape {
17 None,
18 JsonString,
19}
20
21#[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 Warning,
32 Error,
34}
35
36#[derive(Debug, Clone, PartialEq, Eq)]
37pub struct TemplateProblem {
38 pub severity: TemplateProblemSeverity,
39 pub message: String,
40 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
59pub 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
75pub 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
128fn read_error_source(template_text: &str, render_error: &Error) -> Option<String> {
130 let error_range = render_error.range()?;
131 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}