use crate::json::{obj, Json};
use crate::types::{Errc, RcpError};
pub const SCALAR_OPS: [&str; 6] = ["eq", "ne", "gt", "gte", "lt", "lte"];
pub const ARRAY_OPS: [&str; 2] = ["in", "nin"];
pub const UNARY_OPS: [&str; 1] = ["exists"];
pub const STRING_OPS: [&str; 1] = ["contains"];
const ORDERED_OPS: [&str; 4] = ["gt", "gte", "lt", "lte"];
const ORDERED_TYPES: [&str; 3] = ["int", "float", "date"];
fn is_known_op(op: &str) -> bool {
SCALAR_OPS.contains(&op)
|| ARRAY_OPS.contains(&op)
|| UNARY_OPS.contains(&op)
|| STRING_OPS.contains(&op)
}
#[derive(Clone, Debug)]
pub struct Filter(Json);
impl Filter {
pub fn to_json(&self) -> Json {
self.0.clone()
}
pub fn and(self, other: Filter) -> Filter {
all([self, other])
}
pub fn or(self, other: Filter) -> Filter {
any([self, other])
}
pub fn negate(self) -> Filter {
Filter(obj(&[("not", self.0)]))
}
}
impl std::ops::Not for Filter {
type Output = Filter;
fn not(self) -> Filter {
self.negate()
}
}
impl std::ops::BitAnd for Filter {
type Output = Filter;
fn bitand(self, rhs: Filter) -> Filter {
self.and(rhs)
}
}
impl std::ops::BitOr for Filter {
type Output = Filter;
fn bitor(self, rhs: Filter) -> Filter {
self.or(rhs)
}
}
fn leaf(field: &str, op: &str, value: Json) -> Filter {
Filter(obj(&[
("field", Json::from(field)),
("op", Json::from(op)),
("value", value),
]))
}
pub fn eq(field: &str, value: impl Into<Json>) -> Filter {
leaf(field, "eq", value.into())
}
pub fn ne(field: &str, value: impl Into<Json>) -> Filter {
leaf(field, "ne", value.into())
}
pub fn gt(field: &str, value: impl Into<Json>) -> Filter {
leaf(field, "gt", value.into())
}
pub fn gte(field: &str, value: impl Into<Json>) -> Filter {
leaf(field, "gte", value.into())
}
pub fn lt(field: &str, value: impl Into<Json>) -> Filter {
leaf(field, "lt", value.into())
}
pub fn lte(field: &str, value: impl Into<Json>) -> Filter {
leaf(field, "lte", value.into())
}
pub fn in_(field: &str, values: impl IntoIterator<Item = Json>) -> Filter {
leaf(field, "in", Json::Array(values.into_iter().collect()))
}
pub fn nin(field: &str, values: impl IntoIterator<Item = Json>) -> Filter {
leaf(field, "nin", Json::Array(values.into_iter().collect()))
}
pub fn contains(field: &str, value: impl Into<Json>) -> Filter {
leaf(field, "contains", value.into())
}
pub fn exists(field: &str, present: bool) -> Filter {
leaf(field, "exists", Json::Bool(present))
}
pub fn all(clauses: impl IntoIterator<Item = Filter>) -> Filter {
combine("and", clauses)
}
pub fn any(clauses: impl IntoIterator<Item = Filter>) -> Filter {
combine("or", clauses)
}
pub fn not(clause: Filter) -> Filter {
clause.negate()
}
fn combine(kind: &str, clauses: impl IntoIterator<Item = Filter>) -> Filter {
let arr = Json::Array(clauses.into_iter().map(|c| c.0).collect());
Filter(obj(&[(kind, arr)]))
}
pub fn validate(
node: Option<&Json>,
fields: Option<&[(&str, &str)]>,
operators: Option<&[&str]>,
max_depth: i32,
) -> Result<Option<Json>, RcpError> {
let node = match node {
None => return Ok(None),
Some(n) if n.is_null() => return Ok(None),
Some(Json::Object(o)) if o.is_empty() => return Ok(None),
Some(n) => n,
};
Ok(Some(validate_node(node, fields, operators, "filter", max_depth)?))
}
fn validate_node(
node: &Json,
fields: Option<&[(&str, &str)]>,
operators: Option<&[&str]>,
path: &str,
depth: i32,
) -> Result<Json, RcpError> {
if depth < 0 {
return Err(bad(path, "filter nesting too deep"));
}
let obj_pairs = match node.as_object() {
Some(o) => o,
None => return Err(bad(path, "filter node must be an object")),
};
let has = |k: &str| obj_pairs.iter().any(|(kk, _)| kk == k);
let present: Vec<&str> = ["and", "or", "not"].into_iter().filter(|k| has(k)).collect();
let is_leaf = has("field") || has("op");
if present.len() > 1 {
return Err(bad(path, "filter node has multiple combinators"));
}
if !present.is_empty() && is_leaf {
return Err(bad(path, "filter node mixes a combinator with a leaf"));
}
if let Some(&comb) = present.first() {
if comb == "not" {
let child = node.get("not").unwrap();
let inner = validate_node(child, fields, operators, &format!("{path}.not"), depth - 1)?;
return Ok(obj(&[("not", inner)]));
}
let kids = match node.get(comb).and_then(|v| v.as_array()) {
Some(a) => a,
None => return Err(bad(&format!("{path}.{comb}"), "combinator must be an array")),
};
let mut out = Vec::with_capacity(kids.len());
for (i, c) in kids.iter().enumerate() {
out.push(validate_node(c, fields, operators, &format!("{path}.{comb}[{i}]"), depth - 1)?);
}
return Ok(obj(&[(comb, Json::Array(out))]));
}
if !is_leaf {
return Err(bad(path, "filter node is neither a combinator nor a leaf"));
}
let field = match node.get_str("field") {
Some(f) if !f.is_empty() => f,
_ => return Err(bad(path, "leaf requires a non-empty string 'field'")),
};
let op = match node.get_str("op") {
Some(o) => o,
None => return Err(bad(&format!("{path}.op"), "leaf requires a string 'op'")),
};
if !is_known_op(op) {
return Err(bad(&format!("{path}.op"), &format!("unknown operator '{op}'")));
}
if let Some(ops) = operators {
if !ops.contains(&op) {
return Err(bad(&format!("{path}.op"), &format!("operator '{op}' not advertised")));
}
}
let ftype = match fields {
Some(fs) => match fs.iter().find(|(n, _)| *n == field) {
Some((_, t)) => Some(*t),
None => return Err(bad(&format!("{path}.{field}"), &format!("field '{field}' not advertised"))),
},
None => None,
};
check_value(op, node, ftype, path)?;
let value = if UNARY_OPS.contains(&op) {
Json::Bool(node.get("value").and_then(|v| v.as_bool()).unwrap_or(true))
} else {
node.get("value").cloned().unwrap()
};
Ok(obj(&[
("field", Json::from(field)),
("op", Json::from(op)),
("value", value),
]))
}
fn check_value(op: &str, node: &Json, ftype: Option<&str>, path: &str) -> Result<(), RcpError> {
if UNARY_OPS.contains(&op) {
return Ok(());
}
let value = match node.get("value") {
Some(v) => v,
None => return Err(bad(&format!("{path}.value"), &format!("operator '{op}' requires a 'value'"))),
};
if ARRAY_OPS.contains(&op) {
match value.as_array() {
Some(a) if !a.is_empty() => {
if a.iter().any(|v| matches!(v, Json::Array(_) | Json::Object(_))) {
return Err(bad(&format!("{path}.value"), &format!("operator '{op}' array must hold scalars")));
}
}
_ => return Err(bad(&format!("{path}.value"), &format!("operator '{op}' requires a non-empty array"))),
}
} else if (SCALAR_OPS.contains(&op) || STRING_OPS.contains(&op))
&& matches!(value, Json::Array(_) | Json::Object(_))
{
return Err(bad(&format!("{path}.value"), &format!("operator '{op}' requires a scalar value")));
}
if ORDERED_OPS.contains(&op) {
if let Some(t) = ftype {
if !t.is_empty() && !ORDERED_TYPES.contains(&t) {
return Err(bad(&format!("{path}.op"), &format!("operator '{op}' not valid on '{t}' field")));
}
}
}
Ok(())
}
fn bad(path: &str, message: &str) -> RcpError {
RcpError::with_data(
Errc::INVALID_PARAMS,
format!("{message} ({path})"),
obj(&[("field", Json::from(path))]),
)
}
#[cfg(test)]
mod tests {
use super::*;
const FIELDS: [(&str, &str); 2] = [("year", "int"), ("lang", "keyword")];
const OPS: [&str; 8] = ["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin"];
#[test]
fn builder_emits_spec_shape() {
let leaf = eq("lang", "fr").to_json();
assert_eq!(leaf.get_str("field"), Some("lang"));
assert_eq!(leaf.get_str("op"), Some("eq"));
assert_eq!(leaf.get("value").and_then(|v| v.as_str()), Some("fr"));
let tree = eq("lang", "en").and(gte("year", 2015i64)).to_json();
let arr = tree.get("and").and_then(|v| v.as_array()).unwrap();
assert_eq!(arr.len(), 2);
}
#[test]
fn validate_accepts_well_formed() {
let tree = all([eq("lang", "en"), gte("year", 2015i64)]).to_json();
let out = validate(Some(&tree), Some(&FIELDS), Some(&OPS), 32).unwrap();
assert!(out.is_some());
assert!(validate(None, Some(&FIELDS), None, 32).unwrap().is_none());
assert!(validate(Some(&Json::object()), Some(&FIELDS), None, 32).unwrap().is_none());
}
#[test]
fn validate_rejects_every_malformed_tree_with_32602() {
let cases = [
obj(&[("field", "author".into()), ("op", "eq".into()), ("value", "z".into())]),
obj(&[("field", "lang".into()), ("op", "equals".into()), ("value", "en".into())]),
obj(&[("and", "not-a-list".into())]),
obj(&[("field", "year".into()), ("op", "in".into()), ("value", Json::Int(2017))]),
obj(&[("or", Json::Array(vec![obj(&[("field", "lang".into())])]))]),
obj(&[("field", "lang".into()), ("op", "gt".into()), ("value", "en".into())]),
];
for c in &cases {
let err = validate(Some(c), Some(&FIELDS), Some(&OPS), 32).unwrap_err();
assert_eq!(err.code, Errc::INVALID_PARAMS, "case: {}", c.dump());
assert!(err.data.as_ref().and_then(|d| d.get("field")).is_some());
}
}
}