papermake 0.1.0

Fast PDF generation library using Typst with schema validation and caching
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
135
136

//! Macros for ergonomic schema and template definition

/// Macro for declarative schema definition
/// 
/// # Examples
/// 
/// ```rust
/// use papermake::{schema, FieldType};
/// 
/// let schema = schema! {
///     name: String,
///     email: String,
///     age?: Number,
///     active: Boolean
/// };
/// ```
#[macro_export]
macro_rules! schema {
    // Handle empty schema
    {} => {
        $crate::Schema::new()
    };
    
    // Required field: name: Type
    ($name:ident: $type:ident $(, $($rest:tt)*)?) => {
        {
            let mut builder = $crate::Schema::builder();
            builder = builder.field(stringify!($name), schema!(@type $type));
            $(
                builder = schema!(@parse builder, $($rest)*);
            )?
            builder.build()
        }
    };
    
    // Optional field: name?: Type
    ($name:ident ?: $type:ident $(, $($rest:tt)*)?) => {
        {
            let mut builder = $crate::Schema::builder();
            builder = builder.optional(stringify!($name), schema!(@type $type));
            $(
                builder = schema!(@parse builder, $($rest)*);
            )?
            builder.build()
        }
    };
    
    // Parse additional fields
    (@parse $builder:expr, $name:ident: $type:ident $(, $($rest:tt)*)?) => {
        {
            let mut builder = $builder.field(stringify!($name), schema!(@type $type));
            $(
                builder = schema!(@parse builder, $($rest)*);
            )?
            builder
        }
    };
    
    (@parse $builder:expr, $name:ident ?: $type:ident $(, $($rest:tt)*)?) => {
        {
            let mut builder = $builder.optional(stringify!($name), schema!(@type $type));
            $(
                builder = schema!(@parse builder, $($rest)*);
            )?
            builder
        }
    };
    
    // Type mappings
    (@type String) => { $crate::FieldType::String };
    (@type Number) => { $crate::FieldType::Number };
    (@type Boolean) => { $crate::FieldType::Boolean };
    (@type Date) => { $crate::FieldType::Date };
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{Schema, FieldType};
    use serde_json::json;

    #[test]
    fn test_simple_schema_macro() {
        let schema = schema! {
            name: String,
            age: Number,
            active: Boolean
        };
        
        assert_eq!(schema.fields.len(), 3);
        assert_eq!(schema.fields[0].key, "name");
        assert_eq!(schema.fields[0].field_type, FieldType::String);
        assert!(schema.fields[0].required);
        
        assert_eq!(schema.fields[1].key, "age");
        assert_eq!(schema.fields[1].field_type, FieldType::Number);
        assert!(schema.fields[1].required);
    }

    #[test]
    fn test_optional_fields_schema_macro() {
        let schema = schema! {
            name: String,
            age?: Number,
            email?: String
        };
        
        assert_eq!(schema.fields.len(), 3);
        assert!(schema.fields[0].required);
        assert!(!schema.fields[1].required);
        assert!(!schema.fields[2].required);
    }

    // Simplified tests for now - complex nested objects would need more macro work
    #[test]
    fn test_simple_validation_with_macro() {
        let schema = schema! {
            name: String,
            age?: Number
        };
        
        let valid_data = json!({
            "name": "John Doe",
            "age": 30
        });
        
        assert!(schema.validate(&valid_data).is_ok());
        
        let invalid_data = json!({
            "age": 30
            // missing required name
        });
        
        assert!(schema.validate(&invalid_data).is_err());
    }
}