json_validate_rs/
validater.rs

1
2use std::convert::From;
3use json::JsonValue;
4use std::collections::HashSet;
5use regex::Regex;
6
7#[derive(Debug)]
8pub enum FormatError{
9    InvalidDataType,InvalidFormat,
10    InvalidMin,InvalidMax,
11    InvalidSchemaOnData,InvalidSchema,
12    InvalidOptions,OptionsNotAllowed,
13    IsNotObject,IsNotStringArray,
14    ChildrenTypeMissing,InvalidChildrenType,
15    InvalidArrayUniqueKeyType,InvalidMinMaxValues,
16    InvalidMinKeySize,InvalidMaxKeySize,StringRuleNotDefined(String),InvalidChildrenSchema,StringRulesMissing(String),ValidKeyNotString,InvalidValidateRuleAction(String),
17    IncludeIsNotString,ExcludeIsNotString,ElseIsNotString,ElseAnyIsNotString
18}
19
20#[derive(Debug)]
21pub enum DataError{
22    Min,Max,NotFound(String),InvalidDataType,IsNotObject,
23    ExternalDataNotAllowed,InvalidNum,
24    InvalidMax,InvalidMaxNum,InvalidMaxDataType,
25    InvalidMin,InvalidMinNum,InvalidMinDataType,
26    OutOfOptions,DataMaxReached,UnmatchedKey(String),
27    UnMatchedSize,UnSupportedData,InvalidEmail,
28    MissingRequiredOptionField(String),
29    MissingRequiredField(String),
30    ArrayUniqueKeyNotFound(String),ArrayUniqueKeyNotStringType(String),
31    ArrayUniqueKeyDuplicate(String,String),DuplicateArrayString(String),
32    ArrayUniqueValueNotString,InvalidChildDataType(String,String),
33    MinString,MaxString,MaxKeySize,MinKeySize,MissingIncludeKey((String,String)),
34    PresentExcludeKey((String,String)),MissingAllIncludeKey(String),
35    ElseKeyMissing(String),ElseAnyKeyMissing(String)
36}
37
38pub fn validate_email(email:&str)->Result<(),RuleError>{
39
40    let re = Regex::new(
41        r"([\w\d_\-+#$%&*\/^]+)@([\w\d_-]+)[\.]{1,1}([\w\d]+)"
42    ).unwrap();
43
44    if !re.is_match(email){
45        return Err(RuleError::Data(DataError::InvalidEmail));
46    }
47
48    Ok(())
49
50}
51
52#[derive(Debug)]
53pub enum Error{
54    Key(String,RuleError),Format(FormatError),Data(DataError),RuleError(RuleError)
55}
56
57#[derive(Debug)]
58pub enum RuleError{
59    Format(FormatError),Data(DataError),None,Sub(Box<Error>)
60}
61
62impl From<RuleError> for Error {
63    fn from(v: RuleError) -> Error{
64        Error::RuleError(v)
65    }
66}
67
68#[doc = include_str!("../example.md")]
69///schema type can be
70///dynamic validation allows undefined fields
71///static validation only allows defined fields
72pub fn run(
73    format:&JsonValue,
74    data:&JsonValue,
75    schema_type:&str,
76    max_size:u32,
77)->Result<(),Error>{
78    let mut definitions = None;
79    if format["$_DEFINE_$"].is_object(){
80        definitions = Some(&format["$_DEFINE_$"]);
81    }
82    run_with_definitions(
83        format,data,schema_type,max_size,&definitions
84    )
85}
86
87#[doc = include_str!("../example.md")]
88///schema type can be
89///dynamic validation allows undefined fields
90///static validation only allows defined fields
91pub fn run_with_definitions(
92    format:&JsonValue,
93    data:&JsonValue,
94    schema_type:&str,
95    max_size:u32,
96    definitions:&Option<&JsonValue>
97)->Result<(),Error>{
98
99    if !format.is_object(){
100        return Err(RuleError::Format(FormatError::IsNotObject).into());
101    }
102    if !data.is_object(){
103        return Err(RuleError::Data(DataError::IsNotObject).into());
104    }
105    let is_dynamic;
106    if schema_type == "dynamic"{
107        if data.len() > max_size as usize{
108            return Err(RuleError::Data(DataError::DataMaxReached).into());
109        }
110        is_dynamic = true;
111    } else {
112        is_dynamic = false;
113        // if data.len() != format.len(){
114        //     return Err(RuleError::data(DataError::UnMatchedSize).into());
115        // }
116    }
117
118    // let mut define = HashMap::new();
119    // let mut define = None;
120    // if format["$_DEFINE_$"].is_object(){
121    //     define = Some(&format["_DEFINE_"]);
122    // }
123
124    for (key,_rules) in format.entries(){
125
126        let define_key;
127        if key == "$_DEFINE_$"{
128            define_key = true;
129        } else {
130            define_key = false;
131        }
132
133        let rules;
134        if _rules.is_object(){
135            rules = _rules;
136        } 
137        else if _rules.is_string(){
138            // println!("string_rule : {:?}",_rules);
139            let rule = _rules.as_str().unwrap();
140            if definitions.is_some(){
141                let vv = definitions.as_ref().unwrap();
142                if vv[rule].is_object(){
143                    rules = &vv[rule];
144                    // println!("string_rule : {:?} FOUND",_rules);
145                    // println!("{:?}",rules);
146                } else {
147                    return Err(RuleError::Format(FormatError::StringRuleNotDefined(rule.to_string())).into());
148                }
149            } else {
150                return Err(RuleError::Format(FormatError::StringRulesMissing(rule.to_string())).into());
151            }
152        }
153        else {
154            return Err(RuleError::Format(FormatError::InvalidSchema).into()); 
155        }
156
157        if !define_key{
158
159            
160            if !data.has_key(key){
161                if rules.has_key("elective"){
162                    if rules["elective"].is_boolean(){
163                        let elective = rules["elective"].as_bool().unwrap();
164                        if !elective{
165                            return Err(RuleError::Data(DataError::NotFound(key.to_string())).into());
166                        }
167                    } else {
168                        return Err(RuleError::Data(DataError::NotFound(key.to_string())).into());
169                    }
170                } else {
171                    return Err(RuleError::Data(DataError::NotFound(key.to_string())).into());
172                }
173            }
174    
175            if data.has_key(key){
176                let value = &data[key];
177                match check_field(
178                    key, value, rules, &is_dynamic, &data,&definitions
179                ){
180                    Ok(_)=>{},
181                    Err(e)=>{
182                        return Err(Error::Key(key.to_string(), e));
183                    }
184                }
185            }
186
187            //ElseAnyIsNotString ElseAnyKeyMissing
188
189            if 
190                !data.has_key(key) &&
191                rules["else"].is_array()
192            {
193                for else_key in rules["else"].members(){
194                    if !else_key.is_string(){
195                        return Err(RuleError::Format(FormatError::ElseIsNotString).into()); 
196                    }
197                    let else_key = else_key.as_str().unwrap();
198                    if !data.has_key(else_key){
199                        return Err(RuleError::Data(DataError::ElseKeyMissing(
200                            else_key.to_string()
201                        )).into()); 
202                    }
203                }
204            }
205
206            if 
207                !data.has_key(key) &&
208                rules["else_any"].is_array()
209            {
210                let mut found = false;
211                for else_any_key in rules["else_any"].members(){
212                    if !else_any_key.is_string(){
213                        return Err(RuleError::Format(FormatError::ElseAnyIsNotString).into()); 
214                    }
215                    let else_any_key = else_any_key.as_str().unwrap();
216                    if data.has_key(else_any_key){
217                        found = true;
218                    }
219                }
220                if !found{
221                    return Err(RuleError::Data(DataError::ElseAnyKeyMissing(
222                        key.to_string()
223                    )).into()); 
224                }
225            }
226
227            if 
228                data.has_key(key) &&
229                rules["exclude"].is_array()
230            {
231                for exclude_key in rules["exclude"].members(){
232                    if !exclude_key.is_string(){
233                        return Err(RuleError::Format(FormatError::ExcludeIsNotString).into()); 
234                    }
235                    let exclude_key = exclude_key.as_str().unwrap();
236                    if data.has_key(exclude_key){
237                        return Err(RuleError::Data(DataError::PresentExcludeKey(
238                            (key.to_string(),exclude_key.to_string())
239                        )).into()); 
240                    }
241                }
242            }
243
244            if 
245                data.has_key(key) &&
246                rules["include"].is_array()
247            {
248                for include_key in rules["include"].members(){
249                    if !include_key.is_string(){
250                        return Err(RuleError::Format(FormatError::IncludeIsNotString).into()); 
251                    }
252                    let include_key = include_key.as_str().unwrap();
253                    if !data.has_key(include_key){
254                        return Err(RuleError::Data(DataError::MissingIncludeKey(
255                            (key.to_string(),include_key.to_string())
256                        )).into()); 
257                    }
258                }
259            }
260
261            if 
262                data.has_key(key) &&
263                rules["include_any"].is_array()
264            {
265                let mut found = false;
266                for include_key in rules["include_any"].members(){
267                    if !include_key.is_string(){
268                        return Err(RuleError::Format(FormatError::IncludeIsNotString).into()); 
269                    }
270                    let include_key = include_key.as_str().unwrap();
271                    if data.has_key(include_key){
272                        found = true;
273                    }
274                }
275                if !found{
276                    return Err(RuleError::Data(DataError::MissingAllIncludeKey(key.to_string())).into()); 
277                }
278            }
279
280        }
281
282        
283
284    }
285
286    if !is_dynamic{
287        for (key,_) in data.entries(){
288            if !format.has_key(key){
289                return Err(RuleError::Data(DataError::UnmatchedKey(key.to_string())).into());
290            }
291        }
292    }
293
294    return Ok(());
295
296}
297
298fn check_field(
299    _key:&str,value:&JsonValue,
300    rules:&JsonValue,_is_dynamic:&bool,
301    all_values:&JsonValue,
302    definitions:&Option<&JsonValue>
303)->Result<(),RuleError>{
304
305    if !rules.is_object(){
306        return Err(RuleError::Format(FormatError::InvalidFormat).into());
307    }
308
309    match check_rule_data_type(&rules["type"],&value,rules){
310        Ok(_)=>{},
311        Err(e)=>{
312            return Err(e);
313        }
314    }
315
316    let email_type = "string";
317    let mut data_type = rules["type"].as_str().unwrap();
318
319    if data_type == "email"{
320        let email = value.as_str().unwrap();
321        match validate_email(email){
322            Ok(_)=>{},
323            Err(e)=>{
324                return Err(e);
325            }
326        }
327        data_type = &email_type;
328    }
329
330    if data_type == "any"{
331        if value.is_null(){
332            return Err(RuleError::Data(DataError::NotFound(_key.to_string())));
333        }
334    }
335
336    if 
337        data_type == "string" && 
338        rules.has_key("options") &&
339        rules.has_key("option_required_fields")
340    {
341        match check_option_required_fields(&value,&rules["option_required_fields"],&all_values){
342            Ok(_)=>{},
343            Err(e)=>{
344                return Err(e);
345            }
346        }
347    }
348
349    if rules.has_key("min"){
350        match check_min(&data_type,&value,&rules["min"]){
351            Ok(_)=>{},
352            Err(e)=>{
353                return Err(e);
354            }
355        }
356    }
357    
358    if rules.has_key("max"){
359        match check_max(&data_type,&value,&rules["max"]){
360            Ok(_)=>{},
361            Err(e)=>{
362                return Err(e);
363            }
364        }
365    }
366
367    if rules.has_key("options"){
368        match check_options(&data_type,&value,&rules["options"]){
369            Ok(_)=>{},
370            Err(e)=>{
371                return Err(e);
372            }
373        }
374    }
375
376    if rules.has_key("validate"){
377        match check_validate(
378            &data_type,
379            &value,
380            &rules["validate"],
381            definitions
382        ){
383            Ok(_)=>{},
384            Err(e)=>{
385                return Err(e);
386            }
387        }
388    }
389
390    if rules.has_key("required_fields"){
391        match check_required_fields(&rules["required_fields"],&all_values){
392            Ok(_)=>{},
393            Err(e)=>{
394                return Err(e);
395            }
396        }
397    }
398
399    return Ok(());
400
401}
402
403fn check_required_fields(rule:&JsonValue,all_values:&JsonValue)->Result<(),RuleError>{
404
405    if !rule.is_array(){
406        return Err(RuleError::Format(FormatError::IsNotObject));
407    }
408    if !all_values.is_object(){
409        return Err(RuleError::Format(FormatError::IsNotObject));
410    }
411
412    for item in rule.members(){
413        if !item.is_string(){
414            return Err(RuleError::Format(FormatError::IsNotStringArray));
415        }
416        let value = item.as_str().unwrap();
417        if !all_values.has_key(value){
418            return Err(RuleError::Data(DataError::MissingRequiredField(value.to_string()))); 
419        }
420    }
421
422    return Ok(());
423
424}
425
426fn check_option_required_fields(value:&JsonValue,rule:&JsonValue,all_values:&JsonValue)->Result<(),RuleError>{
427
428    if !rule.is_object(){
429        return Err(RuleError::Format(FormatError::IsNotObject));
430    }
431    if !all_values.is_object(){
432        return Err(RuleError::Format(FormatError::IsNotObject));
433    }
434    if !value.is_string(){
435        return Err(RuleError::Data(DataError::InvalidDataType));
436    }
437    let value = value.as_str().unwrap();
438    if !rule.has_key(value){
439        return Ok(());
440    }
441
442    if rule[value].is_array(){
443        for item in rule[value].members(){
444            if !item.is_string(){
445                return Err(RuleError::Format(FormatError::IsNotStringArray));
446            }
447            let value = item.as_str().unwrap();
448            if !all_values.has_key(value){
449                return Err(RuleError::Data(DataError::MissingRequiredField(value.to_string()))); 
450            }
451        }
452    } else if rule[value].is_string(){
453        let field_name = rule[value].as_str().unwrap();
454        if !all_values.has_key(field_name){
455            return Err(RuleError::Data(DataError::MissingRequiredField(field_name.to_string()))); 
456        }
457    } else {
458        return Err(RuleError::Data(DataError::InvalidDataType));
459    }
460
461    return Ok(());
462
463}
464
465fn check_options(_data_type:&str,value:&JsonValue,rule:&JsonValue)->Result<(),RuleError>{
466
467    // println!("check_options => {:?} => {:?} => {:?}",_data_type,value,rule);
468
469    // value.print();
470    // rule.print();
471
472    if
473        !value.is_string() && 
474        !value.is_number() &&
475        !value.is_array()
476    {
477        return Err(RuleError::Format(FormatError::OptionsNotAllowed));
478    }
479
480    if !rule.is_array(){
481        return Err(RuleError::Format(FormatError::InvalidOptions));
482    }
483
484    // let mut set = HashSet::new();
485    // for item in rule.members(){
486    //     if item.is_string(){
487    //         set.insert(item.as_str().unwrap());
488    //     }
489    // }
490
491    if value.is_array(){
492        for item in value.members(){
493            if item.is_string(){
494                let s = item.as_str().unwrap();
495                if rule.contains(s){
496                    // return Err(RuleError::Data(DataError::OutOfOptions));
497                    return Ok(());
498                }
499            } 
500            else if item.as_i64().is_some(){
501                let v: String = item.as_i64().unwrap().to_string();
502                if rule.contains(v.as_str()){
503                    // return Err(RuleError::Data(DataError::OutOfOptions));
504                    return Ok(());
505                }
506            }
507            else if item.as_u64().is_some(){
508                let v: String = item.as_u64().unwrap().to_string();
509                if rule.contains(v.as_str()){
510                    // return Err(RuleError::Data(DataError::OutOfOptions));
511                    return Ok(());
512                }
513            }
514        }
515        // return Err(RuleError::Data(DataError::OutOfOptions));
516    }
517
518    if value.is_string(){
519        let v = value.as_str().unwrap();
520        if rule.contains(v){
521            // return Err(RuleError::Data(DataError::OutOfOptions));
522            return Ok(());
523        }
524        // if !set.contains(v){
525        //     return Err(RuleError::Data(DataError::OutOfOptions));
526        // }
527        // return Err(RuleError::Data(DataError::OutOfOptions));
528    }
529
530    if value.is_number(){
531        if value.as_i64().is_some(){
532            let v: String = value.as_i64().unwrap().to_string();
533            if rule.contains(v.as_str()){
534                // return Err(RuleError::Data(DataError::OutOfOptions));
535                return Ok(());
536            }
537        }
538        else if value.as_u64().is_some(){
539            let v: String = value.as_u64().unwrap().to_string();
540            if rule.contains(v.as_str()){
541                // return Err(RuleError::Data(DataError::OutOfOptions));
542                return Ok(());
543            }
544        } 
545        else if value.as_f64().is_some(){
546            let v: String = value.as_f64().unwrap().to_string();
547            if rule.contains(v.as_str()){
548                // return Err(RuleError::Data(DataError::OutOfOptions));
549                return Ok(());
550            }
551        }
552        // let v = value.as_i64().unwrap();
553        // let n = &v.to_string();
554        // let p = n.as_str();
555        // if !set.contains(p){
556        //     return Err(RuleError::Data(DataError::OutOfOptions));
557        // }
558    }
559
560    // return Ok(());
561
562    // return Err(RuleError::None);
563
564    return Err(RuleError::Data(DataError::OutOfOptions));
565
566}
567
568fn check_validate(
569    data_type:&str,
570    value:&JsonValue,
571    rule:&JsonValue,
572    definitions:&Option<&JsonValue>
573)->Result<(),RuleError>{
574
575    let schema_type;
576    if rule["dynamic"].is_boolean(){
577        let v = rule["dynamic"].as_bool().unwrap();
578        if v{
579            schema_type = "dynamic";
580        } else {
581            schema_type = "static";
582        }
583    } else {
584        schema_type = "static";
585    }
586
587    let max_size;
588    if rule["maxSize"].is_string(){
589        max_size = rule["maxSize"].as_u32().unwrap();
590    } else {
591        max_size = 0;
592    }
593
594    let valid_validate_keys = vec![
595        "schema","maxSize","dynamic","static",
596        "children_schema","valid_keys","children_type",
597        "array_validate","array_child_type",
598        "validate_nested_object","unique_keys",
599        "min_string","max_string","min_key_size","max_key_size",
600        "unique","max_size","option_required_fields",
601        "include","exclude","include_any","else","else_any",
602        "option_required_fields","options","required_fields"
603    ];
604
605    for (key,_) in rule.entries(){
606        if !valid_validate_keys.contains(&key){
607            return Err(RuleError::Format(FormatError::InvalidValidateRuleAction(key.to_string())));
608        }
609    }
610
611    let valid_child_type = ["bool","string","number","array","object"];
612
613    if data_type == "array"{
614
615        if !value.is_array(){
616            return Err(RuleError::Data(DataError::UnSupportedData));
617        }
618
619        if !rule["children_type"].is_string(){
620            return Err(RuleError::Format(FormatError::ChildrenTypeMissing));
621        }
622
623        let children_type = rule["children_type"].as_str().unwrap();
624        let child_data_type = children_type;
625        if !valid_child_type.contains(&child_data_type){
626            return Err(RuleError::Format(FormatError::InvalidChildrenType));
627        }
628
629        for item in value.members(){
630            let item_data_type = get_json_value_data_type(item)?;
631            if item_data_type != child_data_type{
632                return Err(RuleError::Data(DataError::InvalidDataType));
633            }
634        }
635
636        if child_data_type == "object"{
637            if rule["children_schema"].is_object(){
638                let schema = &rule["children_schema"];
639                for item in value.members(){
640                    match run_with_definitions(
641                        schema,item,schema_type,max_size,definitions
642                    ){
643                        Ok(_)=>{},
644                        Err(e)=>{
645                            return Err(RuleError::Sub(Box::new(e)));
646                        }
647                    }
648                }
649            } 
650            else if rule["children_schema"].is_string(){
651                let schema;
652                let name = rule["children_schema"].as_str().unwrap();
653                // println!("children_schema : {:?}",definitions);
654                if definitions.is_some(){
655                    let define = definitions.as_ref().unwrap();
656                    if define[name].is_object(){
657                        schema = &define[name];
658                    } else {
659                        return Err(RuleError::Format(FormatError::StringRuleNotDefined(name.to_string())));
660                    }
661                } else {
662                    return Err(RuleError::Format(FormatError::StringRulesMissing(name.to_string())));
663                }
664                for item in value.members(){
665                    match run_with_definitions(
666                        schema,item,schema_type,max_size,definitions
667                    ){
668                        Ok(_)=>{},
669                        Err(e)=>{
670                            return Err(RuleError::Sub(Box::new(e)));
671                        }
672                    }
673                }
674            }
675            else if rule.has_key("children_schema"){
676                return Err(RuleError::Format(FormatError::InvalidChildrenSchema));
677            }
678        }
679
680        if child_data_type == "object"{
681            if rule["schema"].is_object(){
682                let schema = &rule["schema"];
683                for item in value.members(){
684                    match run_with_definitions(
685                        schema,item,schema_type,max_size,definitions
686                    ){
687                        Ok(_)=>{},
688                        Err(e)=>{
689                            return Err(RuleError::Sub(Box::new(e)));
690                        }
691                    }
692                }
693            } 
694            else if rule["schema"].is_string(){
695                let schema;
696                let name = rule["schema"].as_str().unwrap();
697                if definitions.is_some(){
698                    let define = definitions.as_ref().unwrap();
699                    if define[name].is_object(){
700                        schema = &define[name];
701                    } else {
702                        return Err(RuleError::Format(FormatError::StringRuleNotDefined(name.to_string())));
703                    }
704                } else {
705                    return Err(RuleError::Format(FormatError::StringRulesMissing(name.to_string())));
706                }
707                for item in value.members(){
708                    match run_with_definitions(
709                        schema,item,schema_type,max_size,definitions
710                    ){
711                        Ok(_)=>{},
712                        Err(e)=>{
713                            return Err(RuleError::Sub(Box::new(e)));
714                        }
715                    }
716                }
717            }
718            else if rule.has_key("schema"){
719                return Err(RuleError::Format(FormatError::InvalidSchema));
720            }
721        }
722
723        if children_type == "object" && rule["unique_keys"].is_array(){
724            for item in rule["unique_keys"].members(){
725                if !item.is_string(){
726                    return Err(RuleError::Format(
727                        FormatError::InvalidArrayUniqueKeyType
728                    ));
729                }
730                let u_key = item.as_str().unwrap().to_string();
731                let mut map = HashSet::new();
732                for item in value.members(){
733                    if item.has_key(&u_key){
734                        if !item[&u_key].is_string(){
735                            return Err(RuleError::Data(
736                                DataError::ArrayUniqueKeyNotStringType(u_key)
737                            ));
738                        }
739                        let u_key_val = item[&u_key].as_str().unwrap();
740                        // println!("u_key_val : {u_key_val}");
741                        if map.contains(u_key_val){
742                            return Err(RuleError::Data(
743                                DataError::ArrayUniqueKeyDuplicate(
744                                    u_key,
745                                    u_key_val.to_string()
746                                )
747                            ));
748                        } else {
749                            map.insert(u_key_val);
750                        }
751                    }
752                } 
753            }
754        }
755
756        if 
757            children_type == "object" && 
758            rule["validate_nested_object"].is_object()
759        {
760            let schema = &rule["validate_nested_object"];
761            for ao_val in value.members(){
762                validate_nested_object(
763                    schema,ao_val,&valid_child_type,definitions
764                )?;
765            }
766        }
767
768        if 
769            children_type == "string" && 
770            rule["unique"].is_boolean() &&
771            rule["unique"].as_bool().unwrap()
772        {
773            let mut map = HashSet::new();
774            for item in value.members(){
775                if !item.is_string(){
776                    return Err(RuleError::Data(
777                        DataError::ArrayUniqueValueNotString
778                    ));
779                }
780                let s = item.as_str().unwrap().to_string();
781                if map.contains(&s){
782                    return Err(RuleError::Data(
783                        DataError::DuplicateArrayString(s)
784                    ));
785                } else {
786                    map.insert(s);
787                }
788            }
789        }
790
791        if 
792            children_type == "string" && 
793            rule["max_string"].is_number() || 
794            rule["min_string"].is_number() 
795        {
796            let max = rule["max_string"].as_u64();
797            let min = rule["min_string"].as_u64();
798            if 
799                max.is_some() ||
800                min.is_some()
801            {
802                for item in value.members(){
803                    if !item.is_string(){
804                        return Err(RuleError::Data(
805                            DataError::ArrayUniqueValueNotString
806                        ));
807                    }
808                    let len = item.as_str().unwrap().len() as u64;
809                    if min.is_some(){
810                        let min = min.as_ref().unwrap();
811                        if len < *min{
812                            return Err(RuleError::Data(
813                                DataError::MinString
814                            ));
815                        }
816                    }
817                    if max.is_some(){
818                        let max = max.as_ref().unwrap();
819                        if len > *max{
820                            return Err(RuleError::Data(
821                                DataError::MaxString
822                            ));
823                        }
824                    }
825                }
826            } else {
827                return Err(RuleError::Format(
828                    FormatError::InvalidMinMaxValues
829                ));
830            }
831        }
832
833        return Ok(());
834
835    }
836
837    if data_type == "object"{
838
839        // println!("");
840
841        if !value.is_object(){
842            return Err(RuleError::Format(FormatError::InvalidSchemaOnData));
843        }
844
845        if rule["min_key_size"].as_usize().is_some(){
846            let min_key_size = rule["min_key_size"].as_usize().unwrap();
847            for (key,_) in value.entries(){
848                if key.len() < min_key_size{
849                    return Err(RuleError::Data(DataError::MinKeySize));
850                }
851            }
852        }
853        if rule["max_key_size"].as_usize().is_some(){
854            let max_key_size = rule["max_key_size"].as_usize().unwrap();
855            for (key,_) in value.entries(){
856                if key.len() > max_key_size{
857                    return Err(RuleError::Data(DataError::MaxKeySize));
858                }
859            }
860        }
861
862        //----------------------------
863        //check schema if defined
864        //----------------------------
865    
866        if rule["schema"].is_object(){
867            let schema = &rule["schema"];
868            match run_with_definitions(
869                schema,value,schema_type,max_size,definitions
870            ){
871                Ok(_)=>{
872                    return Ok(());
873                },
874                Err(e)=>{
875                    return Err(RuleError::Sub(Box::new(e)));
876                }
877            }
878        }
879
880        else if rule["schema"].is_string(){
881            let schema;
882            let name = rule["schema"].as_str().unwrap();
883            if definitions.is_some(){
884                let define = definitions.as_ref().unwrap();
885                if define[name].is_object(){
886                    schema = &define[name];
887                } else {
888                    return Err(RuleError::Format(FormatError::StringRuleNotDefined(name.to_string())));
889                }
890            } else {
891                return Err(RuleError::Format(FormatError::StringRulesMissing(name.to_string())));
892            }
893            match run_with_definitions(
894                schema,value,schema_type,max_size,definitions
895            ){
896                Ok(_)=>{
897                    return Ok(());
898                },
899                Err(e)=>{
900                    return Err(RuleError::Sub(Box::new(e)));
901                }
902            }
903        }
904
905        else if rule.has_key("schema"){
906            return Err(RuleError::Format(FormatError::InvalidSchema));
907        }
908
909        //----------------------------
910        //check children schema
911        //----------------------------
912
913        if 
914            rule["children_schema"].is_object()
915        {
916            let schema = &rule["children_schema"];
917            for (_,t_val) in value.entries(){
918                match run_with_definitions(
919                    schema,t_val,schema_type,max_size,definitions
920                ){
921                    Ok(_)=>{},
922                    Err(e)=>{
923                        return Err(RuleError::Sub(Box::new(e)));
924                    }
925                }
926            }
927        }
928
929        else if 
930            rule["children_schema"].is_string()
931        {
932            let schema;
933            let name = rule["children_schema"].as_str().unwrap();
934            if definitions.is_some(){
935                let define = definitions.as_ref().unwrap();
936                if define[name].is_object(){
937                    schema = &define[name];
938                } else {
939                    return Err(RuleError::Format(FormatError::StringRuleNotDefined(name.to_string())));
940                }
941            } else {
942                return Err(RuleError::Format(FormatError::StringRulesMissing(name.to_string())));
943            }
944            for (_,t_val) in value.entries(){
945                match run_with_definitions(
946                    schema,t_val,schema_type,max_size,definitions
947                ){
948                    Ok(_)=>{},
949                    Err(e)=>{
950                        return Err(RuleError::Sub(Box::new(e)));
951                    }
952                }
953            }
954        }
955
956        else if rule.has_key("children_schema"){
957            return Err(RuleError::Format(FormatError::InvalidChildrenSchema));
958        }
959
960        //----------------------------
961        //check keys in options
962        //----------------------------
963
964        if 
965            rule["valid_keys"].is_array()
966        {
967            for valid_key in rule["valid_keys"].members(){
968                if !valid_key.is_string(){
969                    return Err(RuleError::Format(FormatError::ValidKeyNotString));
970                }
971            }
972            let valid_keys = &rule["valid_keys"];
973            for (key,_) in value.entries(){
974                if !valid_keys.contains(key){
975                    return Err(RuleError::Data(DataError::UnmatchedKey(key.to_string())));
976                }
977            }
978        }
979
980        //----------------------------
981        //check children_type
982        //----------------------------
983
984        if 
985            rule["children_type"].is_string()
986        {
987            let children_type = rule["children_type"].as_str().unwrap();
988            if !valid_child_type.contains(&children_type){
989                return Err(RuleError::Format(FormatError::InvalidChildrenType));
990            }
991            for (_,value) in value.entries(){
992                let item_data_type = get_json_value_data_type(value)?;
993                if item_data_type != children_type{
994                    return Err(RuleError::Data(DataError::InvalidChildDataType(
995                        children_type.to_string(),
996                        item_data_type.to_string(),
997                    )));
998                }
999            }
1000        }
1001
1002        //----------------------------
1003        //check array_validate
1004        //----------------------------
1005
1006        if 
1007            rule["children_type"] == "array" && 
1008            rule["array_validate"].is_object()
1009        {
1010            let array_validate = &rule["array_validate"];
1011            if array_validate["array_child_type"].is_string(){
1012                let array_child_type = array_validate["array_child_type"].as_str().unwrap();
1013                if !valid_child_type.contains(&array_child_type){
1014                    return Err(RuleError::Format(FormatError::InvalidChildrenType));
1015                }
1016                for (_,t_val) in value.entries(){
1017                    for array_value in t_val.members(){
1018                        let array_value_type = get_json_value_data_type(array_value)?;
1019                        if array_value_type != array_child_type{
1020                            return Err(RuleError::Data(DataError::InvalidDataType));
1021                        }
1022                        if 
1023                            array_child_type == "object" &&
1024                            array_validate["validate"].is_object()
1025                        {
1026                            validate_array_children_schema(
1027                                &array_validate["validate"],
1028                                array_value,
1029                                definitions
1030                            )?;
1031                        }
1032                    }
1033                }
1034            }
1035        }
1036
1037        //----------------------------
1038        //check string child len
1039        //----------------------------
1040
1041        if 
1042            rule["children_type"] == "string" && 
1043            (
1044                rule["min_string"].is_number() ||
1045                rule["max_string"].is_number()
1046            )
1047        {
1048            let min;
1049            if rule["min_string"].as_usize().is_some(){
1050                min = Some(rule["min_string"].as_usize().unwrap());
1051            } else {
1052                min = None;
1053            }
1054            let max;
1055            if rule["max_string"].as_usize().is_some(){
1056                max = Some(rule["max_string"].as_usize().unwrap());
1057            } else {
1058                max = None;
1059            }
1060            for (_,string_val) in value.entries(){
1061                if !string_val.is_string(){
1062                    return Err(RuleError::Data(DataError::InvalidDataType));
1063                }
1064                let string_len = string_val.as_str().unwrap().len();
1065                if min.is_some(){
1066                    let min = min.as_ref().unwrap();
1067                    if string_len < *min{
1068                        return Err(RuleError::Data(DataError::MinString));
1069                    }
1070                }
1071                if max.is_some(){
1072                    let max = max.as_ref().unwrap();
1073                    if string_len > *max{
1074                        return Err(RuleError::Data(DataError::MaxString));
1075                    }
1076                }
1077            }
1078        }
1079
1080        //----------------------------
1081        //check validate_nested_object
1082        //----------------------------
1083
1084        if 
1085            rule["validate_nested_object"].is_object()
1086        {
1087            let schema = &rule["validate_nested_object"];
1088            validate_nested_object(
1089                schema,value,&valid_child_type,definitions
1090            )?;
1091        }
1092        
1093        return Ok(());
1094
1095    }
1096
1097    // Err()
1098
1099    Ok(())
1100
1101}
1102
1103fn validate_nested_object(
1104    rule:&JsonValue,
1105    value:&JsonValue,
1106    valid_child_type:&[&str;5],
1107    definitions:&Option<&JsonValue>
1108)->Result<(),RuleError>{
1109
1110    if !value.is_object(){
1111        return Err(RuleError::Data(DataError::IsNotObject));  
1112    }
1113
1114    if rule["max_key_size"].is_number(){
1115        let max = rule["max_key_size"].as_u64();
1116        if max.is_none(){
1117            return Err(RuleError::Format(FormatError::InvalidMaxKeySize));  
1118        }
1119        let max = max.unwrap();
1120        for (key,_) in value.entries(){
1121            let len = key.len() as u64;
1122            if len > max{
1123                return Err(RuleError::Data(DataError::MaxKeySize));  
1124            }
1125        }
1126    }
1127
1128    if rule["min_key_size"].is_number(){
1129        let min = rule["min_key_size"].as_u64();
1130        if min.is_none(){
1131            return Err(RuleError::Format(FormatError::InvalidMinKeySize));  
1132        }
1133        let min = min.unwrap();
1134        for (key,_) in value.entries(){
1135            let len = key.len() as u64;
1136            if len < min{
1137                return Err(RuleError::Data(DataError::MinKeySize));  
1138            }
1139        }
1140    }
1141
1142    if rule["validate_nested_object"].is_object(){
1143        // println!("validate_nested_object shallow");
1144        let schema = &rule["validate_nested_object"];
1145        for (_,o_val) in value.entries(){
1146            validate_nested_object(
1147                schema,o_val,&valid_child_type,definitions
1148            )?;
1149        }
1150        return Ok(());
1151    }
1152
1153    // if !
1154
1155    // println!("validate_nested_object deep");
1156    // println!("{:?}",rule["schema"]);
1157    // println!("{:?}",value);
1158
1159    let schema_type;
1160    if rule["dynamic"].is_boolean(){
1161        let v = rule["dynamic"].as_bool().unwrap();
1162        if v{
1163            schema_type = "dynamic";
1164        } else {
1165            schema_type = "static";
1166        }
1167    } else {
1168        schema_type = "static";
1169    }
1170
1171    let max_size;
1172    if rule["maxSize"].as_u32().is_some(){
1173        max_size = rule["maxSize"].as_u32().unwrap();
1174    } else {
1175        max_size = 0;
1176    }
1177
1178    if rule["schema"].is_object(){
1179        let schema = &rule["schema"];
1180        match run_with_definitions(
1181            schema,value,schema_type,max_size,definitions
1182        ){
1183            Ok(_)=>{},
1184            Err(e)=>{
1185                return Err(RuleError::Sub(Box::new(e)));
1186            }
1187        }
1188    }
1189
1190    else if rule["schema"].is_string(){
1191        let schema;
1192        let name = rule["schema"].as_str().unwrap();
1193        if definitions.is_some(){
1194            let define = definitions.as_ref().unwrap();
1195            if define[name].is_object(){
1196                schema = &define[name];
1197            } else {
1198                return Err(RuleError::Format(FormatError::StringRuleNotDefined(name.to_string())));
1199            }
1200        } else {
1201            return Err(RuleError::Format(FormatError::StringRulesMissing(name.to_string())));
1202        }
1203        match run_with_definitions(
1204            schema,value,schema_type,max_size,definitions
1205        ){
1206            Ok(_)=>{},
1207            Err(e)=>{
1208                return Err(RuleError::Sub(Box::new(e)));
1209            }
1210        }
1211    }
1212
1213    else if rule.has_key("schema"){
1214        return Err(RuleError::Format(FormatError::InvalidSchema));
1215    }
1216
1217    if 
1218        rule["children_type"].is_string()
1219    {
1220        let children_type = rule["children_type"].as_str().unwrap();
1221        if !valid_child_type.contains(&children_type){
1222            return Err(RuleError::Format(FormatError::InvalidChildrenType));
1223        }
1224        for (_,o_val) in value.entries(){
1225            let item_data_type = get_json_value_data_type(o_val)?;
1226            if item_data_type != children_type{
1227                return Err(RuleError::Data(DataError::InvalidChildDataType(
1228                    children_type.to_string(),
1229                    item_data_type.to_string(),
1230                )));
1231            }
1232        }
1233    }
1234
1235    if rule["children_type"] == "object"{
1236
1237        if rule["children_schema"].is_object(){
1238            let schema = &rule["children_schema"];
1239            for (_,t_val) in value.entries(){
1240                match run_with_definitions(
1241                    schema,t_val,schema_type,max_size,definitions
1242                ){
1243                    Ok(_)=>{
1244                        return Ok(());
1245                    },
1246                    Err(e)=>{
1247                        return Err(RuleError::Sub(Box::new(e)));
1248                    }
1249                }
1250            }
1251        }
1252
1253        else if rule["children_schema"].is_string(){
1254            let schema;
1255            let name = rule["children_schema"].as_str().unwrap();
1256            if definitions.is_some(){
1257                let define = definitions.as_ref().unwrap();
1258                if define[name].is_object(){
1259                    schema = &define[name];
1260                } else {
1261                    return Err(RuleError::Format(FormatError::StringRuleNotDefined(name.to_string())));
1262                }
1263            } else {
1264                return Err(RuleError::Format(FormatError::StringRulesMissing(name.to_string())));
1265            }
1266            for (_,t_val) in value.entries(){
1267                match run_with_definitions(
1268                    schema,t_val,schema_type,max_size,definitions
1269                ){
1270                    Ok(_)=>{
1271                        return Ok(());
1272                    },
1273                    Err(e)=>{
1274                        return Err(RuleError::Sub(Box::new(e)));
1275                    }
1276                }
1277            }
1278        }
1279
1280        else if rule.has_key("children_schema"){
1281            return Err(RuleError::Format(FormatError::InvalidChildrenSchema));
1282        }
1283
1284    }
1285
1286    Ok(())
1287
1288}
1289
1290fn validate_array_children_schema(
1291    rule:&JsonValue,
1292    value:&JsonValue,
1293    definitions:&Option<&JsonValue>
1294)->Result<(),RuleError>{
1295
1296    let schema_type;
1297    if rule["dynamic"].is_boolean(){
1298        let v = rule["dynamic"].as_bool().unwrap();
1299        if v{
1300            schema_type = "dynamic";
1301        } else {
1302            schema_type = "static";
1303        }
1304    } else {
1305        schema_type = "static";
1306    }
1307
1308    let max_size;
1309    if rule["maxSize"].is_string(){
1310        max_size = rule["maxSize"].as_u32().unwrap();
1311    } else {
1312        max_size = 0;
1313    }
1314
1315    if rule["schema"].is_object(){
1316        let schema = &rule["schema"];
1317        match run_with_definitions(
1318            schema,value,schema_type,max_size,definitions
1319        ){
1320            Ok(_)=>{},
1321            Err(e)=>{
1322                return Err(RuleError::Sub(Box::new(e)));
1323            }
1324        }
1325    }
1326
1327    else if rule["schema"].is_string(){
1328        let schema;
1329        let name = rule["schema"].as_str().unwrap();
1330        if definitions.is_some(){
1331            let define = definitions.as_ref().unwrap();
1332            if define[name].is_object(){
1333                schema = &define[name];
1334            } else {
1335                return Err(RuleError::Format(FormatError::StringRuleNotDefined(name.to_string())));
1336            }
1337        } else {
1338            return Err(RuleError::Format(FormatError::StringRulesMissing(name.to_string())));
1339        }
1340        match run_with_definitions(
1341            schema,value,schema_type,max_size,definitions
1342        ){
1343            Ok(_)=>{},
1344            Err(e)=>{
1345                return Err(RuleError::Sub(Box::new(e)));
1346            }
1347        }
1348    }
1349
1350    else if rule.has_key("schema"){
1351        return Err(RuleError::Format(FormatError::InvalidSchema));
1352    }
1353    
1354    Ok(())
1355
1356}
1357
1358fn check_max(data_type:&str,value:&JsonValue,rule:&JsonValue)->Result<(),RuleError>{
1359
1360    if data_type == "number"{
1361        let r;
1362        if value.as_u64().is_some() && rule.as_u64().is_some(){
1363            r = value.as_u64().unwrap() > rule.as_u64().unwrap();
1364        } else
1365        if value.as_i64().is_some() && rule.as_i64().is_some(){
1366            r = value.as_i64().unwrap() > rule.as_i64().unwrap();
1367        } else
1368        if value.as_f64().is_some() && rule.as_f64().is_some(){
1369            r = value.as_f64().unwrap() > rule.as_f64().unwrap();
1370        } else {
1371            return Err(RuleError::Data(DataError::InvalidMaxNum));
1372        }
1373        if r{return Err(RuleError::Data(DataError::Max));}
1374        return Ok(());
1375    }
1376
1377    if !rule.as_u64().is_some(){
1378        return Err(RuleError::Data(DataError::InvalidMax));
1379    }
1380
1381    let max = rule.as_u64().unwrap();
1382    if data_type == "string"{
1383        let v = value.as_str().unwrap();
1384        if (v.len() as u64) > max{return Err(RuleError::Data(DataError::Max));}
1385    } else if data_type == "array"{
1386        if (value.len() as u64) > max{return Err(RuleError::Data(DataError::Max));}
1387    } else if data_type == "object"{
1388        if (value.len() as u64) > max{return Err(RuleError::Data(DataError::Max));}
1389    } else {
1390        return Err(RuleError::Data(DataError::InvalidMaxDataType));
1391    }
1392
1393    return Ok(());
1394
1395}
1396
1397fn check_min(data_type:&str,value:&JsonValue,rule:&JsonValue)->Result<(),RuleError>{
1398
1399    if data_type == "number"{
1400        let r;
1401        if value.as_u64().is_some() && rule.as_u64().is_some(){
1402            r = value.as_u64().unwrap() < rule.as_u64().unwrap();
1403        } else
1404        if value.as_i64().is_some() && rule.as_i64().is_some(){
1405            r = value.as_i64().unwrap() < rule.as_i64().unwrap();
1406        } else
1407        if value.as_f64().is_some() && rule.as_f64().is_some(){
1408            r = value.as_f64().unwrap() < rule.as_f64().unwrap();
1409        } else {
1410            return Err(RuleError::Data(DataError::InvalidMinNum));
1411        }
1412        if r{return Err(RuleError::Data(DataError::Max));}
1413        return Ok(());
1414    }
1415
1416    if !rule.as_u64().is_some(){
1417        return Err(RuleError::Data(DataError::InvalidMin));
1418    }
1419
1420    let min = rule.as_u64().unwrap();
1421    if data_type == "string"{
1422        let v = value.as_str().unwrap();
1423        if (v.len() as u64) < min{return Err(RuleError::Data(DataError::Min));}
1424    } else if data_type == "array"{
1425        if (value.len() as u64) < min{return Err(RuleError::Data(DataError::Min));}
1426    } else if data_type == "object"{
1427        if (value.len() as u64) < min{return Err(RuleError::Data(DataError::Min));}
1428    } else {
1429        return Err(RuleError::Data(DataError::InvalidMinDataType));
1430    }
1431
1432    return Ok(());
1433
1434}
1435
1436fn check_rule_data_type(rule:&JsonValue,value:&JsonValue,field:&JsonValue)->Result<(),RuleError>{
1437
1438    if !rule.is_string(){
1439        return Err(RuleError::Format(FormatError::InvalidDataType));
1440    }
1441
1442    let rule_data_type = rule.as_str().unwrap();
1443
1444    if
1445        rule_data_type != "any" &&
1446        rule_data_type != "bool" &&
1447        rule_data_type != "string" &&
1448        rule_data_type != "number" &&
1449        rule_data_type != "object" &&
1450        rule_data_type != "array" &&
1451        rule_data_type != "email"
1452    {
1453        return Err(RuleError::Format(FormatError::InvalidDataType));
1454    }
1455
1456    if rule_data_type == "any"{
1457        return Ok(());
1458    }
1459
1460    let value_data_type;
1461    if value.is_string(){value_data_type = "string";} else
1462    if value.is_number(){value_data_type = "number";} else 
1463    if value.is_object(){value_data_type = "object";} else 
1464    if value.is_array(){value_data_type = "array";} else
1465    if value.is_boolean() {value_data_type = "bool";} else {
1466        return Err(RuleError::Data(DataError::UnSupportedData));
1467    }
1468
1469    if rule_data_type == "email" && value_data_type == "string"{
1470        return Ok(());
1471    }
1472
1473    if rule_data_type != value_data_type{
1474        return Err(RuleError::Data(DataError::InvalidDataType));
1475    }
1476
1477    if rule_data_type == "number" && field["int"].is_string(){
1478        let int_t = field["int"].as_str().unwrap();
1479        if 
1480            int_t == "u8" && value.as_u8().is_none() ||
1481            int_t == "u16" && value.as_u16().is_none() ||
1482            int_t == "u32" && value.as_u32().is_none() ||
1483            int_t == "u64" && value.as_u64().is_none() ||
1484
1485            int_t == "i8" && value.as_i8().is_none() ||
1486            int_t == "i16" && value.as_i16().is_none() ||
1487            int_t == "i32" && value.as_i32().is_none() ||
1488            int_t == "i64" && value.as_i64().is_none() ||
1489
1490            int_t == "f64" && value.as_f64().is_none()
1491        {
1492            return Err(RuleError::Data(DataError::InvalidNum));
1493        }
1494    }
1495
1496    return Ok(());
1497
1498}
1499
1500fn get_json_value_data_type(value:&JsonValue)->Result<&'static str,RuleError>{
1501    let value_data_type;
1502    if value.is_string(){value_data_type = "string";} else
1503    if value.is_number(){value_data_type = "number";} else 
1504    if value.is_object(){value_data_type = "object";} else 
1505    if value.is_array(){value_data_type = "array";} else
1506    if value.is_boolean() {value_data_type = "bool";} else {
1507        return Err(RuleError::Data(DataError::UnSupportedData));
1508    }
1509    Ok(value_data_type)
1510}
json_validate_rs/validater.rs

json_validate_rs/
validater.rs
