Struct Rule

pub struct Rule;

Factory for creating validation rules

Implementations

impl Rule

pub fn required() -> impl Validator

Validates that value is not null

Example

use validate_ro::rules::Rule;

let validator = Rule::required();

pub fn string() -> impl Validator

Validates that value is a string (or null)

pub fn array() -> impl Validator

Validates that value is an array (or null)

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::array();
assert!(validator.validate(&json!([1, 2, 3])).is_ok());

pub fn object() -> impl Validator

Validates that value is an object (or null)

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::object();
assert!(validator.validate(&json!({"key": "value"})).is_ok());

pub fn boolean() -> impl Validator

Validates that value is a boolean (or null)

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::boolean();
assert!(validator.validate(&json!(true)).is_ok());

pub fn float() -> impl Validator

Validates that value is a float number (or null)

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::float();
assert!(validator.validate(&json!(3.14)).is_ok());

pub fn integer() -> impl Validator

Validates that value is an integer (or null)

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::integer();
assert!(validator.validate(&json!(42)).is_ok());

pub fn length(len: usize) -> impl Validator

Validates exact length for strings/arrays/objects

Arguments

• len - Exact required length

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::length(3);
assert!(validator.validate(&json!("abc")).is_ok());
assert!(validator.validate(&json!([1, 2, 3])).is_ok());

pub fn min_length(min: usize) -> impl Validator

Validates minimum length for strings/arrays/objects

Arguments

• min - Minimum allowed length

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::min_length(5);
assert!(validator.validate(&json!("long enough")).is_ok());

pub fn max_length(max: usize) -> impl Validator

Validates maximum length for strings/arrays/objects

Arguments

• max - Maximum allowed length

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::max_length(10);
assert!(validator.validate(&json!("short")).is_ok());

pub fn equal(value: Value) -> impl Validator

Validates exact value match

Arguments

• value - Expected value to match against

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::equal(json!("expected"));
assert!(validator.validate(&json!("expected")).is_ok());

pub fn min_value(min: f64) -> impl Validator

Validates minimum numeric value

Arguments

• min - Minimum allowed value

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::min_value(18.0);
assert!(validator.validate(&json!(21)).is_ok());

pub fn max_value(max: f64) -> impl Validator

Validates maximum numeric value

Arguments

• max - Maximum allowed value

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::max_value(100.0);
assert!(validator.validate(&json!(75)).is_ok());

pub fn numeric() -> impl Validator

Validates that string can be parsed as number (or null)

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::numeric();
assert!(validator.validate(&json!("123.45")).is_ok());

pub fn accepted() -> impl Validator

Validates common “accepted” terms (true, 1, “yes”, “on”)

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::accepted();
assert!(validator.validate(&json!("yes")).is_ok());
assert!(validator.validate(&json!(true)).is_ok());

pub fn email(allowed_domains: Option<Vec<String>>) -> impl Validator

Validates that string matches email format

Arguments

• allowed_domains - Optional list of allowed email domains

Example

use validate_ro::rules::Rule;

// Only allow @company.com emails
let validator = Rule::email(Some(vec!["company.com".to_string()]));

pub fn in_values(values: Vec<Value>) -> impl Validator

Validates that value is in allowed set

Arguments

• values - Allowed values

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::in_values(vec![json!("red"), json!("blue")]);
assert!(validator.validate(&json!("red")).is_ok());

pub fn not_in_values(values: Vec<Value>) -> impl Validator

Validates that value is not in excluded set

Arguments

• values - Excluded values

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::not_in_values(vec![json!("admin")]);
assert!(validator.validate(&json!("user")).is_ok());

pub fn regex( pattern: &str, message: Option<String>, ) -> Result<impl Validator, Error>

Validates string against regex pattern

Arguments

• pattern - Regex pattern
• message - Optional custom error message

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::regex(r"^\d{3}-\d{3}$", None).unwrap();
assert!(validator.validate(&json!("123-456")).is_ok());

pub fn url() -> impl Validator

Validates that value is a valid URL (or null)

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::url();
assert!(validator.validate(&json!("https://example.com")).is_ok());

pub fn ip() -> impl Validator

Validates that value is a valid IP address (or null)

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::ip();
assert!(validator.validate(&json!("192.168.1.1")).is_ok());

pub fn extensions(allowed: Vec<String>) -> impl Validator

Validates file extension against allowed set

Arguments

• allowed - List of allowed extensions (without dots)

Example

use serde_json::json;
use validate_ro::rules::Rule;

let validator = Rule::extensions(vec!["png".into(), "jpg".into()]);
assert!(validator.validate(&json!("image.png")).is_ok());

pub fn custom<F>(validator: F) -> impl Validator

where F: Fn(&Value) -> ValidationResult + Send + Sync + 'static,

Creates custom validator from closure

Arguments

• validator - Validation function

Example

use serde_json::json;
use validate_ro::error::ValidationError;
use validate_ro::rules::Rule;

let validator = Rule::custom(|value| {
    if value == "secret" {
        Ok(())
    } else {
        Err(ValidationError::Custom("Invalid value".into()))
    }
});

pub fn unique( collection: &str, field: &str, exclude: Option<ObjectId>, ) -> impl Validator

Validates field value is unique in MongoDB collection

Arguments

• collection - MongoDB collection name
• field - Field name to check uniqueness
• exclude - Optional document ID to exclude from check (for updates)

Example

use validate_ro::rules::Rule;

// For new documents:
let validator = Rule::unique("users", "email", None);

// When updating document:
let validator = Rule::unique("users", "email", Some(user_id));