use mlua::{Lua, Table, Value};
use super::super::message::Param;
#[derive(Debug, Clone, PartialEq)]
pub struct ErrorEntry {
pub path: String,
pub field: String,
pub part: Option<String>,
pub rule: String,
pub message: String,
pub(crate) params: Vec<(String, Param)>,
pub label: Option<String>,
}
impl ErrorEntry {
pub fn params_json(&self) -> Option<serde_json::Value> {
if self.params.is_empty() {
return None;
}
Some(serde_json::Value::Object(
self.params
.iter()
.map(|(k, v)| (k.clone(), v.to_json()))
.collect(),
))
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct ValidationError {
pub message: String,
pub entries: Vec<ErrorEntry>,
}
impl ValidationError {
pub fn single(rule: &str, message: &str) -> Self {
Self {
message: "validation failed".into(),
entries: vec![ErrorEntry {
path: "$".into(),
field: String::new(),
part: None,
rule: rule.into(),
message: message.into(),
params: Vec::new(),
label: None,
}],
}
}
pub fn prefix(&mut self, part: &str) {
for entry in &mut self.entries {
entry.path = if entry.path == "$" {
part.to_string()
} else {
format!("{part}.{}", entry.path)
};
entry.part = Some(part.to_string());
}
}
pub fn merge(&mut self, other: Self) {
self.entries.extend(other.entries);
self.entries.sort_by(|a, b| a.path.cmp(&b.path));
}
pub fn to_lua(&self, lua: &Lua) -> mlua::Result<Table> {
let err = lua.create_table()?;
err.set("code", "VALIDATION_FAILED")?;
err.set("message", self.message.as_str())?;
let fields = lua.create_table()?;
let errors = lua.create_table_with_capacity(self.entries.len(), 0)?;
for (i, entry) in self.entries.iter().enumerate() {
if fields.get::<Value>(entry.path.as_str())?.is_nil() {
fields.set(entry.path.as_str(), entry.message.as_str())?;
}
let e = lua.create_table()?;
e.set("path", entry.path.as_str())?;
if let Some(part) = &entry.part {
e.set("part", part.as_str())?;
}
e.set("field", entry.field.as_str())?;
e.set("rule", entry.rule.as_str())?;
e.set("message", entry.message.as_str())?;
if !entry.params.is_empty() {
let params = lua.create_table()?;
for (k, v) in &entry.params {
params.set(k.as_str(), v.to_lua(lua)?)?;
}
e.set("params", params)?;
}
if let Some(label) = &entry.label {
e.set("label", label.as_str())?;
}
errors.raw_set(i + 1, e)?;
}
err.set("fields", fields)?;
err.set("errors", errors)?;
Ok(err)
}
pub fn to_json(&self) -> serde_json::Value {
let mut fields = serde_json::Map::new();
let mut errors = Vec::with_capacity(self.entries.len());
for entry in &self.entries {
fields
.entry(entry.path.clone())
.or_insert_with(|| serde_json::Value::String(entry.message.clone()));
let mut e = serde_json::Map::new();
e.insert("path".into(), entry.path.clone().into());
if let Some(part) = &entry.part {
e.insert("part".into(), part.clone().into());
}
e.insert("field".into(), entry.field.clone().into());
e.insert("rule".into(), entry.rule.clone().into());
e.insert("message".into(), entry.message.clone().into());
if let Some(params) = entry.params_json() {
e.insert("params".into(), params);
}
if let Some(label) = &entry.label {
e.insert("label".into(), label.clone().into());
}
errors.push(serde_json::Value::Object(e));
}
serde_json::json!({
"code": "VALIDATION_FAILED",
"message": self.message,
"fields": serde_json::Value::Object(fields),
"errors": errors,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
fn entry(path: &str, field: &str, rule: &str) -> ErrorEntry {
ErrorEntry {
path: path.into(),
field: field.into(),
part: None,
rule: rule.into(),
message: format!("{rule} failed"),
params: vec![("min".into(), Param::Num(3.0))],
label: None,
}
}
#[test]
fn prefixing_turns_the_root_into_the_part_name() {
let mut err = ValidationError::single("json", "must be valid JSON");
err.prefix("body");
assert_eq!(err.entries[0].path, "body");
let json = err.to_json();
assert_eq!(json["errors"][0]["part"], "body");
assert_eq!(json["errors"][0]["field"], "");
let mut err = ValidationError {
message: "validation failed".into(),
entries: vec![entry("body", "body", "required")],
};
let json = err.to_json();
assert!(json["errors"][0].get("part").is_none(), "{json}");
assert_eq!(json["errors"][0]["field"], "body");
err.prefix("query");
let json = err.to_json();
assert_eq!(json["errors"][0]["path"], "query.body");
assert_eq!(json["errors"][0]["part"], "query");
assert_eq!(json["errors"][0]["field"], "body");
}
#[test]
fn merge_keeps_paths_sorted_and_json_carries_every_field() {
let mut err = ValidationError {
message: "validation failed".into(),
entries: vec![entry("b", "b", "min")],
};
err.prefix("query");
let mut body = ValidationError {
message: String::new(),
entries: vec![entry("a", "a", "required")],
};
body.prefix("body");
err.merge(body);
assert_eq!(err.entries[0].path, "body.a");
let json = err.to_json();
assert_eq!(json["code"], "VALIDATION_FAILED");
assert_eq!(json["fields"]["query.b"], "min failed");
assert_eq!(json["errors"][1]["part"], "query");
assert_eq!(json["errors"][1]["params"]["min"], 3.0);
}
}