jsonlogic_rs  

A JsonLogic implementation in Rust.

To use this library, add

[dependencies]
jsonlogic = "0.5"

to your Cargo.toml.

Usage

use serde_json::{json, Value};

let rule = json!({
    "===": [
        2,
        { "var": "foo" }
    ]
});

let data = json!({ "foo": 2 });
assert_eq!(jsonlogic::apply(&rule, &data), Ok(Value::Bool(true)));

let data = json!({ "foo": 3 });
assert_eq!(jsonlogic::apply(&rule, &data), Ok(Value::Bool(false)));

See the examples directory for more usage examples.

Operations

jsonlogic_rs supports all JsonLogic operations. For detailed informations about all operations and their arguments, head over to Supported Operations on jsonlogic.com.

For Rust usage examples and edge cases have a look at the linked tests for each operator below.

• Accessing Data
  • var
  • missing
  • missing_some
• Logic and Boolean Operations
  • if
  • ==
  • ===
  • !=
  • !==
  • !
  • !!
  • or
  • and
• Numeric Operations
  • >, >=, <, and <=
  • Between (exclusive, inclusive)
  • max and min
  • Arithmetic, + - * /
  • %
• Array Operations
  • map, reduce and filter
  • all, none and some
  • merge
  • in
• String Operations
  • in
  • cat
  • substr
  • match
• Miscellaneous
  • log
• Juspay Version Comparision
  • jp_ver_eq
  • jp_ver_gt
  • jp_ver_ge
  • jp_ver_lt
  • jp_ver_le

Validation

The library now includes a validation module to ensure JSON Logic rules conform to your requirements:

use jsonlogic::validation::{ValidationConfig, validate, allowed_operators, variable_set, RequireAndWrapper};
use serde_json::json;

// Create a validation configuration
let config = ValidationConfig {
    require_and_wrapper: Some(RequireAndWrapper { allow_empty: true }),
};

// Validate a rule
let rule = json!({
    "and": [
        {"==": [{"var": "age"}, 18]},
        {"==": [{"var": "name"}, Joe]},
    ]
});

match validate(&rule, &config) {
    Ok(_) => println!("Rule is valid!"),
    Err(err) => println!("Validation failed: {} at {}", err.message, err.path),
}

The validation module lets you:

• Require rules to be wrapped in an 'and' block (with option to allow empty rules)

Future versions will include more validation options, such as:

• Restrict which operators can be used
• Limit the depth of the rule's expression tree
• Control which variables can be accessed
• Ensure required variables are present
• Apply custom validation logic