json-eval-rs 0.0.99

High-performance JSON Logic evaluator with schema validation and dependency tracking. Built on blazing-fast Rust engine.
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! WASM type definitions

use crate::jsoneval::cancellation::CancellationToken;
use crate::JSONEval;
use serde::{Deserialize, Serialize};
use wasm_bindgen::prelude::*;

/// Validation error for JavaScript
#[wasm_bindgen]
#[derive(Clone, Serialize, Deserialize)]
pub struct ValidationError {
    path: String,
    #[serde(rename = "type")]
    rule_type: String,
    message: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    code: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pattern: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "fieldValue")]
    field_value: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    data: Option<serde_json::Value>,
}

#[wasm_bindgen]
impl ValidationError {
    #[wasm_bindgen(getter)]
    pub fn path(&self) -> String {
        self.path.clone()
    }

    #[wasm_bindgen(getter)]
    pub fn rule_type(&self) -> String {
        self.rule_type.clone()
    }

    #[wasm_bindgen(getter)]
    pub fn message(&self) -> String {
        self.message.clone()
    }

    #[wasm_bindgen(getter)]
    pub fn code(&self) -> Option<String> {
        self.code.clone()
    }

    #[wasm_bindgen(getter)]
    pub fn pattern(&self) -> Option<String> {
        self.pattern.clone()
    }

    #[wasm_bindgen(getter)]
    pub fn field_value(&self) -> Option<String> {
        self.field_value.clone()
    }

    #[wasm_bindgen(getter)]
    pub fn data(&self) -> JsValue {
        self.data
            .as_ref()
            .and_then(|d| super::to_value(d).ok())
            .unwrap_or(JsValue::NULL)
    }
}

/// Validation result for JavaScript
#[wasm_bindgen]
#[derive(Serialize, Deserialize)]
pub struct ValidationResult {
    has_error: bool,
    error: std::collections::HashMap<String, ValidationError>,
}

#[wasm_bindgen]
impl ValidationResult {
    #[wasm_bindgen(getter)]
    pub fn has_error(&self) -> bool {
        self.has_error
    }

    #[wasm_bindgen(getter)]
    pub fn error(&self) -> JsValue {
        serde_wasm_bindgen::to_value(&self.error).unwrap_or(JsValue::NULL)
    }

    #[wasm_bindgen(js_name = toJSON)]
    pub fn to_json(&self) -> Result<JsValue, JsValue> {
        super::to_value(&self).map_err(|e| JsValue::from_str(&e.to_string()))
    }
}

/// WebAssembly wrapper for JSONEval
#[wasm_bindgen]
pub struct JSONEvalWasm {
    pub(super) inner: JSONEval,
    pub(super) current_token: Option<CancellationToken>,
}

impl JSONEvalWasm {
    pub(super) fn reset_token(&mut self) -> Option<CancellationToken> {
        if let Some(token) = &self.current_token {
            token.cancel();
        }
        let new_token = CancellationToken::new();
        self.current_token = Some(new_token.clone());
        Some(new_token)
    }
}

// Helper function to create ValidationError from internal type
pub(super) fn create_validation_error(
    path: String,
    error: &crate::ValidationError,
) -> ValidationError {
    ValidationError {
        path,
        rule_type: error.rule_type.clone(),
        message: error.message.clone(),
        code: error.code.clone(),
        pattern: error.pattern.clone(),
        field_value: error.field_value.clone(),
        data: error.data.clone(),
    }
}

// Helper function to create ValidationResult from internal type
pub(super) fn create_validation_result(
    has_error: bool,
    error: std::collections::HashMap<String, ValidationError>,
) -> ValidationResult {
    ValidationResult { has_error, error }
}