adapters 0.0.0

A high-performance, native Rust schema validation, serialization, deserialization, and data transformation library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

# Advanced Validators

This example showcases modern complex constraints (like `non_empty`, `alphanumeric`, `positive`, `negative`, and `non_zero`) implemented via tags or dynamic programmatic builders.

### Compilable Example

```rust
//! Advanced validation rules example showcasing `non_empty`, `alphanumeric`,
//! `positive`, `negative`, and `non_zero` validation rules both via declarative
//! macros and programmatic builders.

use adapters::SchemaValidator;
use adapters::prelude::*;
use adapters::schema::{FloatSchema, IntegerSchema, ObjectSchema, StringSchema};

/// A financial invoice transaction derived using macro constraints.
#[derive(Schema, Debug)]
struct TransactionInvoice {
    /// Reference code must be alphanumeric and non-empty.
    #[schema(non_empty, alphanumeric)]
    reference_code: String,

    /// Number of items must be strictly positive (> 0).
    #[schema(positive)]
    quantity: i32,

    /// Adjustments or discounts must be strictly negative (< 0.0).
    #[schema(negative)]
    discount: f32,

    /// Balance cannot be zero (!= 0).
    #[schema(non_zero)]
    balance: i64,
}

fn main() -> Result<(), Error> {
    println!("=== 1. Declarative Macro Validation ===");

    // Valid Payload
    let valid_json = r#"{
        "reference_code": "INV2026TX",
        "quantity": 5,
        "discount": -15.50,
        "balance": 250
    }"#;
    let invoice = TransactionInvoice::from_json(valid_json)?;
    println!(
        "Successfully parsed and validated valid invoice:\n{:#?}\n",
        invoice
    );

    // Invalid Payload with multiple constraint violations
    let invalid_json = r#"{
        "reference_code": "INV-2026-TX!",
        "quantity": 0,
        "discount": 5.50,
        "balance": 0
    }"#;

    match TransactionInvoice::from_json(invalid_json) {
        Ok(_) => println!("Error: Expected validation failure but succeeded!"),
        Err(e) => {
            println!("Validation failed as expected! Errors:");
            println!("{}", e);
        }
    }

    println!("\n=== 2. Programmatic Builder Validation ===");

    // Build the identical validation logic programmatically
    let invoice_schema = ObjectSchema::new()
        .field(
            "reference_code",
            StringSchema::new().required().non_empty().alphanumeric(),
        )
        .field("quantity", IntegerSchema::new().required().positive())
        .field("discount", FloatSchema::new().required().negative())
        .field("balance", IntegerSchema::new().required().non_zero());

    // Validate a dynamic Value payload using our schema
    let dynamic_invalid_payload = Value::Object(
        [
            ("reference_code".to_string(), Value::String("".to_string())), // Fails non_empty
            ("quantity".to_string(), Value::Int(-10)),                     // Fails positive
            ("discount".to_string(), Value::Float(-5.0)),                  // Passes negative
            ("balance".to_string(), Value::Int(0)),                        // Fails non_zero
        ]
        .into_iter()
        .collect(),
    );

    match invoice_schema.validate(&dynamic_invalid_payload, "invoice") {
        Ok(_) => println!("Error: Expected programmatic validation failure!"),
        Err(err) => {
            println!("Programmatic validation detected constraint violations successfully:");
            println!(
                "Field: {}, Code: {}, Message: {}",
                err.field, err.code, err.message
            );
        }
    }

    Ok(())
}
```