zod-rs 1.0.1

TypeScript Zod-inspired schema validation library for Rust with static type inference
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

mod array;
mod boolean;
mod literal;
mod null;
mod number;
mod object;
mod optional;
mod string;
mod tuple;
mod union;

pub use array::*;
pub use boolean::*;
pub use literal::*;
pub use null::*;
pub use number::*;
pub use object::*;
pub use optional::*;
pub use string::*;
pub use tuple::*;
pub use union::*;

use serde_json::Value;
use std::fmt::Debug;
use zod_rs_util::ValidateResult;

pub trait Schema<T>: Debug
where
    T: std::fmt::Debug,
{
    /// Validates the value against this schema and returns the validated result.
    fn validate(&self, value: &Value) -> ValidateResult<T>;

    /// Validates and returns the result, panicking on validation failure.
    ///
    /// # Panics
    /// Panics if validation fails. Use `safe_parse()` or `validate()` for non-panicking alternatives.
    ///
    /// # Example
    /// ```should_panic
    /// use zod_rs::prelude::*;
    /// use serde_json::json;
    ///
    /// let schema = string().min(5);
    /// let result = schema.parse(&json!("hi")); // panics: string too short
    /// ```
    fn parse(&self, value: &Value) -> T {
        match self.validate(value) {
            Ok(result) => result,
            Err(errors) => panic!("Validation failed: {errors}"),
        }
    }

    /// Validates the value and returns a Result. This is the recommended method for handling
    /// validation in production code.
    fn safe_parse(&self, value: &Value) -> ValidateResult<T> {
        self.validate(value)
    }

    fn optional(self) -> OptionalSchema<Self, T>
    where
        Self: Sized,
    {
        OptionalSchema::new(self)
    }

    fn array(self) -> ArraySchema<Self, T>
    where
        Self: Sized,
    {
        ArraySchema::new(self)
    }
}