nitr_std/validate/engine/
errors.rs1use mlua::{Lua, Table, Value};
11
12use super::super::message::Param;
13
14#[derive(Debug, Clone, PartialEq)]
16pub struct ErrorEntry {
17 pub path: String,
19 pub field: String,
21 pub part: Option<String>,
24 pub rule: String,
26 pub message: String,
28 pub(crate) params: Vec<(String, Param)>,
30 pub label: Option<String>,
32}
33
34impl ErrorEntry {
35 pub fn params_json(&self) -> Option<serde_json::Value> {
37 if self.params.is_empty() {
38 return None;
39 }
40 Some(serde_json::Value::Object(
41 self.params
42 .iter()
43 .map(|(k, v)| (k.clone(), v.to_json()))
44 .collect(),
45 ))
46 }
47}
48
49#[derive(Debug, Clone, PartialEq)]
52pub struct ValidationError {
53 pub message: String,
55 pub entries: Vec<ErrorEntry>,
57}
58
59impl ValidationError {
60 pub fn single(rule: &str, message: &str) -> Self {
63 Self {
64 message: "validation failed".into(),
65 entries: vec![ErrorEntry {
66 path: "$".into(),
67 field: String::new(),
68 part: None,
69 rule: rule.into(),
70 message: message.into(),
71 params: Vec::new(),
72 label: None,
73 }],
74 }
75 }
76
77 pub fn prefix(&mut self, part: &str) {
80 for entry in &mut self.entries {
81 entry.path = if entry.path == "$" {
82 part.to_string()
83 } else {
84 format!("{part}.{}", entry.path)
85 };
86 entry.part = Some(part.to_string());
87 }
88 }
89
90 pub fn merge(&mut self, other: Self) {
92 self.entries.extend(other.entries);
93 self.entries.sort_by(|a, b| a.path.cmp(&b.path));
94 }
95
96 pub fn to_lua(&self, lua: &Lua) -> mlua::Result<Table> {
98 let err = lua.create_table()?;
99 err.set("code", "VALIDATION_FAILED")?;
100 err.set("message", self.message.as_str())?;
101 let fields = lua.create_table()?;
102 let errors = lua.create_table_with_capacity(self.entries.len(), 0)?;
103 for (i, entry) in self.entries.iter().enumerate() {
104 if fields.get::<Value>(entry.path.as_str())?.is_nil() {
105 fields.set(entry.path.as_str(), entry.message.as_str())?;
106 }
107 let e = lua.create_table()?;
108 e.set("path", entry.path.as_str())?;
109 if let Some(part) = &entry.part {
110 e.set("part", part.as_str())?;
111 }
112 e.set("field", entry.field.as_str())?;
113 e.set("rule", entry.rule.as_str())?;
114 e.set("message", entry.message.as_str())?;
115 if !entry.params.is_empty() {
116 let params = lua.create_table()?;
117 for (k, v) in &entry.params {
118 params.set(k.as_str(), v.to_lua(lua)?)?;
119 }
120 e.set("params", params)?;
121 }
122 if let Some(label) = &entry.label {
123 e.set("label", label.as_str())?;
124 }
125 errors.raw_set(i + 1, e)?;
126 }
127 err.set("fields", fields)?;
128 err.set("errors", errors)?;
129 Ok(err)
130 }
131
132 pub fn to_json(&self) -> serde_json::Value {
134 let mut fields = serde_json::Map::new();
135 let mut errors = Vec::with_capacity(self.entries.len());
136 for entry in &self.entries {
137 fields
138 .entry(entry.path.clone())
139 .or_insert_with(|| serde_json::Value::String(entry.message.clone()));
140 let mut e = serde_json::Map::new();
141 e.insert("path".into(), entry.path.clone().into());
142 if let Some(part) = &entry.part {
143 e.insert("part".into(), part.clone().into());
144 }
145 e.insert("field".into(), entry.field.clone().into());
146 e.insert("rule".into(), entry.rule.clone().into());
147 e.insert("message".into(), entry.message.clone().into());
148 if let Some(params) = entry.params_json() {
149 e.insert("params".into(), params);
150 }
151 if let Some(label) = &entry.label {
152 e.insert("label".into(), label.clone().into());
153 }
154 errors.push(serde_json::Value::Object(e));
155 }
156 serde_json::json!({
157 "code": "VALIDATION_FAILED",
158 "message": self.message,
159 "fields": serde_json::Value::Object(fields),
160 "errors": errors,
161 })
162 }
163}
164
165#[cfg(test)]
166mod tests {
167 use super::*;
168
169 fn entry(path: &str, field: &str, rule: &str) -> ErrorEntry {
170 ErrorEntry {
171 path: path.into(),
172 field: field.into(),
173 part: None,
174 rule: rule.into(),
175 message: format!("{rule} failed"),
176 params: vec![("min".into(), Param::Num(3.0))],
177 label: None,
178 }
179 }
180
181 #[test]
184 fn prefixing_turns_the_root_into_the_part_name() {
185 let mut err = ValidationError::single("json", "must be valid JSON");
186 err.prefix("body");
187 assert_eq!(err.entries[0].path, "body");
188 let json = err.to_json();
189 assert_eq!(json["errors"][0]["part"], "body");
190 assert_eq!(json["errors"][0]["field"], "");
191
192 let mut err = ValidationError {
193 message: "validation failed".into(),
194 entries: vec![entry("body", "body", "required")],
195 };
196 let json = err.to_json();
197 assert!(json["errors"][0].get("part").is_none(), "{json}");
198 assert_eq!(json["errors"][0]["field"], "body");
199 err.prefix("query");
200 let json = err.to_json();
201 assert_eq!(json["errors"][0]["path"], "query.body");
202 assert_eq!(json["errors"][0]["part"], "query");
203 assert_eq!(json["errors"][0]["field"], "body");
204 }
205
206 #[test]
207 fn merge_keeps_paths_sorted_and_json_carries_every_field() {
208 let mut err = ValidationError {
209 message: "validation failed".into(),
210 entries: vec![entry("b", "b", "min")],
211 };
212 err.prefix("query");
213 let mut body = ValidationError {
214 message: String::new(),
215 entries: vec![entry("a", "a", "required")],
216 };
217 body.prefix("body");
218 err.merge(body);
219 assert_eq!(err.entries[0].path, "body.a");
220 let json = err.to_json();
221 assert_eq!(json["code"], "VALIDATION_FAILED");
222 assert_eq!(json["fields"]["query.b"], "min failed");
223 assert_eq!(json["errors"][1]["part"], "query");
224 assert_eq!(json["errors"][1]["params"]["min"], 3.0);
225 }
226}