+2 -2

crates/jacquard-api/src/app_blebbit/authr/folder.rs

··· 149 149 } 150 150 fn validate( 151 151 &self, 152 152 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 152 152 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 153 153 Ok(()) 154 154 } 155 155 } ··· 189 189 } 190 190 fn validate( 191 191 &self, 192 192 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 192 192 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 193 193 Ok(()) 194 194 } 195 195 }

+1 -1

crates/jacquard-api/src/app_blebbit/authr/folder/record.rs

··· 104 104 } 105 105 fn validate( 106 106 &self, 107 107 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 107 107 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 108 108 Ok(()) 109 109 } 110 110 }

+2 -2

crates/jacquard-api/src/app_blebbit/authr/group.rs

··· 220 220 } 221 221 fn validate( 222 222 &self, 223 223 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 223 223 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 224 224 Ok(()) 225 225 } 226 226 } ··· 266 266 } 267 267 fn validate( 268 268 &self, 269 269 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 269 269 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 270 270 Ok(()) 271 271 } 272 272 }

+1 -1

crates/jacquard-api/src/app_blebbit/authr/group/record.rs

··· 112 112 } 113 113 fn validate( 114 114 &self, 115 115 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 115 115 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 116 116 Ok(()) 117 117 } 118 118 }

+2 -2

crates/jacquard-api/src/app_blebbit/authr/page.rs

··· 164 164 } 165 165 fn validate( 166 166 &self, 167 167 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 167 167 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 168 168 Ok(()) 169 169 } 170 170 } ··· 207 207 } 208 208 fn validate( 209 209 &self, 210 210 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 210 210 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 211 211 Ok(()) 212 212 } 213 213 }

+1 -1

crates/jacquard-api/src/app_blebbit/authr/page/record.rs

··· 108 108 } 109 109 fn validate( 110 110 &self, 111 111 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 111 111 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 112 112 Ok(()) 113 113 } 114 114 }

+122 -76

crates/jacquard-api/src/app_bsky/actor.rs

··· 2397 2397 } 2398 2398 fn validate( 2399 2399 &self, 2400 2400 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2400 2400 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2401 2401 Ok(()) 2402 2402 } 2403 2403 } ··· 2432 2432 } 2433 2433 fn validate( 2434 2434 &self, 2435 2435 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2435 2435 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2436 2436 { 2437 2437 let value = &self.guide; 2438 2438 #[allow(unused_comparisons)] 2439 2439 if <str>::len(value.as_ref()) > 100usize { 2440 2440 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2441 2441 - field: "guide", 2440 2440 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 2441 2441 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 2442 2442 + "guide", 2443 2443 + ), 2442 2444 max: 100usize, 2443 2445 actual: <str>::len(value.as_ref()), 2444 2446 }); ··· 2489 2491 } 2490 2492 fn validate( 2491 2493 &self, 2492 2492 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2494 2494 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2493 2495 if let Some(ref value) = self.nuxs { 2494 2496 #[allow(unused_comparisons)] 2495 2497 if value.len() > 100usize { 2496 2496 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2497 2497 - field: "nuxs", 2498 2498 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 2499 2499 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 2500 2500 + "nuxs", 2501 2501 + ), 2498 2502 max: 100usize, 2499 2503 actual: value.len(), 2500 2504 }); ··· 2503 2507 if let Some(ref value) = self.queued_nudges { 2504 2508 #[allow(unused_comparisons)] 2505 2509 if value.len() > 1000usize { 2506 2506 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2507 2507 - field: "queued_nudges", 2510 2510 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 2511 2511 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 2512 2512 + "queued_nudges", 2513 2513 + ), 2508 2514 max: 1000usize, 2509 2515 actual: value.len(), 2510 2516 }); ··· 2549 2555 } 2550 2556 fn validate( 2551 2557 &self, 2552 2552 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2558 2558 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2553 2559 Ok(()) 2554 2560 } 2555 2561 } ··· 2599 2605 } 2600 2606 fn validate( 2601 2607 &self, 2602 2602 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2608 2608 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2603 2609 Ok(()) 2604 2610 } 2605 2611 } ··· 2634 2640 } 2635 2641 fn validate( 2636 2642 &self, 2637 2637 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2643 2643 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2638 2644 Ok(()) 2639 2645 } 2640 2646 } ··· 2669 2675 } 2670 2676 fn validate( 2671 2677 &self, 2672 2672 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2678 2678 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2673 2679 { 2674 2680 let value = &self.tags; 2675 2681 #[allow(unused_comparisons)] 2676 2682 if value.len() > 100usize { 2677 2677 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2678 2678 - field: "tags", 2683 2683 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 2684 2684 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 2685 2685 + "tags", 2686 2686 + ), 2679 2687 max: 100usize, 2680 2688 actual: value.len(), 2681 2689 }); ··· 2716 2724 } 2717 2725 fn validate( 2718 2726 &self, 2719 2719 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2727 2727 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2720 2728 { 2721 2729 let value = &self.followers; 2722 2730 #[allow(unused_comparisons)] 2723 2731 if value.len() > 5usize { 2724 2724 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2725 2725 - field: "followers", 2732 2732 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 2733 2733 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 2734 2734 + "followers", 2735 2735 + ), 2726 2736 max: 5usize, 2727 2737 actual: value.len(), 2728 2738 }); ··· 2732 2742 let value = &self.followers; 2733 2743 #[allow(unused_comparisons)] 2734 2744 if value.len() < 0usize { 2735 2735 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 2736 2736 - field: "followers", 2745 2745 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 2746 2746 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 2747 2747 + "followers", 2748 2748 + ), 2737 2749 min: 0usize, 2738 2750 actual: value.len(), 2739 2751 }); ··· 2772 2784 } 2773 2785 fn validate( 2774 2786 &self, 2775 2775 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2787 2787 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2776 2788 Ok(()) 2777 2789 } 2778 2790 } ··· 2806 2818 } 2807 2819 fn validate( 2808 2820 &self, 2809 2809 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2821 2821 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2810 2822 Ok(()) 2811 2823 } 2812 2824 } ··· 2859 2871 } 2860 2872 fn validate( 2861 2873 &self, 2862 2862 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2874 2874 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2863 2875 { 2864 2876 let value = &self.value; 2865 2877 #[allow(unused_comparisons)] 2866 2878 if <str>::len(value.as_ref()) > 10000usize { 2867 2867 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2868 2868 - field: "value", 2879 2879 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 2880 2880 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 2881 2881 + "value", 2882 2882 + ), 2869 2883 max: 10000usize, 2870 2884 actual: <str>::len(value.as_ref()), 2871 2885 }); ··· 2880 2894 ) 2881 2895 .count(); 2882 2896 if count > 1000usize { 2883 2883 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 2884 2884 - field: "value", 2897 2897 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 2898 2898 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 2899 2899 + "value", 2900 2900 + ), 2885 2901 max: 1000usize, 2886 2902 actual: count, 2887 2903 }); ··· 2998 3014 } 2999 3015 fn validate( 3000 3016 &self, 3001 3001 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3017 3017 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 3002 3018 Ok(()) 3003 3019 } 3004 3020 } ··· 3044 3060 } 3045 3061 fn validate( 3046 3062 &self, 3047 3047 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3063 3063 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 3048 3064 if let Some(ref value) = self.data { 3049 3065 #[allow(unused_comparisons)] 3050 3066 if <str>::len(value.as_ref()) > 3000usize { 3051 3051 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3052 3052 - field: "data", 3067 3067 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 3068 3068 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 3069 3069 + "data", 3070 3070 + ), 3053 3071 max: 3000usize, 3054 3072 actual: <str>::len(value.as_ref()), 3055 3073 }); ··· 3063 3081 ) 3064 3082 .count(); 3065 3083 if count > 300usize { 3066 3066 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 3067 3067 - field: "data", 3084 3084 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 3085 3085 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 3086 3086 + "data", 3087 3087 + ), 3068 3088 max: 300usize, 3069 3089 actual: count, 3070 3090 }); ··· 3075 3095 let value = &self.id; 3076 3096 #[allow(unused_comparisons)] 3077 3097 if <str>::len(value.as_ref()) > 100usize { 3078 3078 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3079 3079 - field: "id", 3098 3098 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 3099 3099 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 3100 3100 + "id", 3101 3101 + ), 3080 3102 max: 100usize, 3081 3103 actual: <str>::len(value.as_ref()), 3082 3104 }); ··· 3116 3138 } 3117 3139 fn validate( 3118 3140 &self, 3119 3119 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3141 3141 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 3120 3142 Ok(()) 3121 3143 } 3122 3144 } ··· 3184 3206 } 3185 3207 fn validate( 3186 3208 &self, 3187 3187 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3209 3209 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 3188 3210 if let Some(ref value) = self.postgate_embedding_rules { 3189 3211 #[allow(unused_comparisons)] 3190 3212 if value.len() > 5usize { 3191 3191 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3192 3192 - field: "postgate_embedding_rules", 3213 3213 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 3214 3214 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 3215 3215 + "postgate_embedding_rules", 3216 3216 + ), 3193 3217 max: 5usize, 3194 3218 actual: value.len(), 3195 3219 }); ··· 3198 3222 if let Some(ref value) = self.threadgate_allow_rules { 3199 3223 #[allow(unused_comparisons)] 3200 3224 if value.len() > 5usize { 3201 3201 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3202 3202 - field: "threadgate_allow_rules", 3225 3225 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 3226 3226 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 3227 3227 + "threadgate_allow_rules", 3228 3228 + ), 3203 3229 max: 5usize, 3204 3230 actual: value.len(), 3205 3231 }); ··· 3298 3324 } 3299 3325 fn validate( 3300 3326 &self, 3301 3301 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3327 3327 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 3302 3328 Ok(()) 3303 3329 } 3304 3330 } ··· 3333 3359 } 3334 3360 fn validate( 3335 3361 &self, 3336 3336 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3362 3362 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 3337 3363 Ok(()) 3338 3364 } 3339 3365 } ··· 3367 3393 } 3368 3394 fn validate( 3369 3395 &self, 3370 3370 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3396 3396 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 3371 3397 Ok(()) 3372 3398 } 3373 3399 } ··· 3445 3471 } 3446 3472 fn validate( 3447 3473 &self, 3448 3448 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3474 3474 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 3449 3475 if let Some(ref value) = self.description { 3450 3476 #[allow(unused_comparisons)] 3451 3477 if <str>::len(value.as_ref()) > 2560usize { 3452 3452 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3453 3453 - field: "description", 3478 3478 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 3479 3479 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 3480 3480 + "description", 3481 3481 + ), 3454 3482 max: 2560usize, 3455 3483 actual: <str>::len(value.as_ref()), 3456 3484 }); ··· 3464 3492 ) 3465 3493 .count(); 3466 3494 if count > 256usize { 3467 3467 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 3468 3468 - field: "description", 3495 3495 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 3496 3496 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 3497 3497 + "description", 3498 3498 + ), 3469 3499 max: 256usize, 3470 3500 actual: count, 3471 3501 }); ··· 3475 3505 if let Some(ref value) = self.display_name { 3476 3506 #[allow(unused_comparisons)] 3477 3507 if <str>::len(value.as_ref()) > 640usize { 3478 3478 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3479 3479 - field: "display_name", 3508 3508 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 3509 3509 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 3510 3510 + "display_name", 3511 3511 + ), 3480 3512 max: 640usize, 3481 3513 actual: <str>::len(value.as_ref()), 3482 3514 }); ··· 3490 3522 ) 3491 3523 .count(); 3492 3524 if count > 64usize { 3493 3493 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 3494 3494 - field: "display_name", 3525 3525 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 3526 3526 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 3527 3527 + "display_name", 3528 3528 + ), 3495 3529 max: 64usize, 3496 3530 actual: count, 3497 3531 }); ··· 3568 3602 } 3569 3603 fn validate( 3570 3604 &self, 3571 3571 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3605 3605 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 3572 3606 if let Some(ref value) = self.display_name { 3573 3607 #[allow(unused_comparisons)] 3574 3608 if <str>::len(value.as_ref()) > 640usize { 3575 3575 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3576 3576 - field: "display_name", 3609 3609 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 3610 3610 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 3611 3611 + "display_name", 3612 3612 + ), 3577 3613 max: 640usize, 3578 3614 actual: <str>::len(value.as_ref()), 3579 3615 }); ··· 3587 3623 ) 3588 3624 .count(); 3589 3625 if count > 64usize { 3590 3590 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 3591 3591 - field: "display_name", 3626 3626 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 3627 3627 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 3628 3628 + "display_name", 3629 3629 + ), 3592 3630 max: 64usize, 3593 3631 actual: count, 3594 3632 }); ··· 3699 3737 } 3700 3738 fn validate( 3701 3739 &self, 3702 3702 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3740 3740 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 3703 3741 if let Some(ref value) = self.description { 3704 3742 #[allow(unused_comparisons)] 3705 3743 if <str>::len(value.as_ref()) > 2560usize { 3706 3706 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3707 3707 - field: "description", 3744 3744 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 3745 3745 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 3746 3746 + "description", 3747 3747 + ), 3708 3748 max: 2560usize, 3709 3749 actual: <str>::len(value.as_ref()), 3710 3750 }); ··· 3718 3758 ) 3719 3759 .count(); 3720 3760 if count > 256usize { 3721 3721 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 3722 3722 - field: "description", 3761 3761 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 3762 3762 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 3763 3763 + "description", 3764 3764 + ), 3723 3765 max: 256usize, 3724 3766 actual: count, 3725 3767 }); ··· 3729 3771 if let Some(ref value) = self.display_name { 3730 3772 #[allow(unused_comparisons)] 3731 3773 if <str>::len(value.as_ref()) > 640usize { 3732 3732 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3733 3733 - field: "display_name", 3774 3774 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 3775 3775 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 3776 3776 + "display_name", 3777 3777 + ), 3734 3778 max: 640usize, 3735 3779 actual: <str>::len(value.as_ref()), 3736 3780 }); ··· 3744 3788 ) 3745 3789 .count(); 3746 3790 if count > 64usize { 3747 3747 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 3748 3748 - field: "display_name", 3791 3791 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 3792 3792 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 3793 3793 + "display_name", 3794 3794 + ), 3749 3795 max: 64usize, 3750 3796 actual: count, 3751 3797 }); ··· 3793 3839 } 3794 3840 fn validate( 3795 3841 &self, 3796 3796 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3842 3842 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 3797 3843 Ok(()) 3798 3844 } 3799 3845 } ··· 3832 3878 } 3833 3879 fn validate( 3834 3880 &self, 3835 3835 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3881 3881 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 3836 3882 Ok(()) 3837 3883 } 3838 3884 } ··· 3866 3912 } 3867 3913 fn validate( 3868 3914 &self, 3869 3869 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3915 3915 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 3870 3916 Ok(()) 3871 3917 } 3872 3918 } ··· 3917 3963 } 3918 3964 fn validate( 3919 3965 &self, 3920 3920 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3966 3966 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 3921 3967 Ok(()) 3922 3968 } 3923 3969 } ··· 3956 4002 } 3957 4003 fn validate( 3958 4004 &self, 3959 3959 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4005 4005 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 3960 4006 Ok(()) 3961 4007 } 3962 4008 } ··· 3992 4038 } 3993 4039 fn validate( 3994 4040 &self, 3995 3995 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4041 4041 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 3996 4042 Ok(()) 3997 4043 } 3998 4044 } ··· 4036 4082 } 4037 4083 fn validate( 4038 4084 &self, 4039 4039 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4085 4085 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4040 4086 Ok(()) 4041 4087 } 4042 4088 } ··· 4079 4125 } 4080 4126 fn validate( 4081 4127 &self, 4082 4082 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4128 4128 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4083 4129 Ok(()) 4084 4130 } 4085 4131 } ··· 4141 4187 } 4142 4188 fn validate( 4143 4189 &self, 4144 4144 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4190 4190 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4145 4191 Ok(()) 4146 4192 } 4147 4193 }

+25 -13

crates/jacquard-api/src/app_bsky/actor/profile.rs

··· 140 140 } 141 141 fn validate( 142 142 &self, 143 143 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 143 143 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 144 144 if let Some(ref value) = self.description { 145 145 #[allow(unused_comparisons)] 146 146 if <str>::len(value.as_ref()) > 2560usize { 147 147 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 148 148 - field: "description", 147 147 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 148 148 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 149 149 + "description", 150 150 + ), 149 151 max: 2560usize, 150 152 actual: <str>::len(value.as_ref()), 151 153 }); ··· 159 161 ) 160 162 .count(); 161 163 if count > 256usize { 162 162 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 163 163 - field: "description", 164 164 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 165 165 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 166 166 + "description", 167 167 + ), 164 168 max: 256usize, 165 169 actual: count, 166 170 }); ··· 170 174 if let Some(ref value) = self.display_name { 171 175 #[allow(unused_comparisons)] 172 176 if <str>::len(value.as_ref()) > 640usize { 173 173 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 174 174 - field: "display_name", 177 177 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 178 178 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 179 179 + "display_name", 180 180 + ), 175 181 max: 640usize, 176 182 actual: <str>::len(value.as_ref()), 177 183 }); ··· 185 191 ) 186 192 .count(); 187 193 if count > 64usize { 188 188 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 189 189 - field: "display_name", 194 194 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 195 195 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 196 196 + "display_name", 197 197 + ), 190 198 max: 64usize, 191 199 actual: count, 192 200 }); ··· 196 204 if let Some(ref value) = self.pronouns { 197 205 #[allow(unused_comparisons)] 198 206 if <str>::len(value.as_ref()) > 200usize { 199 199 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 200 200 - field: "pronouns", 207 207 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 208 208 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 209 209 + "pronouns", 210 210 + ), 201 211 max: 200usize, 202 212 actual: <str>::len(value.as_ref()), 203 213 }); ··· 211 221 ) 212 222 .count(); 213 223 if count > 20usize { 214 214 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 215 215 - field: "pronouns", 224 224 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 225 225 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 226 226 + "pronouns", 227 227 + ), 216 228 max: 20usize, 217 229 actual: count, 218 230 });

+5 -3

crates/jacquard-api/src/app_bsky/actor/status.rs

··· 126 126 } 127 127 fn validate( 128 128 &self, 129 129 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 129 129 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 130 130 if let Some(ref value) = self.duration_minutes { 131 131 if *value < 1i64 { 132 132 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 133 133 - field: "duration_minutes", 132 132 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 133 133 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 134 134 + "duration_minutes", 135 135 + ), 134 136 min: 1i64, 135 137 actual: *value, 136 138 });

+2 -2

crates/jacquard-api/src/app_bsky/bookmark.rs

··· 141 141 } 142 142 fn validate( 143 143 &self, 144 144 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 144 144 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 145 145 Ok(()) 146 146 } 147 147 } ··· 202 202 } 203 203 fn validate( 204 204 &self, 205 205 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 205 205 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 206 206 Ok(()) 207 207 } 208 208 }

+9 -5

crates/jacquard-api/src/app_bsky/embed.rs

··· 100 100 } 101 101 fn validate( 102 102 &self, 103 103 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 103 103 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 104 104 { 105 105 let value = &self.height; 106 106 if *value < 1i64 { 107 107 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 108 108 - field: "height", 107 107 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 108 108 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 109 109 + "height", 110 110 + ), 109 111 min: 1i64, 110 112 actual: *value, 111 113 }); ··· 114 116 { 115 117 let value = &self.width; 116 118 if *value < 1i64 { 117 117 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 118 118 - field: "width", 119 119 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 120 120 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 121 121 + "width", 122 122 + ), 119 123 min: 1i64, 120 124 actual: *value, 121 125 });

+4 -4

crates/jacquard-api/src/app_bsky/embed/external.rs

··· 274 274 } 275 275 fn validate( 276 276 &self, 277 277 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 277 277 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 278 278 Ok(()) 279 279 } 280 280 } ··· 309 309 } 310 310 fn validate( 311 311 &self, 312 312 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 312 312 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 313 313 Ok(()) 314 314 } 315 315 } ··· 343 343 } 344 344 fn validate( 345 345 &self, 346 346 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 346 346 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 347 347 Ok(()) 348 348 } 349 349 } ··· 387 387 } 388 388 fn validate( 389 389 &self, 390 390 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 390 390 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 391 391 Ok(()) 392 392 } 393 393 }

+12 -8

crates/jacquard-api/src/app_bsky/embed/images.rs

··· 258 258 } 259 259 fn validate( 260 260 &self, 261 261 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 261 261 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 262 262 Ok(()) 263 263 } 264 264 } ··· 292 292 } 293 293 fn validate( 294 294 &self, 295 295 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 295 295 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 296 296 { 297 297 let value = &self.images; 298 298 #[allow(unused_comparisons)] 299 299 if value.len() > 4usize { 300 300 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 301 301 - field: "images", 300 300 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 301 301 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 302 302 + "images", 303 303 + ), 302 304 max: 4usize, 303 305 actual: value.len(), 304 306 }); ··· 337 339 } 338 340 fn validate( 339 341 &self, 340 340 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 342 342 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 341 343 { 342 344 let value = &self.images; 343 345 #[allow(unused_comparisons)] 344 346 if value.len() > 4usize { 345 345 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 346 346 - field: "images", 347 347 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 348 348 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 349 349 + "images", 350 350 + ), 347 351 max: 4usize, 348 352 actual: value.len(), 349 353 }); ··· 394 398 } 395 399 fn validate( 396 400 &self, 397 397 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 401 401 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 398 402 Ok(()) 399 403 } 400 404 }

+6 -6

crates/jacquard-api/src/app_bsky/embed/record.rs

··· 418 418 } 419 419 fn validate( 420 420 &self, 421 421 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 421 421 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 422 422 Ok(()) 423 423 } 424 424 } ··· 483 483 } 484 484 fn validate( 485 485 &self, 486 486 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 486 486 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 487 487 Ok(()) 488 488 } 489 489 } ··· 520 520 } 521 521 fn validate( 522 522 &self, 523 523 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 523 523 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 524 524 Ok(()) 525 525 } 526 526 } ··· 555 555 } 556 556 fn validate( 557 557 &self, 558 558 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 558 558 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 559 559 Ok(()) 560 560 } 561 561 } ··· 590 590 } 591 591 fn validate( 592 592 &self, 593 593 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 593 593 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 594 594 Ok(()) 595 595 } 596 596 } ··· 677 677 } 678 678 fn validate( 679 679 &self, 680 680 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 680 680 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 681 681 Ok(()) 682 682 } 683 683 }

+2 -2

crates/jacquard-api/src/app_bsky/embed/record_with_media.rs

··· 150 150 } 151 151 fn validate( 152 152 &self, 153 153 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 153 153 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 154 154 Ok(()) 155 155 } 156 156 } ··· 207 207 } 208 208 fn validate( 209 209 &self, 210 210 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 210 210 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 211 211 Ok(()) 212 212 } 213 213 }

+23 -13

crates/jacquard-api/src/app_bsky/embed/video.rs

··· 255 255 } 256 256 fn validate( 257 257 &self, 258 258 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 258 258 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 259 259 Ok(()) 260 260 } 261 261 } ··· 303 303 } 304 304 fn validate( 305 305 &self, 306 306 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 306 306 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 307 307 if let Some(ref value) = self.alt { 308 308 #[allow(unused_comparisons)] 309 309 if <str>::len(value.as_ref()) > 10000usize { 310 310 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 311 311 - field: "alt", 310 310 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 311 311 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 312 312 + "alt", 313 313 + ), 312 314 max: 10000usize, 313 315 actual: <str>::len(value.as_ref()), 314 316 }); ··· 322 324 ) 323 325 .count(); 324 326 if count > 1000usize { 325 325 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 326 326 - field: "alt", 327 327 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 328 328 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 329 329 + "alt", 330 330 + ), 327 331 max: 1000usize, 328 332 actual: count, 329 333 }); ··· 333 337 if let Some(ref value) = self.captions { 334 338 #[allow(unused_comparisons)] 335 339 if value.len() > 20usize { 336 336 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 337 337 - field: "captions", 340 340 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 341 341 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 342 342 + "captions", 343 343 + ), 338 344 max: 20usize, 339 345 actual: value.len(), 340 346 }); ··· 387 393 } 388 394 fn validate( 389 395 &self, 390 390 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 396 396 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 391 397 if let Some(ref value) = self.alt { 392 398 #[allow(unused_comparisons)] 393 399 if <str>::len(value.as_ref()) > 10000usize { 394 394 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 395 395 - field: "alt", 400 400 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 401 401 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 402 402 + "alt", 403 403 + ), 396 404 max: 10000usize, 397 405 actual: <str>::len(value.as_ref()), 398 406 }); ··· 406 414 ) 407 415 .count(); 408 416 if count > 1000usize { 409 409 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 410 410 - field: "alt", 417 417 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 418 418 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 419 419 + "alt", 420 420 + ), 411 421 max: 1000usize, 412 422 actual: count, 413 423 });

+50 -34

crates/jacquard-api/src/app_bsky/feed.rs

··· 1444 1444 } 1445 1445 fn validate( 1446 1446 &self, 1447 1447 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1447 1447 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1448 1448 Ok(()) 1449 1449 } 1450 1450 } ··· 1481 1481 } 1482 1482 fn validate( 1483 1483 &self, 1484 1484 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1484 1484 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1485 1485 Ok(()) 1486 1486 } 1487 1487 } ··· 1660 1660 } 1661 1661 fn validate( 1662 1662 &self, 1663 1663 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1663 1663 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1664 1664 if let Some(ref value) = self.feed_context { 1665 1665 #[allow(unused_comparisons)] 1666 1666 if <str>::len(value.as_ref()) > 2000usize { 1667 1667 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1668 1668 - field: "feed_context", 1667 1667 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 1668 1668 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1669 1669 + "feed_context", 1670 1670 + ), 1669 1671 max: 2000usize, 1670 1672 actual: <str>::len(value.as_ref()), 1671 1673 }); ··· 1674 1676 if let Some(ref value) = self.req_id { 1675 1677 #[allow(unused_comparisons)] 1676 1678 if <str>::len(value.as_ref()) > 100usize { 1677 1677 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1678 1678 - field: "req_id", 1679 1679 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 1680 1680 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1681 1681 + "req_id", 1682 1682 + ), 1679 1683 max: 100usize, 1680 1684 actual: <str>::len(value.as_ref()), 1681 1685 }); ··· 1754 1758 } 1755 1759 fn validate( 1756 1760 &self, 1757 1757 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1761 1761 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1758 1762 if let Some(ref value) = self.description { 1759 1763 #[allow(unused_comparisons)] 1760 1764 if <str>::len(value.as_ref()) > 3000usize { 1761 1761 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1762 1762 - field: "description", 1765 1765 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 1766 1766 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1767 1767 + "description", 1768 1768 + ), 1763 1769 max: 3000usize, 1764 1770 actual: <str>::len(value.as_ref()), 1765 1771 }); ··· 1773 1779 ) 1774 1780 .count(); 1775 1781 if count > 300usize { 1776 1776 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1777 1777 - field: "description", 1782 1782 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 1783 1783 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1784 1784 + "description", 1785 1785 + ), 1778 1786 max: 300usize, 1779 1787 actual: count, 1780 1788 }); ··· 1783 1791 } 1784 1792 if let Some(ref value) = self.like_count { 1785 1793 if *value < 0i64 { 1786 1786 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1787 1787 - field: "like_count", 1794 1794 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1795 1795 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1796 1796 + "like_count", 1797 1797 + ), 1788 1798 min: 0i64, 1789 1799 actual: *value, 1790 1800 }); ··· 1824 1834 } 1825 1835 fn validate( 1826 1836 &self, 1827 1827 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1837 1837 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1828 1838 Ok(()) 1829 1839 } 1830 1840 } ··· 1870 1880 } 1871 1881 fn validate( 1872 1882 &self, 1873 1873 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1883 1883 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1874 1884 if let Some(ref value) = self.feed_context { 1875 1885 #[allow(unused_comparisons)] 1876 1886 if <str>::len(value.as_ref()) > 2000usize { 1877 1877 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1878 1878 - field: "feed_context", 1887 1887 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 1888 1888 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1889 1889 + "feed_context", 1890 1890 + ), 1879 1891 max: 2000usize, 1880 1892 actual: <str>::len(value.as_ref()), 1881 1893 }); ··· 1884 1896 if let Some(ref value) = self.req_id { 1885 1897 #[allow(unused_comparisons)] 1886 1898 if <str>::len(value.as_ref()) > 100usize { 1887 1887 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1888 1888 - field: "req_id", 1899 1899 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 1900 1900 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1901 1901 + "req_id", 1902 1902 + ), 1889 1903 max: 100usize, 1890 1904 actual: <str>::len(value.as_ref()), 1891 1905 }); ··· 2033 2047 } 2034 2048 fn validate( 2035 2049 &self, 2036 2036 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2050 2050 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2037 2051 Ok(()) 2038 2052 } 2039 2053 } ··· 2130 2144 } 2131 2145 fn validate( 2132 2146 &self, 2133 2133 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2147 2147 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2134 2148 Ok(()) 2135 2149 } 2136 2150 } ··· 2160 2174 } 2161 2175 fn validate( 2162 2176 &self, 2163 2163 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2177 2177 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2164 2178 Ok(()) 2165 2179 } 2166 2180 } ··· 2203 2217 } 2204 2218 fn validate( 2205 2219 &self, 2206 2206 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2220 2220 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2207 2221 Ok(()) 2208 2222 } 2209 2223 } ··· 2286 2300 } 2287 2301 fn validate( 2288 2302 &self, 2289 2289 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2303 2303 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2290 2304 Ok(()) 2291 2305 } 2292 2306 } ··· 2384 2398 } 2385 2399 fn validate( 2386 2400 &self, 2387 2387 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2401 2401 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2388 2402 if let Some(ref value) = self.feed_context { 2389 2403 #[allow(unused_comparisons)] 2390 2404 if <str>::len(value.as_ref()) > 2000usize { 2391 2391 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2392 2392 - field: "feed_context", 2405 2405 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 2406 2406 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 2407 2407 + "feed_context", 2408 2408 + ), 2393 2409 max: 2000usize, 2394 2410 actual: <str>::len(value.as_ref()), 2395 2411 }); ··· 2424 2440 } 2425 2441 fn validate( 2426 2442 &self, 2427 2427 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2443 2443 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2428 2444 Ok(()) 2429 2445 } 2430 2446 } ··· 2458 2474 } 2459 2475 fn validate( 2460 2476 &self, 2461 2461 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2477 2477 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2462 2478 Ok(()) 2463 2479 } 2464 2480 } ··· 2494 2510 } 2495 2511 fn validate( 2496 2512 &self, 2497 2497 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2513 2513 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2498 2514 Ok(()) 2499 2515 } 2500 2516 } ··· 2582 2598 } 2583 2599 fn validate( 2584 2600 &self, 2585 2585 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2601 2601 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2586 2602 Ok(()) 2587 2603 } 2588 2604 } ··· 2626 2642 } 2627 2643 fn validate( 2628 2644 &self, 2629 2629 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2645 2645 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2630 2646 Ok(()) 2631 2647 } 2632 2648 } ··· 2675 2691 } 2676 2692 fn validate( 2677 2693 &self, 2678 2678 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2694 2694 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2679 2695 Ok(()) 2680 2696 } 2681 2697 }

+2 -2

crates/jacquard-api/src/app_bsky/feed/describe_feed_generator.rs

··· 137 137 } 138 138 fn validate( 139 139 &self, 140 140 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 140 140 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 141 141 Ok(()) 142 142 } 143 143 } ··· 175 175 } 176 176 fn validate( 177 177 &self, 178 178 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 178 178 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 179 179 Ok(()) 180 180 } 181 181 }

+17 -9

crates/jacquard-api/src/app_bsky/feed/generator.rs

··· 125 125 } 126 126 fn validate( 127 127 &self, 128 128 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 128 128 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 129 129 if let Some(ref value) = self.description { 130 130 #[allow(unused_comparisons)] 131 131 if <str>::len(value.as_ref()) > 3000usize { 132 132 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 133 133 - field: "description", 132 132 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 133 133 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 134 134 + "description", 135 135 + ), 134 136 max: 3000usize, 135 137 actual: <str>::len(value.as_ref()), 136 138 }); ··· 144 146 ) 145 147 .count(); 146 148 if count > 300usize { 147 147 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 148 148 - field: "description", 149 149 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 150 150 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 151 151 + "description", 152 152 + ), 149 153 max: 300usize, 150 154 actual: count, 151 155 }); ··· 156 160 let value = &self.display_name; 157 161 #[allow(unused_comparisons)] 158 162 if <str>::len(value.as_ref()) > 240usize { 159 159 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 160 160 - field: "display_name", 163 163 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 164 164 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 165 165 + "display_name", 166 166 + ), 161 167 max: 240usize, 162 168 actual: <str>::len(value.as_ref()), 163 169 }); ··· 172 178 ) 173 179 .count(); 174 180 if count > 24usize { 175 175 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 176 176 - field: "display_name", 181 181 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 182 182 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 183 183 + "display_name", 184 184 + ), 177 185 max: 24usize, 178 186 actual: count, 179 187 });

+1 -1

crates/jacquard-api/src/app_bsky/feed/get_likes.rs

··· 208 208 } 209 209 fn validate( 210 210 &self, 211 211 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 211 211 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 212 212 Ok(()) 213 213 } 214 214 }

+1 -1

crates/jacquard-api/src/app_bsky/feed/like.rs

··· 101 101 } 102 102 fn validate( 103 103 &self, 104 104 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 104 104 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 105 105 Ok(()) 106 106 } 107 107 }

+28 -16

crates/jacquard-api/src/app_bsky/feed/post.rs

··· 388 388 } 389 389 fn validate( 390 390 &self, 391 391 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 391 391 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 392 392 Ok(()) 393 393 } 394 394 } ··· 545 545 } 546 546 fn validate( 547 547 &self, 548 548 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 548 548 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 549 549 if let Some(ref value) = self.langs { 550 550 #[allow(unused_comparisons)] 551 551 if value.len() > 3usize { 552 552 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 553 553 - field: "langs", 552 552 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 553 553 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 554 554 + "langs", 555 555 + ), 554 556 max: 3usize, 555 557 actual: value.len(), 556 558 }); ··· 559 561 if let Some(ref value) = self.tags { 560 562 #[allow(unused_comparisons)] 561 563 if value.len() > 8usize { 562 562 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 563 563 - field: "tags", 564 564 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 565 565 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 566 566 + "tags", 567 567 + ), 564 568 max: 8usize, 565 569 actual: value.len(), 566 570 }); ··· 570 574 let value = &self.text; 571 575 #[allow(unused_comparisons)] 572 576 if <str>::len(value.as_ref()) > 3000usize { 573 573 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 574 574 - field: "text", 577 577 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 578 578 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 579 579 + "text", 580 580 + ), 575 581 max: 3000usize, 576 582 actual: <str>::len(value.as_ref()), 577 583 }); ··· 586 592 ) 587 593 .count(); 588 594 if count > 300usize { 589 589 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 590 590 - field: "text", 595 595 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 596 596 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 597 597 + "text", 598 598 + ), 591 599 max: 300usize, 592 600 actual: count, 593 601 }); ··· 629 637 } 630 638 fn validate( 631 639 &self, 632 632 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 640 640 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 633 641 Ok(()) 634 642 } 635 643 } ··· 664 672 } 665 673 fn validate( 666 674 &self, 667 667 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 675 675 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 668 676 { 669 677 let value = &self.end; 670 678 if *value < 0i64 { 671 671 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 672 672 - field: "end", 679 679 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 680 680 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 681 681 + "end", 682 682 + ), 673 683 min: 0i64, 674 684 actual: *value, 675 685 }); ··· 678 688 { 679 689 let value = &self.start; 680 690 if *value < 0i64 { 681 681 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 682 682 - field: "start", 691 691 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 692 692 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 693 693 + "start", 694 694 + ), 683 695 min: 0i64, 684 696 actual: *value, 685 697 });

+10 -6

crates/jacquard-api/src/app_bsky/feed/postgate.rs

··· 178 178 } 179 179 fn validate( 180 180 &self, 181 181 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 181 181 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 182 182 Ok(()) 183 183 } 184 184 } ··· 286 286 } 287 287 fn validate( 288 288 &self, 289 289 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 289 289 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 290 290 if let Some(ref value) = self.detached_embedding_uris { 291 291 #[allow(unused_comparisons)] 292 292 if value.len() > 50usize { 293 293 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 294 294 - field: "detached_embedding_uris", 293 293 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 294 294 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 295 295 + "detached_embedding_uris", 296 296 + ), 295 297 max: 50usize, 296 298 actual: value.len(), 297 299 }); ··· 300 302 if let Some(ref value) = self.embedding_rules { 301 303 #[allow(unused_comparisons)] 302 304 if value.len() > 5usize { 303 303 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 304 304 - field: "embedding_rules", 305 305 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 306 306 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 307 307 + "embedding_rules", 308 308 + ), 305 309 max: 5usize, 306 310 actual: value.len(), 307 311 });

+1 -1

crates/jacquard-api/src/app_bsky/feed/repost.rs

··· 101 101 } 102 102 fn validate( 103 103 &self, 104 104 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 104 104 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 105 105 Ok(()) 106 106 } 107 107 }

+13 -9

crates/jacquard-api/src/app_bsky/feed/threadgate.rs

··· 249 249 } 250 250 fn validate( 251 251 &self, 252 252 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 252 252 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 253 253 Ok(()) 254 254 } 255 255 } ··· 280 280 } 281 281 fn validate( 282 282 &self, 283 283 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 283 283 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 284 284 Ok(()) 285 285 } 286 286 } ··· 315 315 } 316 316 fn validate( 317 317 &self, 318 318 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 318 318 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 319 319 Ok(()) 320 320 } 321 321 } ··· 446 446 } 447 447 fn validate( 448 448 &self, 449 449 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 449 449 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 450 450 if let Some(ref value) = self.allow { 451 451 #[allow(unused_comparisons)] 452 452 if value.len() > 5usize { 453 453 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 454 454 - field: "allow", 453 453 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 454 454 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 455 455 + "allow", 456 456 + ), 455 457 max: 5usize, 456 458 actual: value.len(), 457 459 }); ··· 460 462 if let Some(ref value) = self.hidden_replies { 461 463 #[allow(unused_comparisons)] 462 464 if value.len() > 300usize { 463 463 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 464 464 - field: "hidden_replies", 465 465 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 466 466 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 467 467 + "hidden_replies", 468 468 + ), 465 469 max: 300usize, 466 470 actual: value.len(), 467 471 }); ··· 497 501 } 498 502 fn validate( 499 503 &self, 500 500 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 504 504 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 501 505 Ok(()) 502 506 } 503 507 }

+68 -38

crates/jacquard-api/src/app_bsky/graph.rs

··· 994 994 } 995 995 fn validate( 996 996 &self, 997 997 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 997 997 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 998 998 Ok(()) 999 999 } 1000 1000 } ··· 1146 1146 } 1147 1147 fn validate( 1148 1148 &self, 1149 1149 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1149 1149 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1150 1150 if let Some(ref value) = self.description { 1151 1151 #[allow(unused_comparisons)] 1152 1152 if <str>::len(value.as_ref()) > 3000usize { 1153 1153 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1154 1154 - field: "description", 1153 1153 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 1154 1154 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1155 1155 + "description", 1156 1156 + ), 1155 1157 max: 3000usize, 1156 1158 actual: <str>::len(value.as_ref()), 1157 1159 }); ··· 1165 1167 ) 1166 1168 .count(); 1167 1169 if count > 300usize { 1168 1168 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1169 1169 - field: "description", 1170 1170 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 1171 1171 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1172 1172 + "description", 1173 1173 + ), 1170 1174 max: 300usize, 1171 1175 actual: count, 1172 1176 }); ··· 1175 1179 } 1176 1180 if let Some(ref value) = self.list_item_count { 1177 1181 if *value < 0i64 { 1178 1178 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1179 1179 - field: "list_item_count", 1182 1182 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1183 1183 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1184 1184 + "list_item_count", 1185 1185 + ), 1180 1186 min: 0i64, 1181 1187 actual: *value, 1182 1188 }); ··· 1186 1192 let value = &self.name; 1187 1193 #[allow(unused_comparisons)] 1188 1194 if <str>::len(value.as_ref()) > 64usize { 1189 1189 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1190 1190 - field: "name", 1195 1195 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 1196 1196 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1197 1197 + "name", 1198 1198 + ), 1191 1199 max: 64usize, 1192 1200 actual: <str>::len(value.as_ref()), 1193 1201 }); ··· 1197 1205 let value = &self.name; 1198 1206 #[allow(unused_comparisons)] 1199 1207 if <str>::len(value.as_ref()) < 1usize { 1200 1200 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 1201 1201 - field: "name", 1208 1208 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 1209 1209 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1210 1210 + "name", 1211 1211 + ), 1202 1212 min: 1usize, 1203 1213 actual: <str>::len(value.as_ref()), 1204 1214 }); ··· 1262 1272 } 1263 1273 fn validate( 1264 1274 &self, 1265 1265 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1275 1275 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1266 1276 if let Some(ref value) = self.list_item_count { 1267 1277 if *value < 0i64 { 1268 1268 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1269 1269 - field: "list_item_count", 1278 1278 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1279 1279 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1280 1280 + "list_item_count", 1281 1281 + ), 1270 1282 min: 0i64, 1271 1283 actual: *value, 1272 1284 }); ··· 1276 1288 let value = &self.name; 1277 1289 #[allow(unused_comparisons)] 1278 1290 if <str>::len(value.as_ref()) > 64usize { 1279 1279 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1280 1280 - field: "name", 1291 1291 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 1292 1292 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1293 1293 + "name", 1294 1294 + ), 1281 1295 max: 64usize, 1282 1296 actual: <str>::len(value.as_ref()), 1283 1297 }); ··· 1287 1301 let value = &self.name; 1288 1302 #[allow(unused_comparisons)] 1289 1303 if <str>::len(value.as_ref()) < 1usize { 1290 1290 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 1291 1291 - field: "name", 1304 1304 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 1305 1305 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1306 1306 + "name", 1307 1307 + ), 1292 1308 min: 1usize, 1293 1309 actual: <str>::len(value.as_ref()), 1294 1310 }); ··· 1330 1346 } 1331 1347 fn validate( 1332 1348 &self, 1333 1333 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1349 1349 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1334 1350 Ok(()) 1335 1351 } 1336 1352 } ··· 1384 1400 } 1385 1401 fn validate( 1386 1402 &self, 1387 1387 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1403 1403 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1388 1404 Ok(()) 1389 1405 } 1390 1406 } ··· 1447 1463 } 1448 1464 fn validate( 1449 1465 &self, 1450 1450 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1466 1466 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1451 1467 Ok(()) 1452 1468 } 1453 1469 } ··· 1510 1526 } 1511 1527 fn validate( 1512 1528 &self, 1513 1513 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1529 1529 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1514 1530 if let Some(ref value) = self.feeds { 1515 1531 #[allow(unused_comparisons)] 1516 1532 if value.len() > 3usize { 1517 1517 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1518 1518 - field: "feeds", 1533 1533 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 1534 1534 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1535 1535 + "feeds", 1536 1536 + ), 1519 1537 max: 3usize, 1520 1538 actual: value.len(), 1521 1539 }); ··· 1523 1541 } 1524 1542 if let Some(ref value) = self.joined_all_time_count { 1525 1543 if *value < 0i64 { 1526 1526 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1527 1527 - field: "joined_all_time_count", 1544 1544 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1545 1545 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1546 1546 + "joined_all_time_count", 1547 1547 + ), 1528 1548 min: 0i64, 1529 1549 actual: *value, 1530 1550 }); ··· 1532 1552 } 1533 1553 if let Some(ref value) = self.joined_week_count { 1534 1554 if *value < 0i64 { 1535 1535 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1536 1536 - field: "joined_week_count", 1555 1555 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1556 1556 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1557 1557 + "joined_week_count", 1558 1558 + ), 1537 1559 min: 0i64, 1538 1560 actual: *value, 1539 1561 }); ··· 1542 1564 if let Some(ref value) = self.list_items_sample { 1543 1565 #[allow(unused_comparisons)] 1544 1566 if value.len() > 12usize { 1545 1545 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1546 1546 - field: "list_items_sample", 1567 1567 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 1568 1568 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1569 1569 + "list_items_sample", 1570 1570 + ), 1547 1571 max: 12usize, 1548 1572 actual: value.len(), 1549 1573 }); ··· 1602 1626 } 1603 1627 fn validate( 1604 1628 &self, 1605 1605 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1629 1629 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1606 1630 if let Some(ref value) = self.joined_all_time_count { 1607 1631 if *value < 0i64 { 1608 1608 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1609 1609 - field: "joined_all_time_count", 1632 1632 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1633 1633 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1634 1634 + "joined_all_time_count", 1635 1635 + ), 1610 1636 min: 0i64, 1611 1637 actual: *value, 1612 1638 }); ··· 1614 1640 } 1615 1641 if let Some(ref value) = self.joined_week_count { 1616 1642 if *value < 0i64 { 1617 1617 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1618 1618 - field: "joined_week_count", 1643 1643 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1644 1644 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1645 1645 + "joined_week_count", 1646 1646 + ), 1619 1647 min: 0i64, 1620 1648 actual: *value, 1621 1649 }); ··· 1623 1651 } 1624 1652 if let Some(ref value) = self.list_item_count { 1625 1653 if *value < 0i64 { 1626 1626 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1627 1627 - field: "list_item_count", 1654 1654 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1655 1655 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1656 1656 + "list_item_count", 1657 1657 + ), 1628 1658 min: 0i64, 1629 1659 actual: *value, 1630 1660 });

+1 -1

crates/jacquard-api/src/app_bsky/graph/block.rs

··· 98 98 } 99 99 fn validate( 100 100 &self, 101 101 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 101 101 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 102 102 Ok(()) 103 103 } 104 104 }

+1 -1

crates/jacquard-api/src/app_bsky/graph/follow.rs

··· 97 97 } 98 98 fn validate( 99 99 &self, 100 100 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 100 100 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 101 101 Ok(()) 102 102 } 103 103 }

+1 -1

crates/jacquard-api/src/app_bsky/graph/get_lists_with_membership.rs

··· 185 185 } 186 186 fn validate( 187 187 &self, 188 188 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 188 188 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 189 189 Ok(()) 190 190 } 191 191 }

+1 -1

crates/jacquard-api/src/app_bsky/graph/get_starter_packs_with_membership.rs

··· 238 238 } 239 239 fn validate( 240 240 &self, 241 241 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 241 241 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 242 242 Ok(()) 243 243 } 244 244 }

+17 -9

crates/jacquard-api/src/app_bsky/graph/list.rs

··· 118 118 } 119 119 fn validate( 120 120 &self, 121 121 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 121 121 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 122 122 if let Some(ref value) = self.description { 123 123 #[allow(unused_comparisons)] 124 124 if <str>::len(value.as_ref()) > 3000usize { 125 125 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 126 126 - field: "description", 125 125 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 126 126 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 127 127 + "description", 128 128 + ), 127 129 max: 3000usize, 128 130 actual: <str>::len(value.as_ref()), 129 131 }); ··· 137 139 ) 138 140 .count(); 139 141 if count > 300usize { 140 140 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 141 141 - field: "description", 142 142 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 143 143 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 144 144 + "description", 145 145 + ), 142 146 max: 300usize, 143 147 actual: count, 144 148 }); ··· 149 153 let value = &self.name; 150 154 #[allow(unused_comparisons)] 151 155 if <str>::len(value.as_ref()) > 64usize { 152 152 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 153 153 - field: "name", 156 156 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 157 157 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 158 158 + "name", 159 159 + ), 154 160 max: 64usize, 155 161 actual: <str>::len(value.as_ref()), 156 162 }); ··· 160 166 let value = &self.name; 161 167 #[allow(unused_comparisons)] 162 168 if <str>::len(value.as_ref()) < 1usize { 163 163 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 164 164 - field: "name", 169 169 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 170 170 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 171 171 + "name", 172 172 + ), 165 173 min: 1usize, 166 174 actual: <str>::len(value.as_ref()), 167 175 });

+1 -1

crates/jacquard-api/src/app_bsky/graph/listblock.rs

··· 98 98 } 99 99 fn validate( 100 100 &self, 101 101 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 101 101 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 102 102 Ok(()) 103 103 } 104 104 }

+1 -1

crates/jacquard-api/src/app_bsky/graph/listitem.rs

··· 101 101 } 102 102 fn validate( 103 103 &self, 104 104 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 104 104 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 105 105 Ok(()) 106 106 } 107 107 }

+26 -14

crates/jacquard-api/src/app_bsky/graph/starterpack.rs

··· 212 212 } 213 213 fn validate( 214 214 &self, 215 215 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 215 215 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 216 216 Ok(()) 217 217 } 218 218 } ··· 326 326 } 327 327 fn validate( 328 328 &self, 329 329 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 329 329 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 330 330 if let Some(ref value) = self.description { 331 331 #[allow(unused_comparisons)] 332 332 if <str>::len(value.as_ref()) > 3000usize { 333 333 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 334 334 - field: "description", 333 333 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 334 334 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 335 335 + "description", 336 336 + ), 335 337 max: 3000usize, 336 338 actual: <str>::len(value.as_ref()), 337 339 }); ··· 345 347 ) 346 348 .count(); 347 349 if count > 300usize { 348 348 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 349 349 - field: "description", 350 350 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 351 351 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 352 352 + "description", 353 353 + ), 350 354 max: 300usize, 351 355 actual: count, 352 356 }); ··· 356 360 if let Some(ref value) = self.feeds { 357 361 #[allow(unused_comparisons)] 358 362 if value.len() > 3usize { 359 359 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 360 360 - field: "feeds", 363 363 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 364 364 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 365 365 + "feeds", 366 366 + ), 361 367 max: 3usize, 362 368 actual: value.len(), 363 369 }); ··· 367 373 let value = &self.name; 368 374 #[allow(unused_comparisons)] 369 375 if <str>::len(value.as_ref()) > 500usize { 370 370 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 371 371 - field: "name", 376 376 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 377 377 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 378 378 + "name", 379 379 + ), 372 380 max: 500usize, 373 381 actual: <str>::len(value.as_ref()), 374 382 }); ··· 378 386 let value = &self.name; 379 387 #[allow(unused_comparisons)] 380 388 if <str>::len(value.as_ref()) < 1usize { 381 381 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 382 382 - field: "name", 389 389 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 390 390 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 391 391 + "name", 392 392 + ), 383 393 min: 1usize, 384 394 actual: <str>::len(value.as_ref()), 385 395 }); ··· 394 404 ) 395 405 .count(); 396 406 if count > 50usize { 397 397 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 398 398 - field: "name", 407 407 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 408 408 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 409 409 + "name", 410 410 + ), 399 411 max: 50usize, 400 412 actual: count, 401 413 });

+1 -1

crates/jacquard-api/src/app_bsky/graph/verification.rs

··· 106 106 } 107 107 fn validate( 108 108 &self, 109 109 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 109 109 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 110 110 Ok(()) 111 111 } 112 112 }

+12 -8

crates/jacquard-api/src/app_bsky/labeler.rs

··· 461 461 } 462 462 fn validate( 463 463 &self, 464 464 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 464 464 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 465 465 Ok(()) 466 466 } 467 467 } ··· 511 511 } 512 512 fn validate( 513 513 &self, 514 514 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 514 514 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 515 515 if let Some(ref value) = self.like_count { 516 516 if *value < 0i64 { 517 517 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 518 518 - field: "like_count", 517 517 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 518 518 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 519 519 + "like_count", 520 520 + ), 519 521 min: 0i64, 520 522 actual: *value, 521 523 }); ··· 587 589 } 588 590 fn validate( 589 591 &self, 590 590 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 592 592 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 591 593 if let Some(ref value) = self.like_count { 592 594 if *value < 0i64 { 593 593 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 594 594 - field: "like_count", 595 595 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 596 596 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 597 597 + "like_count", 598 598 + ), 595 599 min: 0i64, 596 600 actual: *value, 597 601 }); ··· 631 635 } 632 636 fn validate( 633 637 &self, 634 634 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 638 638 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 635 639 Ok(()) 636 640 } 637 641 }

+1 -1

crates/jacquard-api/src/app_bsky/labeler/service.rs

··· 116 116 } 117 117 fn validate( 118 118 &self, 119 119 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 119 119 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 120 120 Ok(()) 121 121 } 122 122 }

+7 -7

crates/jacquard-api/src/app_bsky/notification.rs

··· 433 433 } 434 434 fn validate( 435 435 &self, 436 436 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 436 436 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 437 437 Ok(()) 438 438 } 439 439 } ··· 469 469 } 470 470 fn validate( 471 471 &self, 472 472 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 472 472 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 473 473 Ok(()) 474 474 } 475 475 } ··· 506 506 } 507 507 fn validate( 508 508 &self, 509 509 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 509 509 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 510 510 Ok(()) 511 511 } 512 512 } ··· 540 540 } 541 541 fn validate( 542 542 &self, 543 543 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 543 543 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 544 544 Ok(()) 545 545 } 546 546 } ··· 598 598 } 599 599 fn validate( 600 600 &self, 601 601 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 601 601 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 602 602 Ok(()) 603 603 } 604 604 } ··· 628 628 } 629 629 fn validate( 630 630 &self, 631 631 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 631 631 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 632 632 Ok(()) 633 633 } 634 634 } ··· 665 665 } 666 666 fn validate( 667 667 &self, 668 668 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 668 668 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 669 669 Ok(()) 670 670 } 671 671 }

+1 -1

crates/jacquard-api/src/app_bsky/notification/declaration.rs

··· 98 98 } 99 99 fn validate( 100 100 &self, 101 101 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 101 101 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 102 102 Ok(()) 103 103 } 104 104 }

+1 -1

crates/jacquard-api/src/app_bsky/notification/list_notifications.rs

··· 396 396 } 397 397 fn validate( 398 398 &self, 399 399 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 399 399 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 400 400 Ok(()) 401 401 } 402 402 }

+21 -13

crates/jacquard-api/src/app_bsky/richtext/facet.rs

··· 248 248 } 249 249 fn validate( 250 250 &self, 251 251 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 251 251 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 252 252 { 253 253 let value = &self.byte_end; 254 254 if *value < 0i64 { 255 255 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 256 256 - field: "byte_end", 255 255 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 256 256 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 257 257 + "byte_end", 258 258 + ), 257 259 min: 0i64, 258 260 actual: *value, 259 261 }); ··· 262 264 { 263 265 let value = &self.byte_start; 264 266 if *value < 0i64 { 265 265 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 266 266 - field: "byte_start", 267 267 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 268 268 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 269 269 + "byte_start", 270 270 + ), 267 271 min: 0i64, 268 272 actual: *value, 269 273 }); ··· 303 307 } 304 308 fn validate( 305 309 &self, 306 306 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 310 310 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 307 311 Ok(()) 308 312 } 309 313 } ··· 361 365 } 362 366 fn validate( 363 367 &self, 364 364 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 368 368 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 365 369 Ok(()) 366 370 } 367 371 } ··· 396 400 } 397 401 fn validate( 398 402 &self, 399 399 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 403 403 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 400 404 Ok(()) 401 405 } 402 406 } ··· 431 435 } 432 436 fn validate( 433 437 &self, 434 434 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 438 438 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 435 439 { 436 440 let value = &self.tag; 437 441 #[allow(unused_comparisons)] 438 442 if <str>::len(value.as_ref()) > 640usize { 439 439 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 440 440 - field: "tag", 443 443 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 444 444 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 445 445 + "tag", 446 446 + ), 441 447 max: 640usize, 442 448 actual: <str>::len(value.as_ref()), 443 449 }); ··· 452 458 ) 453 459 .count(); 454 460 if count > 64usize { 455 455 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 456 456 - field: "tag", 461 461 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 462 462 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 463 463 + "tag", 464 464 + ), 457 465 max: 64usize, 458 466 actual: count, 459 467 });

+12 -12

crates/jacquard-api/src/app_bsky/unspecced.rs

··· 964 964 } 965 965 fn validate( 966 966 &self, 967 967 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 967 967 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 968 968 Ok(()) 969 969 } 970 970 } ··· 1003 1003 } 1004 1004 fn validate( 1005 1005 &self, 1006 1006 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1006 1006 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1007 1007 Ok(()) 1008 1008 } 1009 1009 } ··· 1037 1037 } 1038 1038 fn validate( 1039 1039 &self, 1040 1040 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1040 1040 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1041 1041 Ok(()) 1042 1042 } 1043 1043 } ··· 1071 1071 } 1072 1072 fn validate( 1073 1073 &self, 1074 1074 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1074 1074 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1075 1075 Ok(()) 1076 1076 } 1077 1077 } ··· 1105 1105 } 1106 1106 fn validate( 1107 1107 &self, 1108 1108 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1108 1108 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1109 1109 Ok(()) 1110 1110 } 1111 1111 } ··· 1158 1158 } 1159 1159 fn validate( 1160 1160 &self, 1161 1161 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1161 1161 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1162 1162 Ok(()) 1163 1163 } 1164 1164 } ··· 1192 1192 } 1193 1193 fn validate( 1194 1194 &self, 1195 1195 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1195 1195 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1196 1196 Ok(()) 1197 1197 } 1198 1198 } ··· 1222 1222 } 1223 1223 fn validate( 1224 1224 &self, 1225 1225 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1225 1225 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1226 1226 Ok(()) 1227 1227 } 1228 1228 } ··· 1252 1252 } 1253 1253 fn validate( 1254 1254 &self, 1255 1255 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1255 1255 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1256 1256 Ok(()) 1257 1257 } 1258 1258 } ··· 1296 1296 } 1297 1297 fn validate( 1298 1298 &self, 1299 1299 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1299 1299 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1300 1300 Ok(()) 1301 1301 } 1302 1302 } ··· 1349 1349 } 1350 1350 fn validate( 1351 1351 &self, 1352 1352 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1352 1352 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1353 1353 Ok(()) 1354 1354 } 1355 1355 } ··· 1391 1391 } 1392 1392 fn validate( 1393 1393 &self, 1394 1394 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1394 1394 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1395 1395 Ok(()) 1396 1396 } 1397 1397 }

+1 -1

crates/jacquard-api/src/app_bsky/unspecced/get_config.rs

··· 115 115 } 116 116 fn validate( 117 117 &self, 118 118 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 118 118 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 119 119 Ok(()) 120 120 } 121 121 }

+1 -1

crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_other_v2.rs

··· 229 229 } 230 230 fn validate( 231 231 &self, 232 232 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 232 232 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 233 233 Ok(()) 234 234 } 235 235 }

+1 -1

crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_v2.rs

··· 325 325 } 326 326 fn validate( 327 327 &self, 328 328 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 328 328 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 329 329 Ok(()) 330 330 } 331 331 }

+1 -1

crates/jacquard-api/src/app_bsky/unspecced/get_tagged_suggestions.rs

··· 199 199 } 200 200 fn validate( 201 201 &self, 202 202 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 202 202 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 203 203 Ok(()) 204 204 } 205 205 }

+9 -5

crates/jacquard-api/src/app_bsky/video.rs

··· 195 195 } 196 196 fn validate( 197 197 &self, 198 198 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 198 198 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 199 199 if let Some(ref value) = self.progress { 200 200 if *value > 100i64 { 201 201 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 202 202 - field: "progress", 201 201 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 202 202 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 203 203 + "progress", 204 204 + ), 203 205 max: 100i64, 204 206 actual: *value, 205 207 }); ··· 207 209 } 208 210 if let Some(ref value) = self.progress { 209 211 if *value < 0i64 { 210 210 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 211 211 - field: "progress", 212 212 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 213 213 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 214 214 + "progress", 215 215 + ), 212 216 min: 0i64, 213 217 actual: *value, 214 218 });

+1 -1

crates/jacquard-api/src/app_ocho/auth.rs

··· 151 151 } 152 152 fn validate( 153 153 &self, 154 154 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 154 154 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 155 155 Ok(()) 156 156 } 157 157 }

+1 -1

crates/jacquard-api/src/app_ocho/edu/verification.rs

··· 103 103 } 104 104 fn validate( 105 105 &self, 106 106 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 106 106 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 107 107 Ok(()) 108 108 } 109 109 }

+13 -13

crates/jacquard-api/src/app_ocho/plugin.rs

··· 1023 1023 } 1024 1024 fn validate( 1025 1025 &self, 1026 1026 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1026 1026 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1027 1027 Ok(()) 1028 1028 } 1029 1029 } ··· 1062 1062 } 1063 1063 fn validate( 1064 1064 &self, 1065 1065 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1065 1065 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1066 1066 Ok(()) 1067 1067 } 1068 1068 } ··· 1099 1099 } 1100 1100 fn validate( 1101 1101 &self, 1102 1102 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1102 1102 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1103 1103 Ok(()) 1104 1104 } 1105 1105 } ··· 1146 1146 } 1147 1147 fn validate( 1148 1148 &self, 1149 1149 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1149 1149 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1150 1150 Ok(()) 1151 1151 } 1152 1152 } ··· 1181 1181 } 1182 1182 fn validate( 1183 1183 &self, 1184 1184 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1184 1184 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1185 1185 Ok(()) 1186 1186 } 1187 1187 } ··· 1216 1216 } 1217 1217 fn validate( 1218 1218 &self, 1219 1219 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1219 1219 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1220 1220 Ok(()) 1221 1221 } 1222 1222 } ··· 1319 1319 } 1320 1320 fn validate( 1321 1321 &self, 1322 1322 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1322 1322 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1323 1323 Ok(()) 1324 1324 } 1325 1325 } ··· 1354 1354 } 1355 1355 fn validate( 1356 1356 &self, 1357 1357 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1357 1357 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1358 1358 Ok(()) 1359 1359 } 1360 1360 } ··· 1389 1389 } 1390 1390 fn validate( 1391 1391 &self, 1392 1392 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1392 1392 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1393 1393 Ok(()) 1394 1394 } 1395 1395 } ··· 1432 1432 } 1433 1433 fn validate( 1434 1434 &self, 1435 1435 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1435 1435 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1436 1436 Ok(()) 1437 1437 } 1438 1438 } ··· 1482 1482 } 1483 1483 fn validate( 1484 1484 &self, 1485 1485 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1485 1485 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1486 1486 Ok(()) 1487 1487 } 1488 1488 } ··· 1518 1518 } 1519 1519 fn validate( 1520 1520 &self, 1521 1521 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1521 1521 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1522 1522 Ok(()) 1523 1523 } 1524 1524 } ··· 1588 1588 } 1589 1589 fn validate( 1590 1590 &self, 1591 1591 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1591 1591 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1592 1592 Ok(()) 1593 1593 } 1594 1594 }

+1 -1

crates/jacquard-api/src/app_ocho/plugin/service.rs

··· 101 101 } 102 102 fn validate( 103 103 &self, 104 104 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 104 104 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 105 105 Ok(()) 106 106 } 107 107 }

+2 -2

crates/jacquard-api/src/app_rocksky/actor.rs

··· 397 397 } 398 398 fn validate( 399 399 &self, 400 400 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 400 400 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 401 401 Ok(()) 402 402 } 403 403 } ··· 455 455 } 456 456 fn validate( 457 457 &self, 458 458 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 458 458 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 459 459 Ok(()) 460 460 } 461 461 }

+39 -21

crates/jacquard-api/src/app_rocksky/album.rs

··· 155 155 } 156 156 fn validate( 157 157 &self, 158 158 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 158 158 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 159 159 { 160 160 let value = &self.artist; 161 161 #[allow(unused_comparisons)] 162 162 if <str>::len(value.as_ref()) > 256usize { 163 163 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 164 164 - field: "artist", 163 163 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 164 164 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 165 165 + "artist", 166 166 + ), 165 167 max: 256usize, 166 168 actual: <str>::len(value.as_ref()), 167 169 }); ··· 171 173 let value = &self.artist; 172 174 #[allow(unused_comparisons)] 173 175 if <str>::len(value.as_ref()) < 1usize { 174 174 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 175 175 - field: "artist", 176 176 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 177 177 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 178 178 + "artist", 179 179 + ), 176 180 min: 1usize, 177 181 actual: <str>::len(value.as_ref()), 178 182 }); ··· 181 185 if let Some(ref value) = self.genre { 182 186 #[allow(unused_comparisons)] 183 187 if <str>::len(value.as_ref()) > 256usize { 184 184 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 185 185 - field: "genre", 188 188 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 189 189 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 190 190 + "genre", 191 191 + ), 186 192 max: 256usize, 187 193 actual: <str>::len(value.as_ref()), 188 194 }); ··· 192 198 let value = &self.title; 193 199 #[allow(unused_comparisons)] 194 200 if <str>::len(value.as_ref()) > 512usize { 195 195 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 196 196 - field: "title", 201 201 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 202 202 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 203 203 + "title", 204 204 + ), 197 205 max: 512usize, 198 206 actual: <str>::len(value.as_ref()), 199 207 }); ··· 203 211 let value = &self.title; 204 212 #[allow(unused_comparisons)] 205 213 if <str>::len(value.as_ref()) < 1usize { 206 206 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 207 207 - field: "title", 214 214 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 215 215 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 216 216 + "title", 217 217 + ), 208 218 min: 1usize, 209 219 actual: <str>::len(value.as_ref()), 210 220 }); ··· 1028 1038 } 1029 1039 fn validate( 1030 1040 &self, 1031 1031 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1041 1041 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1032 1042 if let Some(ref value) = self.play_count { 1033 1043 if *value < 0i64 { 1034 1034 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1035 1035 - field: "play_count", 1044 1044 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1045 1045 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1046 1046 + "play_count", 1047 1047 + ), 1036 1048 min: 0i64, 1037 1049 actual: *value, 1038 1050 }); ··· 1040 1052 } 1041 1053 if let Some(ref value) = self.unique_listeners { 1042 1054 if *value < 0i64 { 1043 1043 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1044 1044 - field: "unique_listeners", 1055 1055 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1056 1056 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1057 1057 + "unique_listeners", 1058 1058 + ), 1045 1059 min: 0i64, 1046 1060 actual: *value, 1047 1061 }); ··· 1122 1136 } 1123 1137 fn validate( 1124 1138 &self, 1125 1125 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1139 1139 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1126 1140 if let Some(ref value) = self.play_count { 1127 1141 if *value < 0i64 { 1128 1128 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1129 1129 - field: "play_count", 1142 1142 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1143 1143 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1144 1144 + "play_count", 1145 1145 + ), 1130 1146 min: 0i64, 1131 1147 actual: *value, 1132 1148 }); ··· 1134 1150 } 1135 1151 if let Some(ref value) = self.unique_listeners { 1136 1152 if *value < 0i64 { 1137 1137 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1138 1138 - field: "unique_listeners", 1153 1153 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1154 1154 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1155 1155 + "unique_listeners", 1156 1156 + ), 1139 1157 min: 0i64, 1140 1158 actual: *value, 1141 1159 });

+1 -1

crates/jacquard-api/src/app_rocksky/apikey.rs

··· 162 162 } 163 163 fn validate( 164 164 &self, 165 165 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 165 165 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 166 166 Ok(()) 167 167 } 168 168 }

+35 -19

crates/jacquard-api/src/app_rocksky/artist.rs

··· 133 133 } 134 134 fn validate( 135 135 &self, 136 136 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 136 136 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 137 137 if let Some(ref value) = self.bio { 138 138 #[allow(unused_comparisons)] 139 139 if <str>::len(value.as_ref()) > 1000usize { 140 140 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 141 141 - field: "bio", 140 140 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 141 141 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 142 142 + "bio", 143 143 + ), 142 144 max: 1000usize, 143 145 actual: <str>::len(value.as_ref()), 144 146 }); ··· 147 149 if let Some(ref value) = self.born_in { 148 150 #[allow(unused_comparisons)] 149 151 if <str>::len(value.as_ref()) > 256usize { 150 150 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 151 151 - field: "born_in", 152 152 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 153 153 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 154 154 + "born_in", 155 155 + ), 152 156 max: 256usize, 153 157 actual: <str>::len(value.as_ref()), 154 158 }); ··· 158 162 let value = &self.name; 159 163 #[allow(unused_comparisons)] 160 164 if <str>::len(value.as_ref()) > 512usize { 161 161 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 162 162 - field: "name", 165 165 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 166 166 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 167 167 + "name", 168 168 + ), 163 169 max: 512usize, 164 170 actual: <str>::len(value.as_ref()), 165 171 }); ··· 169 175 let value = &self.name; 170 176 #[allow(unused_comparisons)] 171 177 if <str>::len(value.as_ref()) < 1usize { 172 172 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 173 173 - field: "name", 178 178 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 179 179 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 180 180 + "name", 181 181 + ), 174 182 min: 1usize, 175 183 actual: <str>::len(value.as_ref()), 176 184 }); ··· 713 721 } 714 722 fn validate( 715 723 &self, 716 716 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 724 724 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 717 725 if let Some(ref value) = self.play_count { 718 726 if *value < 0i64 { 719 719 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 720 720 - field: "play_count", 727 727 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 728 728 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 729 729 + "play_count", 730 730 + ), 721 731 min: 0i64, 722 732 actual: *value, 723 733 }); ··· 725 735 } 726 736 if let Some(ref value) = self.unique_listeners { 727 737 if *value < 0i64 { 728 728 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 729 729 - field: "unique_listeners", 738 738 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 739 739 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 740 740 + "unique_listeners", 741 741 + ), 730 742 min: 0i64, 731 743 actual: *value, 732 744 }); ··· 789 801 } 790 802 fn validate( 791 803 &self, 792 792 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 804 804 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 793 805 if let Some(ref value) = self.play_count { 794 806 if *value < 0i64 { 795 795 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 796 796 - field: "play_count", 807 807 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 808 808 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 809 809 + "play_count", 810 810 + ), 797 811 min: 0i64, 798 812 actual: *value, 799 813 }); ··· 801 815 } 802 816 if let Some(ref value) = self.unique_listeners { 803 817 if *value < 0i64 { 804 804 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 805 805 - field: "unique_listeners", 818 818 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 819 819 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 820 820 + "unique_listeners", 821 821 + ), 806 822 min: 0i64, 807 823 actual: *value, 808 824 });

+2 -2

crates/jacquard-api/src/app_rocksky/charts.rs

··· 128 128 } 129 129 fn validate( 130 130 &self, 131 131 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 131 131 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 132 132 Ok(()) 133 133 } 134 134 } ··· 166 166 } 167 167 fn validate( 168 168 &self, 169 169 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 169 169 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 170 170 Ok(()) 171 171 } 172 172 }

+3 -3

crates/jacquard-api/src/app_rocksky/dropbox.rs

··· 260 260 } 261 261 fn validate( 262 262 &self, 263 263 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 263 263 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 264 264 Ok(()) 265 265 } 266 266 } ··· 314 314 } 315 315 fn validate( 316 316 &self, 317 317 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 317 317 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 318 318 Ok(()) 319 319 } 320 320 } ··· 350 350 } 351 351 fn validate( 352 352 &self, 353 353 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 353 353 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 354 354 Ok(()) 355 355 } 356 356 }

+3 -3

crates/jacquard-api/src/app_rocksky/feed.rs

··· 462 462 } 463 463 fn validate( 464 464 &self, 465 465 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 465 465 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 466 466 Ok(()) 467 467 } 468 468 } ··· 499 499 } 500 500 fn validate( 501 501 &self, 502 502 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 502 502 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 503 503 Ok(()) 504 504 } 505 505 } ··· 567 567 } 568 568 fn validate( 569 569 &self, 570 570 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 570 570 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 571 571 Ok(()) 572 572 } 573 573 }

+2 -2

crates/jacquard-api/src/app_rocksky/googledrive.rs

··· 113 113 } 114 114 fn validate( 115 115 &self, 116 116 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 116 116 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 117 117 Ok(()) 118 118 } 119 119 } ··· 149 149 } 150 150 fn validate( 151 151 &self, 152 152 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 152 152 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 153 153 Ok(()) 154 154 } 155 155 }

+1 -1

crates/jacquard-api/src/app_rocksky/like.rs

··· 103 103 } 104 104 fn validate( 105 105 &self, 106 106 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 106 106 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 107 107 Ok(()) 108 108 } 109 109 }

+1 -1

crates/jacquard-api/src/app_rocksky/player.rs

··· 92 92 } 93 93 fn validate( 94 94 &self, 95 95 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 95 95 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 96 96 Ok(()) 97 97 } 98 98 }

+23 -13

crates/jacquard-api/src/app_rocksky/playlist.rs

··· 138 138 } 139 139 fn validate( 140 140 &self, 141 141 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 141 141 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 142 142 if let Some(ref value) = self.description { 143 143 #[allow(unused_comparisons)] 144 144 if <str>::len(value.as_ref()) > 256usize { 145 145 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 146 146 - field: "description", 145 145 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 146 146 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 147 147 + "description", 148 148 + ), 147 149 max: 256usize, 148 150 actual: <str>::len(value.as_ref()), 149 151 }); ··· 152 154 if let Some(ref value) = self.description { 153 155 #[allow(unused_comparisons)] 154 156 if <str>::len(value.as_ref()) < 1usize { 155 155 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 156 156 - field: "description", 157 157 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 158 158 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 159 159 + "description", 160 160 + ), 157 161 min: 1usize, 158 162 actual: <str>::len(value.as_ref()), 159 163 }); ··· 163 167 let value = &self.name; 164 168 #[allow(unused_comparisons)] 165 169 if <str>::len(value.as_ref()) > 512usize { 166 166 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 167 167 - field: "name", 170 170 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 171 171 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 172 172 + "name", 173 173 + ), 168 174 max: 512usize, 169 175 actual: <str>::len(value.as_ref()), 170 176 }); ··· 174 180 let value = &self.name; 175 181 #[allow(unused_comparisons)] 176 182 if <str>::len(value.as_ref()) < 1usize { 177 177 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 178 178 - field: "name", 183 183 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 184 184 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 185 185 + "name", 186 186 + ), 179 187 min: 1usize, 180 188 actual: <str>::len(value.as_ref()), 181 189 }); ··· 985 993 } 986 994 fn validate( 987 995 &self, 988 988 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 996 996 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 989 997 if let Some(ref value) = self.track_count { 990 998 if *value < 0i64 { 991 991 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 992 992 - field: "track_count", 999 999 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1000 1000 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1001 1001 + "track_count", 1002 1002 + ), 993 1003 min: 0i64, 994 1004 actual: *value, 995 1005 }); ··· 1074 1084 } 1075 1085 fn validate( 1076 1086 &self, 1077 1077 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1087 1087 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1078 1088 Ok(()) 1079 1089 } 1080 1090 }

+27 -15

crates/jacquard-api/src/app_rocksky/radio.rs

··· 123 123 } 124 124 fn validate( 125 125 &self, 126 126 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 126 126 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 127 127 if let Some(ref value) = self.description { 128 128 #[allow(unused_comparisons)] 129 129 if <str>::len(value.as_ref()) > 1000usize { 130 130 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 131 131 - field: "description", 130 130 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 131 131 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 132 132 + "description", 133 133 + ), 132 134 max: 1000usize, 133 135 actual: <str>::len(value.as_ref()), 134 136 }); ··· 137 139 if let Some(ref value) = self.description { 138 140 #[allow(unused_comparisons)] 139 141 if <str>::len(value.as_ref()) < 1usize { 140 140 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 141 141 - field: "description", 142 142 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 143 143 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 144 144 + "description", 145 145 + ), 142 146 min: 1usize, 143 147 actual: <str>::len(value.as_ref()), 144 148 }); ··· 147 151 if let Some(ref value) = self.genre { 148 152 #[allow(unused_comparisons)] 149 153 if <str>::len(value.as_ref()) > 256usize { 150 150 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 151 151 - field: "genre", 154 154 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 155 155 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 156 156 + "genre", 157 157 + ), 152 158 max: 256usize, 153 159 actual: <str>::len(value.as_ref()), 154 160 }); ··· 157 163 if let Some(ref value) = self.genre { 158 164 #[allow(unused_comparisons)] 159 165 if <str>::len(value.as_ref()) < 1usize { 160 160 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 161 161 - field: "genre", 166 166 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 167 167 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 168 168 + "genre", 169 169 + ), 162 170 min: 1usize, 163 171 actual: <str>::len(value.as_ref()), 164 172 }); ··· 168 176 let value = &self.name; 169 177 #[allow(unused_comparisons)] 170 178 if <str>::len(value.as_ref()) > 512usize { 171 171 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 172 172 - field: "name", 179 179 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 180 180 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 181 181 + "name", 182 182 + ), 173 183 max: 512usize, 174 184 actual: <str>::len(value.as_ref()), 175 185 }); ··· 179 189 let value = &self.name; 180 190 #[allow(unused_comparisons)] 181 191 if <str>::len(value.as_ref()) < 1usize { 182 182 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 183 183 - field: "name", 192 192 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 193 193 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 194 194 + "name", 195 195 + ), 184 196 min: 1usize, 185 197 actual: <str>::len(value.as_ref()), 186 198 }); ··· 689 701 } 690 702 fn validate( 691 703 &self, 692 692 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 704 704 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 693 705 Ok(()) 694 706 } 695 707 } ··· 752 764 } 753 765 fn validate( 754 766 &self, 755 755 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 767 767 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 756 768 Ok(()) 757 769 } 758 770 }

+71 -37

crates/jacquard-api/src/app_rocksky/scrobble.rs

··· 199 199 } 200 200 fn validate( 201 201 &self, 202 202 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 202 202 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 203 203 { 204 204 let value = &self.album; 205 205 #[allow(unused_comparisons)] 206 206 if <str>::len(value.as_ref()) > 256usize { 207 207 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 208 208 - field: "album", 207 207 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 208 208 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 209 209 + "album", 210 210 + ), 209 211 max: 256usize, 210 212 actual: <str>::len(value.as_ref()), 211 213 }); ··· 215 217 let value = &self.album; 216 218 #[allow(unused_comparisons)] 217 219 if <str>::len(value.as_ref()) < 1usize { 218 218 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 219 219 - field: "album", 220 220 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 221 221 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 222 222 + "album", 223 223 + ), 220 224 min: 1usize, 221 225 actual: <str>::len(value.as_ref()), 222 226 }); ··· 226 230 let value = &self.album_artist; 227 231 #[allow(unused_comparisons)] 228 232 if <str>::len(value.as_ref()) > 256usize { 229 229 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 230 230 - field: "album_artist", 233 233 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 234 234 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 235 235 + "album_artist", 236 236 + ), 231 237 max: 256usize, 232 238 actual: <str>::len(value.as_ref()), 233 239 }); ··· 237 243 let value = &self.album_artist; 238 244 #[allow(unused_comparisons)] 239 245 if <str>::len(value.as_ref()) < 1usize { 240 240 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 241 241 - field: "album_artist", 246 246 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 247 247 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 248 248 + "album_artist", 249 249 + ), 242 250 min: 1usize, 243 251 actual: <str>::len(value.as_ref()), 244 252 }); ··· 248 256 let value = &self.artist; 249 257 #[allow(unused_comparisons)] 250 258 if <str>::len(value.as_ref()) > 256usize { 251 251 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 252 252 - field: "artist", 259 259 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 260 260 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 261 261 + "artist", 262 262 + ), 253 263 max: 256usize, 254 264 actual: <str>::len(value.as_ref()), 255 265 }); ··· 259 269 let value = &self.artist; 260 270 #[allow(unused_comparisons)] 261 271 if <str>::len(value.as_ref()) < 1usize { 262 262 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 263 263 - field: "artist", 272 272 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 273 273 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 274 274 + "artist", 275 275 + ), 264 276 min: 1usize, 265 277 actual: <str>::len(value.as_ref()), 266 278 }); ··· 269 281 if let Some(ref value) = self.composer { 270 282 #[allow(unused_comparisons)] 271 283 if <str>::len(value.as_ref()) > 256usize { 272 272 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 273 273 - field: "composer", 284 284 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 285 285 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 286 286 + "composer", 287 287 + ), 274 288 max: 256usize, 275 289 actual: <str>::len(value.as_ref()), 276 290 }); ··· 279 293 if let Some(ref value) = self.copyright_message { 280 294 #[allow(unused_comparisons)] 281 295 if <str>::len(value.as_ref()) > 256usize { 282 282 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 283 283 - field: "copyright_message", 296 296 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 297 297 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 298 298 + "copyright_message", 299 299 + ), 284 300 max: 256usize, 285 301 actual: <str>::len(value.as_ref()), 286 302 }); ··· 288 304 } 289 305 if let Some(ref value) = self.disc_number { 290 306 if *value < 1i64 { 291 291 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 292 292 - field: "disc_number", 307 307 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 308 308 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 309 309 + "disc_number", 310 310 + ), 293 311 min: 1i64, 294 312 actual: *value, 295 313 }); ··· 298 316 { 299 317 let value = &self.duration; 300 318 if *value < 1i64 { 301 301 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 302 302 - field: "duration", 319 319 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 320 320 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 321 321 + "duration", 322 322 + ), 303 323 min: 1i64, 304 324 actual: *value, 305 325 }); ··· 308 328 if let Some(ref value) = self.genre { 309 329 #[allow(unused_comparisons)] 310 330 if <str>::len(value.as_ref()) > 256usize { 311 311 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 312 312 - field: "genre", 331 331 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 332 332 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 333 333 + "genre", 334 334 + ), 313 335 max: 256usize, 314 336 actual: <str>::len(value.as_ref()), 315 337 }); ··· 318 340 if let Some(ref value) = self.label { 319 341 #[allow(unused_comparisons)] 320 342 if <str>::len(value.as_ref()) > 256usize { 321 321 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 322 322 - field: "label", 343 343 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 344 344 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 345 345 + "label", 346 346 + ), 323 347 max: 256usize, 324 348 actual: <str>::len(value.as_ref()), 325 349 }); ··· 328 352 if let Some(ref value) = self.lyrics { 329 353 #[allow(unused_comparisons)] 330 354 if <str>::len(value.as_ref()) > 10000usize { 331 331 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 332 332 - field: "lyrics", 355 355 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 356 356 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 357 357 + "lyrics", 358 358 + ), 333 359 max: 10000usize, 334 360 actual: <str>::len(value.as_ref()), 335 361 }); ··· 339 365 let value = &self.title; 340 366 #[allow(unused_comparisons)] 341 367 if <str>::len(value.as_ref()) > 512usize { 342 342 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 343 343 - field: "title", 368 368 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 369 369 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 370 370 + "title", 371 371 + ), 344 372 max: 512usize, 345 373 actual: <str>::len(value.as_ref()), 346 374 }); ··· 350 378 let value = &self.title; 351 379 #[allow(unused_comparisons)] 352 380 if <str>::len(value.as_ref()) < 1usize { 353 353 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 354 354 - field: "title", 381 381 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 382 382 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 383 383 + "title", 384 384 + ), 355 385 min: 1usize, 356 386 actual: <str>::len(value.as_ref()), 357 387 }); ··· 359 389 } 360 390 if let Some(ref value) = self.track_number { 361 391 if *value < 1i64 { 362 362 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 363 363 - field: "track_number", 392 392 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 393 393 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 394 394 + "track_number", 395 395 + ), 364 396 min: 1i64, 365 397 actual: *value, 366 398 }); ··· 369 401 if let Some(ref value) = self.wiki { 370 402 #[allow(unused_comparisons)] 371 403 if <str>::len(value.as_ref()) > 10000usize { 372 372 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 373 373 - field: "wiki", 404 404 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 405 405 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 406 406 + "wiki", 407 407 + ), 374 408 max: 10000usize, 375 409 actual: <str>::len(value.as_ref()), 376 410 }); ··· 1441 1475 } 1442 1476 fn validate( 1443 1477 &self, 1444 1444 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1478 1478 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1445 1479 Ok(()) 1446 1480 } 1447 1481 } ··· 1522 1556 } 1523 1557 fn validate( 1524 1558 &self, 1525 1525 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1559 1559 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1526 1560 Ok(()) 1527 1561 } 1528 1562 }

+11 -7

crates/jacquard-api/src/app_rocksky/shout.rs

··· 116 116 } 117 117 fn validate( 118 118 &self, 119 119 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 119 119 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 120 120 { 121 121 let value = &self.message; 122 122 #[allow(unused_comparisons)] 123 123 if <str>::len(value.as_ref()) > 1000usize { 124 124 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 125 125 - field: "message", 124 124 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 125 125 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 126 126 + "message", 127 127 + ), 126 128 max: 1000usize, 127 129 actual: <str>::len(value.as_ref()), 128 130 }); ··· 132 134 let value = &self.message; 133 135 #[allow(unused_comparisons)] 134 136 if <str>::len(value.as_ref()) < 1usize { 135 135 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 136 136 - field: "message", 137 137 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 138 138 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 139 139 + "message", 140 140 + ), 137 141 min: 1usize, 138 142 actual: <str>::len(value.as_ref()), 139 143 }); ··· 523 527 } 524 528 fn validate( 525 529 &self, 526 526 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 530 530 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 527 531 Ok(()) 528 532 } 529 533 } ··· 574 578 } 575 579 fn validate( 576 580 &self, 577 577 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 581 581 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 578 582 Ok(()) 579 583 } 580 584 }

+91 -47

crates/jacquard-api/src/app_rocksky/song.rs

··· 199 199 } 200 200 fn validate( 201 201 &self, 202 202 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 202 202 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 203 203 { 204 204 let value = &self.album; 205 205 #[allow(unused_comparisons)] 206 206 if <str>::len(value.as_ref()) > 256usize { 207 207 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 208 208 - field: "album", 207 207 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 208 208 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 209 209 + "album", 210 210 + ), 209 211 max: 256usize, 210 212 actual: <str>::len(value.as_ref()), 211 213 }); ··· 215 217 let value = &self.album; 216 218 #[allow(unused_comparisons)] 217 219 if <str>::len(value.as_ref()) < 1usize { 218 218 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 219 219 - field: "album", 220 220 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 221 221 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 222 222 + "album", 223 223 + ), 220 224 min: 1usize, 221 225 actual: <str>::len(value.as_ref()), 222 226 }); ··· 226 230 let value = &self.album_artist; 227 231 #[allow(unused_comparisons)] 228 232 if <str>::len(value.as_ref()) > 256usize { 229 229 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 230 230 - field: "album_artist", 233 233 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 234 234 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 235 235 + "album_artist", 236 236 + ), 231 237 max: 256usize, 232 238 actual: <str>::len(value.as_ref()), 233 239 }); ··· 237 243 let value = &self.album_artist; 238 244 #[allow(unused_comparisons)] 239 245 if <str>::len(value.as_ref()) < 1usize { 240 240 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 241 241 - field: "album_artist", 246 246 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 247 247 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 248 248 + "album_artist", 249 249 + ), 242 250 min: 1usize, 243 251 actual: <str>::len(value.as_ref()), 244 252 }); ··· 248 256 let value = &self.artist; 249 257 #[allow(unused_comparisons)] 250 258 if <str>::len(value.as_ref()) > 256usize { 251 251 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 252 252 - field: "artist", 259 259 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 260 260 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 261 261 + "artist", 262 262 + ), 253 263 max: 256usize, 254 264 actual: <str>::len(value.as_ref()), 255 265 }); ··· 259 269 let value = &self.artist; 260 270 #[allow(unused_comparisons)] 261 271 if <str>::len(value.as_ref()) < 1usize { 262 262 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 263 263 - field: "artist", 272 272 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 273 273 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 274 274 + "artist", 275 275 + ), 264 276 min: 1usize, 265 277 actual: <str>::len(value.as_ref()), 266 278 }); ··· 269 281 if let Some(ref value) = self.composer { 270 282 #[allow(unused_comparisons)] 271 283 if <str>::len(value.as_ref()) > 256usize { 272 272 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 273 273 - field: "composer", 284 284 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 285 285 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 286 286 + "composer", 287 287 + ), 274 288 max: 256usize, 275 289 actual: <str>::len(value.as_ref()), 276 290 }); ··· 279 293 if let Some(ref value) = self.copyright_message { 280 294 #[allow(unused_comparisons)] 281 295 if <str>::len(value.as_ref()) > 256usize { 282 282 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 283 283 - field: "copyright_message", 296 296 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 297 297 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 298 298 + "copyright_message", 299 299 + ), 284 300 max: 256usize, 285 301 actual: <str>::len(value.as_ref()), 286 302 }); ··· 288 304 } 289 305 if let Some(ref value) = self.disc_number { 290 306 if *value < 1i64 { 291 291 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 292 292 - field: "disc_number", 307 307 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 308 308 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 309 309 + "disc_number", 310 310 + ), 293 311 min: 1i64, 294 312 actual: *value, 295 313 }); ··· 298 316 { 299 317 let value = &self.duration; 300 318 if *value < 1i64 { 301 301 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 302 302 - field: "duration", 319 319 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 320 320 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 321 321 + "duration", 322 322 + ), 303 323 min: 1i64, 304 324 actual: *value, 305 325 }); ··· 308 328 if let Some(ref value) = self.genre { 309 329 #[allow(unused_comparisons)] 310 330 if <str>::len(value.as_ref()) > 256usize { 311 311 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 312 312 - field: "genre", 331 331 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 332 332 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 333 333 + "genre", 334 334 + ), 313 335 max: 256usize, 314 336 actual: <str>::len(value.as_ref()), 315 337 }); ··· 318 340 if let Some(ref value) = self.genre { 319 341 #[allow(unused_comparisons)] 320 342 if <str>::len(value.as_ref()) < 1usize { 321 321 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 322 322 - field: "genre", 343 343 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 344 344 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 345 345 + "genre", 346 346 + ), 323 347 min: 1usize, 324 348 actual: <str>::len(value.as_ref()), 325 349 }); ··· 328 352 if let Some(ref value) = self.label { 329 353 #[allow(unused_comparisons)] 330 354 if <str>::len(value.as_ref()) > 256usize { 331 331 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 332 332 - field: "label", 355 355 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 356 356 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 357 357 + "label", 358 358 + ), 333 359 max: 256usize, 334 360 actual: <str>::len(value.as_ref()), 335 361 }); ··· 338 364 if let Some(ref value) = self.lyrics { 339 365 #[allow(unused_comparisons)] 340 366 if <str>::len(value.as_ref()) > 10000usize { 341 341 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 342 342 - field: "lyrics", 367 367 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 368 368 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 369 369 + "lyrics", 370 370 + ), 343 371 max: 10000usize, 344 372 actual: <str>::len(value.as_ref()), 345 373 }); ··· 349 377 let value = &self.title; 350 378 #[allow(unused_comparisons)] 351 379 if <str>::len(value.as_ref()) > 512usize { 352 352 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 353 353 - field: "title", 380 380 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 381 381 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 382 382 + "title", 383 383 + ), 354 384 max: 512usize, 355 385 actual: <str>::len(value.as_ref()), 356 386 }); ··· 360 390 let value = &self.title; 361 391 #[allow(unused_comparisons)] 362 392 if <str>::len(value.as_ref()) < 1usize { 363 363 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 364 364 - field: "title", 393 393 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 394 394 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 395 395 + "title", 396 396 + ), 365 397 min: 1usize, 366 398 actual: <str>::len(value.as_ref()), 367 399 }); ··· 369 401 } 370 402 if let Some(ref value) = self.track_number { 371 403 if *value < 1i64 { 372 372 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 373 373 - field: "track_number", 404 404 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 405 405 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 406 406 + "track_number", 407 407 + ), 374 408 min: 1i64, 375 409 actual: *value, 376 410 }); ··· 379 413 if let Some(ref value) = self.wiki { 380 414 #[allow(unused_comparisons)] 381 415 if <str>::len(value.as_ref()) > 10000usize { 382 382 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 383 383 - field: "wiki", 416 416 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 417 417 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 418 418 + "wiki", 419 419 + ), 384 420 max: 10000usize, 385 421 actual: <str>::len(value.as_ref()), 386 422 }); ··· 1570 1606 } 1571 1607 fn validate( 1572 1608 &self, 1573 1573 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1609 1609 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1574 1610 if let Some(ref value) = self.play_count { 1575 1611 if *value < 0i64 { 1576 1576 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1577 1577 - field: "play_count", 1612 1612 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1613 1613 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1614 1614 + "play_count", 1615 1615 + ), 1578 1616 min: 0i64, 1579 1617 actual: *value, 1580 1618 }); ··· 1582 1620 } 1583 1621 if let Some(ref value) = self.unique_listeners { 1584 1622 if *value < 0i64 { 1585 1585 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1586 1586 - field: "unique_listeners", 1623 1623 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1624 1624 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1625 1625 + "unique_listeners", 1626 1626 + ), 1587 1627 min: 0i64, 1588 1628 actual: *value, 1589 1629 }); ··· 1678 1718 } 1679 1719 fn validate( 1680 1720 &self, 1681 1681 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1721 1721 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1682 1722 if let Some(ref value) = self.play_count { 1683 1723 if *value < 0i64 { 1684 1684 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1685 1685 - field: "play_count", 1724 1724 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1725 1725 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1726 1726 + "play_count", 1727 1727 + ), 1686 1728 min: 0i64, 1687 1729 actual: *value, 1688 1730 }); ··· 1690 1732 } 1691 1733 if let Some(ref value) = self.unique_listeners { 1692 1734 if *value < 0i64 { 1693 1693 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1694 1694 - field: "unique_listeners", 1735 1735 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1736 1736 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1737 1737 + "unique_listeners", 1738 1738 + ), 1695 1739 min: 0i64, 1696 1740 actual: *value, 1697 1741 });

+1 -1

crates/jacquard-api/src/app_rocksky/spotify.rs

··· 198 198 } 199 199 fn validate( 200 200 &self, 201 201 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 201 201 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 202 202 Ok(()) 203 203 } 204 204 }

+1 -1

crates/jacquard-api/src/app_rocksky/stats.rs

··· 136 136 } 137 137 fn validate( 138 138 &self, 139 139 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 139 139 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 140 140 Ok(()) 141 141 } 142 142 }

+17 -9

crates/jacquard-api/src/beauty_cybernetic/trustcow/review.rs

··· 117 117 } 118 118 fn validate( 119 119 &self, 120 120 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 120 120 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 121 121 if let Some(ref value) = self.description { 122 122 #[allow(unused_comparisons)] 123 123 if <str>::len(value.as_ref()) > 1000usize { 124 124 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 125 125 - field: "description", 124 124 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 125 125 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 126 126 + "description", 127 127 + ), 126 128 max: 1000usize, 127 129 actual: <str>::len(value.as_ref()), 128 130 }); ··· 131 133 { 132 134 let value = &self.rating; 133 135 if *value > 5i64 { 134 134 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 135 135 - field: "rating", 136 136 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 137 137 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 138 138 + "rating", 139 139 + ), 136 140 max: 5i64, 137 141 actual: *value, 138 142 }); ··· 141 145 { 142 146 let value = &self.rating; 143 147 if *value < 1i64 { 144 144 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 145 145 - field: "rating", 148 148 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 149 149 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 150 150 + "rating", 151 151 + ), 146 152 min: 1i64, 147 153 actual: *value, 148 154 }); ··· 151 157 if let Some(ref value) = self.title { 152 158 #[allow(unused_comparisons)] 153 159 if <str>::len(value.as_ref()) > 100usize { 154 154 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 155 155 - field: "title", 160 160 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 161 161 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 162 162 + "title", 163 163 + ), 156 164 max: 100usize, 157 165 actual: <str>::len(value.as_ref()), 158 166 });

+13 -7

crates/jacquard-api/src/beauty_cybernetic/trustcow/transaction.rs

··· 123 123 } 124 124 fn validate( 125 125 &self, 126 126 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 126 126 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 127 127 if let Some(ref value) = self.currency { 128 128 #[allow(unused_comparisons)] 129 129 if <str>::len(value.as_ref()) > 10usize { 130 130 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 131 131 - field: "currency", 130 130 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 131 131 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 132 132 + "currency", 133 133 + ), 132 134 max: 10usize, 133 135 actual: <str>::len(value.as_ref()), 134 136 }); ··· 137 139 if let Some(ref value) = self.description { 138 140 #[allow(unused_comparisons)] 139 141 if <str>::len(value.as_ref()) > 500usize { 140 140 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 141 141 - field: "description", 142 142 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 143 143 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 144 144 + "description", 145 145 + ), 142 146 max: 500usize, 143 147 actual: <str>::len(value.as_ref()), 144 148 }); ··· 148 152 let value = &self.transaction_id; 149 153 #[allow(unused_comparisons)] 150 154 if <str>::len(value.as_ref()) > 128usize { 151 151 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 152 152 - field: "transaction_id", 155 155 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 156 156 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 157 157 + "transaction_id", 158 158 + ), 153 159 max: 128usize, 154 160 actual: <str>::len(value.as_ref()), 155 161 });

+5 -3

crates/jacquard-api/src/beauty_cybernetic/trustcow/warrant.rs

··· 119 119 } 120 120 fn validate( 121 121 &self, 122 122 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 122 122 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 123 123 if let Some(ref value) = self.description { 124 124 #[allow(unused_comparisons)] 125 125 if <str>::len(value.as_ref()) > 300usize { 126 126 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 127 127 - field: "description", 126 126 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 127 127 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 128 128 + "description", 129 129 + ), 128 130 max: 300usize, 129 131 actual: <str>::len(value.as_ref()), 130 132 });

+3 -3

crates/jacquard-api/src/blog_pckt/blog.rs

··· 119 119 } 120 120 fn validate( 121 121 &self, 122 122 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 122 122 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 123 123 Ok(()) 124 124 } 125 125 } ··· 434 434 } 435 435 fn validate( 436 436 &self, 437 437 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 437 437 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 438 438 Ok(()) 439 439 } 440 440 } ··· 475 475 } 476 476 fn validate( 477 477 &self, 478 478 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 478 478 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 479 479 Ok(()) 480 480 } 481 481 }

+1 -1

crates/jacquard-api/src/blog_pckt/post.rs

··· 124 124 } 125 125 fn validate( 126 126 &self, 127 127 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 127 127 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 128 128 Ok(()) 129 129 } 130 130 }

+13 -7

crates/jacquard-api/src/blog_pckt/publication.rs

··· 129 129 } 130 130 fn validate( 131 131 &self, 132 132 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 132 132 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 133 133 if let Some(ref value) = self.description { 134 134 #[allow(unused_comparisons)] 135 135 if <str>::len(value.as_ref()) > 2000usize { 136 136 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 137 137 - field: "description", 136 136 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 137 137 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 138 138 + "description", 139 139 + ), 138 140 max: 2000usize, 139 141 actual: <str>::len(value.as_ref()), 140 142 }); ··· 143 145 if let Some(ref value) = self.extensions { 144 146 #[allow(unused_comparisons)] 145 147 if value.len() > 10usize { 146 146 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 147 147 - field: "extensions", 148 148 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 149 149 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 150 150 + "extensions", 151 151 + ), 148 152 max: 10usize, 149 153 actual: value.len(), 150 154 }); ··· 154 158 let value = &self.name; 155 159 #[allow(unused_comparisons)] 156 160 if <str>::len(value.as_ref()) > 200usize { 157 157 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 158 158 - field: "name", 161 161 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 162 162 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 163 163 + "name", 164 164 + ), 159 165 max: 200usize, 160 166 actual: <str>::len(value.as_ref()), 161 167 });

+26 -14

crates/jacquard-api/src/blog_pckt/theme.rs

··· 105 105 } 106 106 fn validate( 107 107 &self, 108 108 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 108 108 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 109 109 if let Some(ref value) = self.font { 110 110 #[allow(unused_comparisons)] 111 111 if <str>::len(value.as_ref()) > 100usize { 112 112 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 113 113 - field: "font", 112 112 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 113 113 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 114 114 + "font", 115 115 + ), 114 116 max: 100usize, 115 117 actual: <str>::len(value.as_ref()), 116 118 }); ··· 359 361 } 360 362 fn validate( 361 363 &self, 362 362 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 364 364 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 363 365 { 364 366 let value = &self.accent; 365 367 #[allow(unused_comparisons)] 366 368 if <str>::len(value.as_ref()) > 7usize { 367 367 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 368 368 - field: "accent", 369 369 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 370 370 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 371 371 + "accent", 372 372 + ), 369 373 max: 7usize, 370 374 actual: <str>::len(value.as_ref()), 371 375 }); ··· 375 379 let value = &self.background; 376 380 #[allow(unused_comparisons)] 377 381 if <str>::len(value.as_ref()) > 7usize { 378 378 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 379 379 - field: "background", 382 382 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 383 383 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 384 384 + "background", 385 385 + ), 380 386 max: 7usize, 381 387 actual: <str>::len(value.as_ref()), 382 388 }); ··· 386 392 let value = &self.link; 387 393 #[allow(unused_comparisons)] 388 394 if <str>::len(value.as_ref()) > 7usize { 389 389 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 390 390 - field: "link", 395 395 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 396 396 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 397 397 + "link", 398 398 + ), 391 399 max: 7usize, 392 400 actual: <str>::len(value.as_ref()), 393 401 }); ··· 397 405 let value = &self.surface_hover; 398 406 #[allow(unused_comparisons)] 399 407 if <str>::len(value.as_ref()) > 7usize { 400 400 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 401 401 - field: "surface_hover", 408 408 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 409 409 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 410 410 + "surface_hover", 411 411 + ), 402 412 max: 7usize, 403 413 actual: <str>::len(value.as_ref()), 404 414 }); ··· 408 418 let value = &self.text; 409 419 #[allow(unused_comparisons)] 410 420 if <str>::len(value.as_ref()) > 7usize { 411 411 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 412 412 - field: "text", 421 421 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 422 422 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 423 423 + "text", 424 424 + ), 413 425 max: 7usize, 414 426 actual: <str>::len(value.as_ref()), 415 427 });

+1 -1

crates/jacquard-api/src/blue__2048.rs

··· 150 150 } 151 151 fn validate( 152 152 &self, 153 153 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 153 153 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 154 154 Ok(()) 155 155 } 156 156 }

+1 -1

crates/jacquard-api/src/blue__2048/game.rs

··· 108 108 } 109 109 fn validate( 110 110 &self, 111 111 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 111 111 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 112 112 Ok(()) 113 113 } 114 114 }

+2 -2

crates/jacquard-api/src/blue__2048/key.rs

··· 196 196 } 197 197 fn validate( 198 198 &self, 199 199 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 199 199 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 200 200 Ok(()) 201 201 } 202 202 } ··· 238 238 } 239 239 fn validate( 240 240 &self, 241 241 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 241 241 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 242 242 Ok(()) 243 243 } 244 244 }

+1 -1

crates/jacquard-api/src/blue__2048/key/game.rs

··· 98 98 } 99 99 fn validate( 100 100 &self, 101 101 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 101 101 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 102 102 Ok(()) 103 103 } 104 104 }

+1 -1

crates/jacquard-api/src/blue__2048/key/player/stats.rs

··· 98 98 } 99 99 fn validate( 100 100 &self, 101 101 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 101 101 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 102 102 Ok(()) 103 103 } 104 104 }

+1 -1

crates/jacquard-api/src/blue__2048/player/profile.rs

··· 100 100 } 101 101 fn validate( 102 102 &self, 103 103 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 103 103 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 104 104 Ok(()) 105 105 } 106 106 }

+1 -1

crates/jacquard-api/src/blue__2048/player/stats.rs

··· 112 112 } 113 113 fn validate( 114 114 &self, 115 115 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 115 115 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 116 116 Ok(()) 117 117 } 118 118 }

+1 -1

crates/jacquard-api/src/blue__2048/verification.rs

··· 195 195 } 196 196 fn validate( 197 197 &self, 198 198 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 198 198 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 199 199 Ok(()) 200 200 } 201 201 }

+1 -1

crates/jacquard-api/src/blue__2048/verification/game.rs

··· 102 102 } 103 103 fn validate( 104 104 &self, 105 105 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 105 105 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 106 106 Ok(()) 107 107 } 108 108 }

+1 -1

crates/jacquard-api/src/blue__2048/verification/stats.rs

··· 102 102 } 103 103 fn validate( 104 104 &self, 105 105 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 105 105 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 106 106 Ok(()) 107 107 } 108 108 }

+5 -3

crates/jacquard-api/src/blue_atplane/fav_client.rs

··· 98 98 } 99 99 fn validate( 100 100 &self, 101 101 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 101 101 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 102 102 { 103 103 let value = &self.fav_client; 104 104 #[allow(unused_comparisons)] 105 105 if <str>::len(value.as_ref()) > 32usize { 106 106 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 107 107 - field: "fav_client", 106 106 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 107 107 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 108 108 + "fav_client", 109 109 + ), 108 110 max: 32usize, 109 111 actual: <str>::len(value.as_ref()), 110 112 });

+2 -2

crates/jacquard-api/src/blue_linkat/board.rs

··· 162 162 } 163 163 fn validate( 164 164 &self, 165 165 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 165 165 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 166 166 Ok(()) 167 167 } 168 168 } ··· 259 259 } 260 260 fn validate( 261 261 &self, 262 262 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 262 262 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 263 263 Ok(()) 264 264 } 265 265 }

+30 -16

crates/jacquard-api/src/blue_rito/feed/bookmark.rs

··· 292 292 } 293 293 fn validate( 294 294 &self, 295 295 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 295 295 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 296 296 if let Some(ref value) = self.comment { 297 297 #[allow(unused_comparisons)] 298 298 if <str>::len(value.as_ref()) > 100000usize { 299 299 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 300 300 - field: "comment", 299 299 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 300 300 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 301 301 + "comment", 302 302 + ), 301 303 max: 100000usize, 302 304 actual: <str>::len(value.as_ref()), 303 305 }); ··· 311 313 ) 312 314 .count(); 313 315 if count > 10000usize { 314 314 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 315 315 - field: "comment", 316 316 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 317 317 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 318 318 + "comment", 319 319 + ), 316 320 max: 10000usize, 317 321 actual: count, 318 322 }); ··· 323 327 let value = &self.lang; 324 328 #[allow(unused_comparisons)] 325 329 if <str>::len(value.as_ref()) > 6usize { 326 326 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 327 327 - field: "lang", 330 330 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 331 331 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 332 332 + "lang", 333 333 + ), 328 334 max: 6usize, 329 335 actual: <str>::len(value.as_ref()), 330 336 }); ··· 334 340 let value = &self.title; 335 341 #[allow(unused_comparisons)] 336 342 if <str>::len(value.as_ref()) > 500usize { 337 337 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 338 338 - field: "title", 343 343 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 344 344 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 345 345 + "title", 346 346 + ), 339 347 max: 500usize, 340 348 actual: <str>::len(value.as_ref()), 341 349 }); ··· 350 358 ) 351 359 .count(); 352 360 if count > 50usize { 353 353 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 354 354 - field: "title", 361 361 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 362 362 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 363 363 + "title", 364 364 + ), 355 365 max: 50usize, 356 366 actual: count, 357 367 }); ··· 477 487 } 478 488 fn validate( 479 489 &self, 480 480 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 490 490 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 481 491 { 482 492 let value = &self.comments; 483 493 #[allow(unused_comparisons)] 484 494 if value.len() < 1usize { 485 485 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 486 486 - field: "comments", 495 495 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 496 496 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 497 497 + "comments", 498 498 + ), 487 499 min: 1usize, 488 500 actual: value.len(), 489 501 }); ··· 492 504 if let Some(ref value) = self.tags { 493 505 #[allow(unused_comparisons)] 494 506 if value.len() > 10usize { 495 495 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 496 496 - field: "tags", 507 507 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 508 508 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 509 509 + "tags", 510 510 + ), 497 511 max: 10usize, 498 512 actual: value.len(), 499 513 });

+1 -1

crates/jacquard-api/src/blue_rito/feed/like.rs

··· 97 97 } 98 98 fn validate( 99 99 &self, 100 100 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 100 100 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 101 101 Ok(()) 102 102 } 103 103 }

+1 -1

crates/jacquard-api/src/blue_rito/service/get_schema.rs

··· 191 191 } 192 192 fn validate( 193 193 &self, 194 194 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 194 194 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 195 195 Ok(()) 196 196 } 197 197 }

+1 -1

crates/jacquard-api/src/blue_rito/service/schema.rs

··· 97 97 } 98 98 fn validate( 99 99 &self, 100 100 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 100 100 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 101 101 Ok(()) 102 102 } 103 103 }

+2 -2

crates/jacquard-api/src/blue_zio/atfile/finger.rs

··· 180 180 } 181 181 fn validate( 182 182 &self, 183 183 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 183 183 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 184 184 Ok(()) 185 185 } 186 186 } ··· 225 225 } 226 226 fn validate( 227 227 &self, 228 228 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 228 228 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 229 229 Ok(()) 230 230 } 231 231 }

+1 -1

crates/jacquard-api/src/blue_zio/atfile/lock.rs

··· 97 97 } 98 98 fn validate( 99 99 &self, 100 100 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 100 100 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 101 101 Ok(()) 102 102 } 103 103 }

+1 -1

crates/jacquard-api/src/blue_zio/atfile/meta.rs

··· 83 83 } 84 84 fn validate( 85 85 &self, 86 86 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 86 86 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 87 87 Ok(()) 88 88 } 89 89 }

+61 -33

crates/jacquard-api/src/buzz_bookhive.rs

··· 799 799 } 800 800 fn validate( 801 801 &self, 802 802 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 802 802 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 803 803 Ok(()) 804 804 } 805 805 } ··· 849 849 } 850 850 fn validate( 851 851 &self, 852 852 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 852 852 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 853 853 { 854 854 let value = &self.comment; 855 855 #[allow(unused_comparisons)] 856 856 if <str>::len(value.as_ref()) > 100000usize { 857 857 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 858 858 - field: "comment", 857 857 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 858 858 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 859 859 + "comment", 860 860 + ), 859 861 max: 100000usize, 860 862 actual: <str>::len(value.as_ref()), 861 863 }); ··· 870 872 ) 871 873 .count(); 872 874 if count > 10000usize { 873 873 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 874 874 - field: "comment", 875 875 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 876 876 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 877 877 + "comment", 878 878 + ), 875 879 max: 10000usize, 876 880 actual: count, 877 881 }); ··· 961 965 } 962 966 fn validate( 963 967 &self, 964 964 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 968 968 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 965 969 { 966 970 let value = &self.books_read; 967 971 if *value < 0i64 { 968 968 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 969 969 - field: "books_read", 972 972 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 973 973 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 974 974 + "books_read", 975 975 + ), 970 976 min: 0i64, 971 977 actual: *value, 972 978 }); ··· 975 981 { 976 982 let value = &self.reviews; 977 983 if *value < 0i64 { 978 978 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 979 979 - field: "reviews", 984 984 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 985 985 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 986 986 + "reviews", 987 987 + ), 980 988 min: 0i64, 981 989 actual: *value, 982 990 }); ··· 1049 1057 } 1050 1058 fn validate( 1051 1059 &self, 1052 1052 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1060 1060 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1053 1061 Ok(()) 1054 1062 } 1055 1063 } ··· 1133 1141 } 1134 1142 fn validate( 1135 1143 &self, 1136 1136 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1144 1144 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1137 1145 { 1138 1146 let value = &self.authors; 1139 1147 #[allow(unused_comparisons)] 1140 1148 if <str>::len(value.as_ref()) > 2048usize { 1141 1141 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1142 1142 - field: "authors", 1149 1149 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 1150 1150 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1151 1151 + "authors", 1152 1152 + ), 1143 1153 max: 2048usize, 1144 1154 actual: <str>::len(value.as_ref()), 1145 1155 }); ··· 1149 1159 let value = &self.authors; 1150 1160 #[allow(unused_comparisons)] 1151 1161 if <str>::len(value.as_ref()) < 1usize { 1152 1152 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 1153 1153 - field: "authors", 1162 1162 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 1163 1163 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1164 1164 + "authors", 1165 1165 + ), 1154 1166 min: 1usize, 1155 1167 actual: <str>::len(value.as_ref()), 1156 1168 }); ··· 1159 1171 if let Some(ref value) = self.description { 1160 1172 #[allow(unused_comparisons)] 1161 1173 if <str>::len(value.as_ref()) > 5000usize { 1162 1162 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1163 1163 - field: "description", 1174 1174 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 1175 1175 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1176 1176 + "description", 1177 1177 + ), 1164 1178 max: 5000usize, 1165 1179 actual: <str>::len(value.as_ref()), 1166 1180 }); ··· 1168 1182 } 1169 1183 if let Some(ref value) = self.rating { 1170 1184 if *value > 1000i64 { 1171 1171 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 1172 1172 - field: "rating", 1185 1185 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 1186 1186 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1187 1187 + "rating", 1188 1188 + ), 1173 1189 max: 1000i64, 1174 1190 actual: *value, 1175 1191 }); ··· 1177 1193 } 1178 1194 if let Some(ref value) = self.rating { 1179 1195 if *value < 0i64 { 1180 1180 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1181 1181 - field: "rating", 1196 1196 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1197 1197 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1198 1198 + "rating", 1199 1199 + ), 1182 1200 min: 0i64, 1183 1201 actual: *value, 1184 1202 }); ··· 1192 1210 ) 1193 1211 .count(); 1194 1212 if count > 15000usize { 1195 1195 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1196 1196 - field: "review", 1213 1213 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 1214 1214 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1215 1215 + "review", 1216 1216 + ), 1197 1217 max: 15000usize, 1198 1218 actual: count, 1199 1219 }); ··· 1202 1222 } 1203 1223 if let Some(ref value) = self.stars { 1204 1224 if *value > 10i64 { 1205 1205 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 1206 1206 - field: "stars", 1225 1225 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 1226 1226 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1227 1227 + "stars", 1228 1228 + ), 1207 1229 max: 10i64, 1208 1230 actual: *value, 1209 1231 }); ··· 1211 1233 } 1212 1234 if let Some(ref value) = self.stars { 1213 1235 if *value < 1i64 { 1214 1214 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1215 1215 - field: "stars", 1236 1236 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1237 1237 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1238 1238 + "stars", 1239 1239 + ), 1216 1240 min: 1i64, 1217 1241 actual: *value, 1218 1242 }); ··· 1222 1246 let value = &self.title; 1223 1247 #[allow(unused_comparisons)] 1224 1248 if <str>::len(value.as_ref()) > 512usize { 1225 1225 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1226 1226 - field: "title", 1249 1249 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 1250 1250 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1251 1251 + "title", 1252 1252 + ), 1227 1253 max: 512usize, 1228 1254 actual: <str>::len(value.as_ref()), 1229 1255 }); ··· 1233 1259 let value = &self.title; 1234 1260 #[allow(unused_comparisons)] 1235 1261 if <str>::len(value.as_ref()) < 1usize { 1236 1236 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 1237 1237 - field: "title", 1262 1262 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 1263 1263 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1264 1264 + "title", 1265 1265 + ), 1238 1266 min: 1usize, 1239 1267 actual: <str>::len(value.as_ref()), 1240 1268 });

+29 -15

crates/jacquard-api/src/buzz_bookhive/book.rs

··· 133 133 } 134 134 fn validate( 135 135 &self, 136 136 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 136 136 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 137 137 { 138 138 let value = &self.authors; 139 139 #[allow(unused_comparisons)] 140 140 if <str>::len(value.as_ref()) > 2048usize { 141 141 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 142 142 - field: "authors", 141 141 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 142 142 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 143 143 + "authors", 144 144 + ), 143 145 max: 2048usize, 144 146 actual: <str>::len(value.as_ref()), 145 147 }); ··· 149 151 let value = &self.authors; 150 152 #[allow(unused_comparisons)] 151 153 if <str>::len(value.as_ref()) < 1usize { 152 152 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 153 153 - field: "authors", 154 154 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 155 155 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 156 156 + "authors", 157 157 + ), 154 158 min: 1usize, 155 159 actual: <str>::len(value.as_ref()), 156 160 }); ··· 164 168 ) 165 169 .count(); 166 170 if count > 15000usize { 167 167 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 168 168 - field: "review", 171 171 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 172 172 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 173 173 + "review", 174 174 + ), 169 175 max: 15000usize, 170 176 actual: count, 171 177 }); ··· 174 180 } 175 181 if let Some(ref value) = self.stars { 176 182 if *value > 10i64 { 177 177 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 178 178 - field: "stars", 183 183 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 184 184 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 185 185 + "stars", 186 186 + ), 179 187 max: 10i64, 180 188 actual: *value, 181 189 }); ··· 183 191 } 184 192 if let Some(ref value) = self.stars { 185 193 if *value < 1i64 { 186 186 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 187 187 - field: "stars", 194 194 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 195 195 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 196 196 + "stars", 197 197 + ), 188 198 min: 1i64, 189 199 actual: *value, 190 200 }); ··· 194 204 let value = &self.title; 195 205 #[allow(unused_comparisons)] 196 206 if <str>::len(value.as_ref()) > 512usize { 197 197 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 198 198 - field: "title", 207 207 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 208 208 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 209 209 + "title", 210 210 + ), 199 211 max: 512usize, 200 212 actual: <str>::len(value.as_ref()), 201 213 }); ··· 205 217 let value = &self.title; 206 218 #[allow(unused_comparisons)] 207 219 if <str>::len(value.as_ref()) < 1usize { 208 208 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 209 209 - field: "title", 220 220 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 221 221 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 222 222 + "title", 223 223 + ), 210 224 min: 1usize, 211 225 actual: <str>::len(value.as_ref()), 212 226 });

+9 -5

crates/jacquard-api/src/buzz_bookhive/buzz.rs

··· 104 104 } 105 105 fn validate( 106 106 &self, 107 107 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 107 107 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 108 108 { 109 109 let value = &self.comment; 110 110 #[allow(unused_comparisons)] 111 111 if <str>::len(value.as_ref()) > 100000usize { 112 112 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 113 113 - field: "comment", 112 112 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 113 113 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 114 114 + "comment", 115 115 + ), 114 116 max: 100000usize, 115 117 actual: <str>::len(value.as_ref()), 116 118 }); ··· 125 127 ) 126 128 .count(); 127 129 if count > 10000usize { 128 128 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 129 129 - field: "comment", 130 130 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 131 131 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 132 132 + "comment", 133 133 + ), 130 134 max: 10000usize, 131 135 actual: count, 132 136 });

+29 -15

crates/jacquard-api/src/buzz_bookhive/hive_book.rs

··· 145 145 } 146 146 fn validate( 147 147 &self, 148 148 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 148 148 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 149 149 { 150 150 let value = &self.authors; 151 151 #[allow(unused_comparisons)] 152 152 if <str>::len(value.as_ref()) > 512usize { 153 153 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 154 154 - field: "authors", 153 153 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 154 154 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 155 155 + "authors", 156 156 + ), 155 157 max: 512usize, 156 158 actual: <str>::len(value.as_ref()), 157 159 }); ··· 161 163 let value = &self.authors; 162 164 #[allow(unused_comparisons)] 163 165 if <str>::len(value.as_ref()) < 1usize { 164 164 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 165 165 - field: "authors", 166 166 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 167 167 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 168 168 + "authors", 169 169 + ), 166 170 min: 1usize, 167 171 actual: <str>::len(value.as_ref()), 168 172 }); ··· 171 175 if let Some(ref value) = self.description { 172 176 #[allow(unused_comparisons)] 173 177 if <str>::len(value.as_ref()) > 5000usize { 174 174 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 175 175 - field: "description", 178 178 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 179 179 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 180 180 + "description", 181 181 + ), 176 182 max: 5000usize, 177 183 actual: <str>::len(value.as_ref()), 178 184 }); ··· 180 186 } 181 187 if let Some(ref value) = self.rating { 182 188 if *value > 1000i64 { 183 183 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 184 184 - field: "rating", 189 189 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 190 190 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 191 191 + "rating", 192 192 + ), 185 193 max: 1000i64, 186 194 actual: *value, 187 195 }); ··· 189 197 } 190 198 if let Some(ref value) = self.rating { 191 199 if *value < 0i64 { 192 192 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 193 193 - field: "rating", 200 200 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 201 201 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 202 202 + "rating", 203 203 + ), 194 204 min: 0i64, 195 205 actual: *value, 196 206 }); ··· 200 210 let value = &self.title; 201 211 #[allow(unused_comparisons)] 202 212 if <str>::len(value.as_ref()) > 512usize { 203 203 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 204 204 - field: "title", 213 213 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 214 214 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 215 215 + "title", 216 216 + ), 205 217 max: 512usize, 206 218 actual: <str>::len(value.as_ref()), 207 219 }); ··· 211 223 let value = &self.title; 212 224 #[allow(unused_comparisons)] 213 225 if <str>::len(value.as_ref()) < 1usize { 214 214 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 215 215 - field: "title", 226 226 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 227 227 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 228 228 + "title", 229 229 + ), 216 230 min: 1usize, 217 231 actual: <str>::len(value.as_ref()), 218 232 });

+9 -5

crates/jacquard-api/src/chat_bsky/actor.rs

··· 224 224 } 225 225 fn validate( 226 226 &self, 227 227 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 227 227 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 228 228 if let Some(ref value) = self.display_name { 229 229 #[allow(unused_comparisons)] 230 230 if <str>::len(value.as_ref()) > 640usize { 231 231 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 232 232 - field: "display_name", 231 231 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 232 232 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 233 233 + "display_name", 234 234 + ), 233 235 max: 640usize, 234 236 actual: <str>::len(value.as_ref()), 235 237 }); ··· 243 245 ) 244 246 .count(); 245 247 if count > 64usize { 246 246 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 247 247 - field: "display_name", 248 248 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 249 249 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 250 250 + "display_name", 251 251 + ), 248 252 max: 64usize, 249 253 actual: count, 250 254 });

+1 -1

crates/jacquard-api/src/chat_bsky/actor/declaration.rs

··· 97 97 } 98 98 fn validate( 99 99 &self, 100 100 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 100 100 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 101 101 Ok(()) 102 102 } 103 103 }

+35 -27

crates/jacquard-api/src/chat_bsky/convo.rs

··· 1296 1296 } 1297 1297 fn validate( 1298 1298 &self, 1299 1299 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1299 1299 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1300 1300 Ok(()) 1301 1301 } 1302 1302 } ··· 1337 1337 } 1338 1338 fn validate( 1339 1339 &self, 1340 1340 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1340 1340 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1341 1341 Ok(()) 1342 1342 } 1343 1343 } ··· 1373 1373 } 1374 1374 fn validate( 1375 1375 &self, 1376 1376 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1376 1376 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1377 1377 Ok(()) 1378 1378 } 1379 1379 } ··· 1434 1434 } 1435 1435 fn validate( 1436 1436 &self, 1437 1437 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1437 1437 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1438 1438 Ok(()) 1439 1439 } 1440 1440 } ··· 1470 1470 } 1471 1471 fn validate( 1472 1472 &self, 1473 1473 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1473 1473 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1474 1474 Ok(()) 1475 1475 } 1476 1476 } ··· 1529 1529 } 1530 1530 fn validate( 1531 1531 &self, 1532 1532 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1532 1532 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1533 1533 Ok(()) 1534 1534 } 1535 1535 } ··· 1588 1588 } 1589 1589 fn validate( 1590 1590 &self, 1591 1591 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1591 1591 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1592 1592 Ok(()) 1593 1593 } 1594 1594 } ··· 1624 1624 } 1625 1625 fn validate( 1626 1626 &self, 1627 1627 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1627 1627 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1628 1628 Ok(()) 1629 1629 } 1630 1630 } ··· 1660 1660 } 1661 1661 fn validate( 1662 1662 &self, 1663 1663 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1663 1663 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1664 1664 Ok(()) 1665 1665 } 1666 1666 } ··· 1719 1719 } 1720 1720 fn validate( 1721 1721 &self, 1722 1722 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1722 1722 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1723 1723 Ok(()) 1724 1724 } 1725 1725 } ··· 1780 1780 } 1781 1781 fn validate( 1782 1782 &self, 1783 1783 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1783 1783 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1784 1784 Ok(()) 1785 1785 } 1786 1786 } ··· 1816 1816 } 1817 1817 fn validate( 1818 1818 &self, 1819 1819 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1819 1819 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1820 1820 Ok(()) 1821 1821 } 1822 1822 } ··· 1852 1852 } 1853 1853 fn validate( 1854 1854 &self, 1855 1855 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1855 1855 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1856 1856 Ok(()) 1857 1857 } 1858 1858 } ··· 1893 1893 } 1894 1894 fn validate( 1895 1895 &self, 1896 1896 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1896 1896 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1897 1897 { 1898 1898 let value = &self.text; 1899 1899 #[allow(unused_comparisons)] 1900 1900 if <str>::len(value.as_ref()) > 10000usize { 1901 1901 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1902 1902 - field: "text", 1901 1901 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 1902 1902 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1903 1903 + "text", 1904 1904 + ), 1903 1905 max: 10000usize, 1904 1906 actual: <str>::len(value.as_ref()), 1905 1907 }); ··· 1914 1916 ) 1915 1917 .count(); 1916 1918 if count > 1000usize { 1917 1917 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1918 1918 - field: "text", 1919 1919 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 1920 1920 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1921 1921 + "text", 1922 1922 + ), 1919 1923 max: 1000usize, 1920 1924 actual: count, 1921 1925 }); ··· 1961 1965 } 1962 1966 fn validate( 1963 1967 &self, 1964 1964 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1968 1968 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1965 1969 Ok(()) 1966 1970 } 1967 1971 } ··· 2019 2023 } 2020 2024 fn validate( 2021 2025 &self, 2022 2022 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2026 2026 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2023 2027 { 2024 2028 let value = &self.text; 2025 2029 #[allow(unused_comparisons)] 2026 2030 if <str>::len(value.as_ref()) > 10000usize { 2027 2027 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2028 2028 - field: "text", 2031 2031 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 2032 2032 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 2033 2033 + "text", 2034 2034 + ), 2029 2035 max: 10000usize, 2030 2036 actual: <str>::len(value.as_ref()), 2031 2037 }); ··· 2040 2046 ) 2041 2047 .count(); 2042 2048 if count > 1000usize { 2043 2043 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 2044 2044 - field: "text", 2049 2049 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 2050 2050 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 2051 2051 + "text", 2052 2052 + ), 2045 2053 max: 1000usize, 2046 2054 actual: count, 2047 2055 }); ··· 2081 2089 } 2082 2090 fn validate( 2083 2091 &self, 2084 2084 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2092 2092 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2085 2093 Ok(()) 2086 2094 } 2087 2095 } ··· 2119 2127 } 2120 2128 fn validate( 2121 2129 &self, 2122 2122 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2130 2130 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2123 2131 Ok(()) 2124 2132 } 2125 2133 } ··· 2153 2161 } 2154 2162 fn validate( 2155 2163 &self, 2156 2156 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2164 2164 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2157 2165 Ok(()) 2158 2166 } 2159 2167 }

+1 -1

crates/jacquard-api/src/chat_bsky/convo/send_message_batch.rs

··· 137 137 } 138 138 fn validate( 139 139 &self, 140 140 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 140 140 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 141 141 Ok(()) 142 142 } 143 143 }

+1 -1

crates/jacquard-api/src/chat_bsky/moderation/get_actor_metadata.rs

··· 226 226 } 227 227 fn validate( 228 228 &self, 229 229 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 229 229 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 230 230 Ok(()) 231 231 } 232 232 }

+22 -12

crates/jacquard-api/src/club_stellz/evm/address_control.rs

··· 295 295 } 296 296 fn validate( 297 297 &self, 298 298 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 298 298 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 299 299 Ok(()) 300 300 } 301 301 } ··· 354 354 } 355 355 fn validate( 356 356 &self, 357 357 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 357 357 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 358 358 { 359 359 let value = &self.address; 360 360 #[allow(unused_comparisons)] 361 361 if <str>::len(value.as_ref()) > 42usize { 362 362 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 363 363 - field: "address", 362 362 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 363 363 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 364 364 + "address", 365 365 + ), 364 366 max: 42usize, 365 367 actual: <str>::len(value.as_ref()), 366 368 }); ··· 370 372 let value = &self.address; 371 373 #[allow(unused_comparisons)] 372 374 if <str>::len(value.as_ref()) < 42usize { 373 373 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 374 374 - field: "address", 375 375 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 376 376 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 377 377 + "address", 378 378 + ), 375 379 min: 42usize, 376 380 actual: <str>::len(value.as_ref()), 377 381 }); ··· 381 385 let value = &self.nonce; 382 386 #[allow(unused_comparisons)] 383 387 if <str>::len(value.as_ref()) > 256usize { 384 384 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 385 385 - field: "nonce", 388 388 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 389 389 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 390 390 + "nonce", 391 391 + ), 386 392 max: 256usize, 387 393 actual: <str>::len(value.as_ref()), 388 394 }); ··· 392 398 let value = &self.nonce; 393 399 #[allow(unused_comparisons)] 394 400 if <str>::len(value.as_ref()) < 8usize { 395 395 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 396 396 - field: "nonce", 401 401 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 402 402 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 403 403 + "nonce", 404 404 + ), 397 405 min: 8usize, 398 406 actual: <str>::len(value.as_ref()), 399 407 }); ··· 403 411 let value = &self.statement; 404 412 #[allow(unused_comparisons)] 405 413 if <str>::len(value.as_ref()) < 78usize { 406 406 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 407 407 - field: "statement", 414 414 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 415 415 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 416 416 + "statement", 417 417 + ), 408 418 min: 78usize, 409 419 actual: <str>::len(value.as_ref()), 410 420 });

+5 -5

crates/jacquard-api/src/com_atproto/admin.rs

··· 496 496 } 497 497 fn validate( 498 498 &self, 499 499 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 499 499 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 500 500 Ok(()) 501 501 } 502 502 } ··· 536 536 } 537 537 fn validate( 538 538 &self, 539 539 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 539 539 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 540 540 Ok(()) 541 541 } 542 542 } ··· 570 570 } 571 571 fn validate( 572 572 &self, 573 573 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 573 573 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 574 574 Ok(()) 575 575 } 576 576 } ··· 607 607 } 608 608 fn validate( 609 609 &self, 610 610 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 610 610 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 611 611 Ok(()) 612 612 } 613 613 } ··· 643 643 } 644 644 fn validate( 645 645 &self, 646 646 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 646 646 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 647 647 Ok(()) 648 648 } 649 649 }

+1 -1

crates/jacquard-api/src/com_atproto/identity.rs

··· 128 128 } 129 129 fn validate( 130 130 &self, 131 131 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 131 131 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 132 132 Ok(()) 133 133 } 134 134 }

+41 -23

crates/jacquard-api/src/com_atproto/label.rs

··· 559 559 } 560 560 fn validate( 561 561 &self, 562 562 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 562 562 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 563 563 { 564 564 let value = &self.val; 565 565 #[allow(unused_comparisons)] 566 566 if <str>::len(value.as_ref()) > 128usize { 567 567 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 568 568 - field: "val", 567 567 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 568 568 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 569 569 + "val", 570 570 + ), 569 571 max: 128usize, 570 572 actual: <str>::len(value.as_ref()), 571 573 }); ··· 747 749 } 748 750 fn validate( 749 751 &self, 750 750 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 752 752 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 751 753 { 752 754 let value = &self.identifier; 753 755 #[allow(unused_comparisons)] 754 756 if <str>::len(value.as_ref()) > 100usize { 755 755 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 756 756 - field: "identifier", 757 757 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 758 758 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 759 759 + "identifier", 760 760 + ), 757 761 max: 100usize, 758 762 actual: <str>::len(value.as_ref()), 759 763 }); ··· 768 772 ) 769 773 .count(); 770 774 if count > 100usize { 771 771 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 772 772 - field: "identifier", 775 775 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 776 776 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 777 777 + "identifier", 778 778 + ), 773 779 max: 100usize, 774 780 actual: count, 775 781 }); ··· 818 824 } 819 825 fn validate( 820 826 &self, 821 821 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 827 827 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 822 828 { 823 829 let value = &self.description; 824 830 #[allow(unused_comparisons)] 825 831 if <str>::len(value.as_ref()) > 100000usize { 826 826 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 827 827 - field: "description", 832 832 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 833 833 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 834 834 + "description", 835 835 + ), 828 836 max: 100000usize, 829 837 actual: <str>::len(value.as_ref()), 830 838 }); ··· 839 847 ) 840 848 .count(); 841 849 if count > 10000usize { 842 842 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 843 843 - field: "description", 850 850 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 851 851 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 852 852 + "description", 853 853 + ), 844 854 max: 10000usize, 845 855 actual: count, 846 856 }); ··· 851 861 let value = &self.name; 852 862 #[allow(unused_comparisons)] 853 863 if <str>::len(value.as_ref()) > 640usize { 854 854 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 855 855 - field: "name", 864 864 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 865 865 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 866 866 + "name", 867 867 + ), 856 868 max: 640usize, 857 869 actual: <str>::len(value.as_ref()), 858 870 }); ··· 867 879 ) 868 880 .count(); 869 881 if count > 64usize { 870 870 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 871 871 - field: "name", 882 882 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 883 883 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 884 884 + "name", 885 885 + ), 872 886 max: 64usize, 873 887 actual: count, 874 888 }); ··· 910 924 } 911 925 fn validate( 912 926 &self, 913 913 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 927 927 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 914 928 { 915 929 let value = &self.val; 916 930 #[allow(unused_comparisons)] 917 931 if <str>::len(value.as_ref()) > 128usize { 918 918 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 919 919 - field: "val", 932 932 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 933 933 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 934 934 + "val", 935 935 + ), 920 936 max: 128usize, 921 937 actual: <str>::len(value.as_ref()), 922 938 }); ··· 956 972 } 957 973 fn validate( 958 974 &self, 959 959 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 975 975 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 960 976 { 961 977 let value = &self.values; 962 978 #[allow(unused_comparisons)] 963 979 if value.len() > 10usize { 964 964 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 965 965 - field: "values", 980 980 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 981 981 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 982 982 + "values", 983 983 + ), 966 984 max: 10usize, 967 985 actual: value.len(), 968 986 });

+2 -2

crates/jacquard-api/src/com_atproto/label/subscribe_labels.rs

··· 171 171 } 172 172 fn validate( 173 173 &self, 174 174 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 174 174 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 175 175 Ok(()) 176 176 } 177 177 } ··· 206 206 } 207 207 fn validate( 208 208 &self, 209 209 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 209 209 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 210 210 Ok(()) 211 211 } 212 212 }

+1 -1

crates/jacquard-api/src/com_atproto/lexicon/schema.rs

··· 96 96 } 97 97 fn validate( 98 98 &self, 99 99 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 99 99 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 100 100 Ok(()) 101 101 } 102 102 }

+1 -1

crates/jacquard-api/src/com_atproto/moderation/create_report.rs

··· 309 309 } 310 310 fn validate( 311 311 &self, 312 312 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 312 312 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 313 313 Ok(()) 314 314 } 315 315 }

+1 -1

crates/jacquard-api/src/com_atproto/repo.rs

··· 114 114 } 115 115 fn validate( 116 116 &self, 117 117 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 117 117 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 118 118 Ok(()) 119 119 } 120 120 }

+10 -8

crates/jacquard-api/src/com_atproto/repo/apply_writes.rs

··· 506 506 } 507 507 fn validate( 508 508 &self, 509 509 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 509 509 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 510 510 if let Some(ref value) = self.rkey { 511 511 #[allow(unused_comparisons)] 512 512 if <str>::len(value.as_ref()) > 512usize { 513 513 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 514 514 - field: "rkey", 513 513 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 514 514 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 515 515 + "rkey", 516 516 + ), 515 517 max: 512usize, 516 518 actual: <str>::len(value.as_ref()), 517 519 }); ··· 556 558 } 557 559 fn validate( 558 560 &self, 559 559 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 561 561 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 560 562 Ok(()) 561 563 } 562 564 } ··· 595 597 } 596 598 fn validate( 597 599 &self, 598 598 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 600 600 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 599 601 Ok(()) 600 602 } 601 603 } ··· 625 627 } 626 628 fn validate( 627 629 &self, 628 628 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 630 630 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 629 631 Ok(()) 630 632 } 631 633 } ··· 829 831 } 830 832 fn validate( 831 833 &self, 832 832 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 834 834 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 833 835 Ok(()) 834 836 } 835 837 } ··· 869 871 } 870 872 fn validate( 871 873 &self, 872 872 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 874 874 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 873 875 Ok(()) 874 876 } 875 877 }

+1 -1

crates/jacquard-api/src/com_atproto/repo/list_missing_blobs.rs

··· 217 217 } 218 218 fn validate( 219 219 &self, 220 220 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 220 220 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 221 221 Ok(()) 222 222 } 223 223 }

+1 -1

crates/jacquard-api/src/com_atproto/repo/list_records.rs

··· 287 287 } 288 288 fn validate( 289 289 &self, 290 290 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 290 290 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 291 291 Ok(()) 292 292 } 293 293 }

+1 -1

crates/jacquard-api/src/com_atproto/repo/strong_ref.rs

··· 103 103 } 104 104 fn validate( 105 105 &self, 106 106 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 106 106 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 107 107 Ok(()) 108 108 } 109 109 }

+2 -2

crates/jacquard-api/src/com_atproto/server.rs

··· 265 265 } 266 266 fn validate( 267 267 &self, 268 268 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 268 268 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 269 269 Ok(()) 270 270 } 271 271 } ··· 300 300 } 301 301 fn validate( 302 302 &self, 303 303 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 303 303 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 304 304 Ok(()) 305 305 } 306 306 }

+1 -1

crates/jacquard-api/src/com_atproto/server/create_app_password.rs

··· 197 197 } 198 198 fn validate( 199 199 &self, 200 200 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 200 200 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 201 201 Ok(()) 202 202 } 203 203 }

+1 -1

crates/jacquard-api/src/com_atproto/server/create_invite_codes.rs

··· 189 189 } 190 190 fn validate( 191 191 &self, 192 192 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 192 192 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 193 193 Ok(()) 194 194 } 195 195 }

+2 -2

crates/jacquard-api/src/com_atproto/server/describe_server.rs

··· 138 138 } 139 139 fn validate( 140 140 &self, 141 141 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 141 141 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 142 142 Ok(()) 143 143 } 144 144 } ··· 176 176 } 177 177 fn validate( 178 178 &self, 179 179 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 179 179 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 180 180 Ok(()) 181 181 } 182 182 }

+1 -1

crates/jacquard-api/src/com_atproto/server/list_app_passwords.rs

··· 125 125 } 126 126 fn validate( 127 127 &self, 128 128 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 128 128 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 129 129 Ok(()) 130 130 } 131 131 }

+1 -1

crates/jacquard-api/src/com_atproto/sync/list_hosts.rs

··· 172 172 } 173 173 fn validate( 174 174 &self, 175 175 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 175 175 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 176 176 Ok(()) 177 177 } 178 178 }

+1 -1

crates/jacquard-api/src/com_atproto/sync/list_repos.rs

··· 274 274 } 275 275 fn validate( 276 276 &self, 277 277 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 277 277 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 278 278 Ok(()) 279 279 } 280 280 }

+1 -1

crates/jacquard-api/src/com_atproto/sync/list_repos_by_collection.rs

··· 220 220 } 221 221 fn validate( 222 222 &self, 223 223 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 223 223 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 224 224 Ok(()) 225 225 } 226 226 }

+10 -8

crates/jacquard-api/src/com_atproto/sync/subscribe_repos.rs

··· 675 675 } 676 676 fn validate( 677 677 &self, 678 678 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 678 678 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 679 679 Ok(()) 680 680 } 681 681 } ··· 737 737 } 738 738 fn validate( 739 739 &self, 740 740 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 740 740 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 741 741 { 742 742 let value = &self.ops; 743 743 #[allow(unused_comparisons)] 744 744 if value.len() > 200usize { 745 745 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 746 746 - field: "ops", 745 745 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 746 746 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 747 747 + "ops", 748 748 + ), 747 749 max: 200usize, 748 750 actual: value.len(), 749 751 }); ··· 790 792 } 791 793 fn validate( 792 794 &self, 793 793 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 795 795 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 794 796 Ok(()) 795 797 } 796 798 } ··· 827 829 } 828 830 fn validate( 829 831 &self, 830 830 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 832 832 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 831 833 Ok(()) 832 834 } 833 835 } ··· 1027 1029 } 1028 1030 fn validate( 1029 1031 &self, 1030 1030 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1032 1032 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1031 1033 Ok(()) 1032 1034 } 1033 1035 } ··· 1073 1075 } 1074 1076 fn validate( 1075 1077 &self, 1076 1076 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1078 1078 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1077 1079 Ok(()) 1078 1080 } 1079 1081 }

+3 -3

crates/jacquard-api/src/com_atproto/temp/check_handle_availability.rs

··· 370 370 } 371 371 fn validate( 372 372 &self, 373 373 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 373 373 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 374 374 Ok(()) 375 375 } 376 376 } ··· 408 408 } 409 409 fn validate( 410 410 &self, 411 411 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 411 411 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 412 412 Ok(()) 413 413 } 414 414 } ··· 446 446 } 447 447 fn validate( 448 448 &self, 449 449 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 449 449 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 450 450 Ok(()) 451 451 } 452 452 }

+25 -13

crates/jacquard-api/src/com_crabdance/nandi/post.rs

··· 119 119 } 120 120 fn validate( 121 121 &self, 122 122 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 122 122 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 123 123 { 124 124 let value = &self.content; 125 125 #[allow(unused_comparisons)] 126 126 if <str>::len(value.as_ref()) > 10000usize { 127 127 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 128 128 - field: "content", 127 127 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 128 128 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 129 129 + "content", 130 130 + ), 129 131 max: 10000usize, 130 132 actual: <str>::len(value.as_ref()), 131 133 }); ··· 135 137 let value = &self.content; 136 138 #[allow(unused_comparisons)] 137 139 if <str>::len(value.as_ref()) < 1usize { 138 138 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 139 139 - field: "content", 140 140 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 141 141 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 142 142 + "content", 143 143 + ), 140 144 min: 1usize, 141 145 actual: <str>::len(value.as_ref()), 142 146 }); ··· 145 149 if let Some(ref value) = self.summary { 146 150 #[allow(unused_comparisons)] 147 151 if <str>::len(value.as_ref()) > 500usize { 148 148 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 149 149 - field: "summary", 152 152 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 153 153 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 154 154 + "summary", 155 155 + ), 150 156 max: 500usize, 151 157 actual: <str>::len(value.as_ref()), 152 158 }); ··· 155 161 if let Some(ref value) = self.tags { 156 162 #[allow(unused_comparisons)] 157 163 if value.len() > 10usize { 158 158 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 159 159 - field: "tags", 164 164 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 165 165 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 166 166 + "tags", 167 167 + ), 160 168 max: 10usize, 161 169 actual: value.len(), 162 170 }); ··· 166 174 let value = &self.title; 167 175 #[allow(unused_comparisons)] 168 176 if <str>::len(value.as_ref()) > 200usize { 169 169 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 170 170 - field: "title", 177 177 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 178 178 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 179 179 + "title", 180 180 + ), 171 181 max: 200usize, 172 182 actual: <str>::len(value.as_ref()), 173 183 }); ··· 177 187 let value = &self.title; 178 188 #[allow(unused_comparisons)] 179 189 if <str>::len(value.as_ref()) < 1usize { 180 180 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 181 181 - field: "title", 190 190 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 191 191 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 192 192 + "title", 193 193 + ), 182 194 min: 1usize, 183 195 actual: <str>::len(value.as_ref()), 184 196 });

+7 -5

crates/jacquard-api/src/com_shinolabs/pinksea/app_view_defs.rs

··· 324 324 } 325 325 fn validate( 326 326 &self, 327 327 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 327 327 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 328 328 Ok(()) 329 329 } 330 330 } ··· 382 382 } 383 383 fn validate( 384 384 &self, 385 385 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 385 385 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 386 386 if let Some(ref value) = self.tags { 387 387 #[allow(unused_comparisons)] 388 388 if value.len() > 10usize { 389 389 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 390 390 - field: "tags", 389 389 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 390 390 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 391 391 + "tags", 392 392 + ), 391 393 max: 10usize, 392 394 actual: value.len(), 393 395 }); ··· 428 430 } 429 431 fn validate( 430 432 &self, 431 431 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 433 433 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 432 434 Ok(()) 433 435 } 434 436 }

+7 -5

crates/jacquard-api/src/com_shinolabs/pinksea/oekaki.rs

··· 220 220 } 221 221 fn validate( 222 222 &self, 223 223 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 223 223 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 224 224 Ok(()) 225 225 } 226 226 } ··· 257 257 } 258 258 fn validate( 259 259 &self, 260 260 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 260 260 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 261 261 Ok(()) 262 262 } 263 263 } ··· 369 369 } 370 370 fn validate( 371 371 &self, 372 372 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 372 372 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 373 373 if let Some(ref value) = self.tags { 374 374 #[allow(unused_comparisons)] 375 375 if value.len() > 10usize { 376 376 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 377 377 - field: "tags", 376 376 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 377 377 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 378 378 + "tags", 379 379 + ), 378 380 max: 10usize, 379 381 actual: value.len(), 380 382 });

+30 -16

crates/jacquard-api/src/com_shinolabs/pinksea/profile.rs

··· 114 114 } 115 115 fn validate( 116 116 &self, 117 117 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 117 117 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 118 118 if let Some(ref value) = self.bio { 119 119 #[allow(unused_comparisons)] 120 120 if <str>::len(value.as_ref()) > 2400usize { 121 121 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 122 122 - field: "bio", 121 121 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 122 122 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 123 123 + "bio", 124 124 + ), 123 125 max: 2400usize, 124 126 actual: <str>::len(value.as_ref()), 125 127 }); ··· 133 135 ) 134 136 .count(); 135 137 if count > 240usize { 136 136 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 137 137 - field: "bio", 138 138 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 139 139 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 140 140 + "bio", 141 141 + ), 138 142 max: 240usize, 139 143 actual: count, 140 144 }); ··· 144 148 if let Some(ref value) = self.links { 145 149 #[allow(unused_comparisons)] 146 150 if value.len() > 5usize { 147 147 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 148 148 - field: "links", 151 151 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 152 152 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 153 153 + "links", 154 154 + ), 149 155 max: 5usize, 150 156 actual: value.len(), 151 157 }); ··· 154 160 if let Some(ref value) = self.nickname { 155 161 #[allow(unused_comparisons)] 156 162 if <str>::len(value.as_ref()) > 640usize { 157 157 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 158 158 - field: "nickname", 163 163 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 164 164 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 165 165 + "nickname", 166 166 + ), 159 167 max: 640usize, 160 168 actual: <str>::len(value.as_ref()), 161 169 }); ··· 169 177 ) 170 178 .count(); 171 179 if count > 64usize { 172 172 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 173 173 - field: "nickname", 180 180 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 181 181 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 182 182 + "nickname", 183 183 + ), 174 184 max: 64usize, 175 185 actual: count, 176 186 }); ··· 374 384 } 375 385 fn validate( 376 386 &self, 377 377 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 387 387 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 378 388 { 379 389 let value = &self.name; 380 390 #[allow(unused_comparisons)] 381 391 if <str>::len(value.as_ref()) > 500usize { 382 382 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 383 383 - field: "name", 392 392 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 393 393 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 394 394 + "name", 395 395 + ), 384 396 max: 500usize, 385 397 actual: <str>::len(value.as_ref()), 386 398 }); ··· 395 407 ) 396 408 .count(); 397 409 if count > 50usize { 398 398 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 399 399 - field: "name", 410 410 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 411 411 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 412 412 + "name", 413 413 + ), 400 414 max: 50usize, 401 415 actual: count, 402 416 });

+12 -8

crates/jacquard-api/src/com_whtwnd/blog.rs

··· 250 250 } 251 251 fn validate( 252 252 &self, 253 253 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 253 253 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 254 254 Ok(()) 255 255 } 256 256 } ··· 286 286 } 287 287 fn validate( 288 288 &self, 289 289 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 289 289 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 290 290 { 291 291 let value = &self.content; 292 292 #[allow(unused_comparisons)] 293 293 if <str>::len(value.as_ref()) > 100000usize { 294 294 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 295 295 - field: "content", 294 294 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 295 295 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 296 296 + "content", 297 297 + ), 296 298 max: 100000usize, 297 299 actual: <str>::len(value.as_ref()), 298 300 }); ··· 334 336 } 335 337 fn validate( 336 338 &self, 337 337 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 339 339 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 338 340 { 339 341 let value = &self.content; 340 342 #[allow(unused_comparisons)] 341 343 if <str>::len(value.as_ref()) > 1000usize { 342 342 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 343 343 - field: "content", 344 344 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 345 345 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 346 346 + "content", 347 347 + ), 344 348 max: 1000usize, 345 349 actual: <str>::len(value.as_ref()), 346 350 }); ··· 385 389 } 386 390 fn validate( 387 391 &self, 388 388 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 392 392 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 389 393 Ok(()) 390 394 } 391 395 }

+13 -7

crates/jacquard-api/src/com_whtwnd/blog/entry.rs

··· 129 129 } 130 130 fn validate( 131 131 &self, 132 132 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 132 132 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 133 133 { 134 134 let value = &self.content; 135 135 #[allow(unused_comparisons)] 136 136 if <str>::len(value.as_ref()) > 100000usize { 137 137 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 138 138 - field: "content", 137 137 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 138 138 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 139 139 + "content", 140 140 + ), 139 141 max: 100000usize, 140 142 actual: <str>::len(value.as_ref()), 141 143 }); ··· 144 146 if let Some(ref value) = self.subtitle { 145 147 #[allow(unused_comparisons)] 146 148 if <str>::len(value.as_ref()) > 1000usize { 147 147 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 148 148 - field: "subtitle", 149 149 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 150 150 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 151 151 + "subtitle", 152 152 + ), 149 153 max: 1000usize, 150 154 actual: <str>::len(value.as_ref()), 151 155 }); ··· 154 158 if let Some(ref value) = self.title { 155 159 #[allow(unused_comparisons)] 156 160 if <str>::len(value.as_ref()) > 1000usize { 157 157 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 158 158 - field: "title", 161 161 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 162 162 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 163 163 + "title", 164 164 + ), 159 165 max: 1000usize, 160 166 actual: <str>::len(value.as_ref()), 161 167 });

+1 -1

crates/jacquard-api/src/community_lexicon/bookmarks/bookmark.rs

··· 102 102 } 103 103 fn validate( 104 104 &self, 105 105 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 105 105 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 106 106 Ok(()) 107 107 } 108 108 }

+2 -2

crates/jacquard-api/src/community_lexicon/calendar/event.rs

··· 212 212 } 213 213 fn validate( 214 214 &self, 215 215 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 215 215 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 216 216 Ok(()) 217 217 } 218 218 } ··· 906 906 } 907 907 fn validate( 908 908 &self, 909 909 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 909 909 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 910 910 Ok(()) 911 911 } 912 912 }

+1 -1

crates/jacquard-api/src/community_lexicon/calendar/rsvp.rs

··· 135 135 } 136 136 fn validate( 137 137 &self, 138 138 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 138 138 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 139 139 Ok(()) 140 140 } 141 141 }

+1 -1

crates/jacquard-api/src/community_lexicon/interaction/like.rs

··· 97 97 } 98 98 fn validate( 99 99 &self, 100 100 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 100 100 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 101 101 Ok(()) 102 102 } 103 103 }

+9 -5

crates/jacquard-api/src/community_lexicon/location/address.rs

··· 204 204 } 205 205 fn validate( 206 206 &self, 207 207 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 207 207 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 208 208 { 209 209 let value = &self.country; 210 210 #[allow(unused_comparisons)] 211 211 if <str>::len(value.as_ref()) > 10usize { 212 212 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 213 213 - field: "country", 212 212 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 213 213 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 214 214 + "country", 215 215 + ), 214 216 max: 10usize, 215 217 actual: <str>::len(value.as_ref()), 216 218 }); ··· 220 222 let value = &self.country; 221 223 #[allow(unused_comparisons)] 222 224 if <str>::len(value.as_ref()) < 2usize { 223 223 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 224 224 - field: "country", 225 225 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 226 226 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 227 227 + "country", 228 228 + ), 225 229 min: 2usize, 226 230 actual: <str>::len(value.as_ref()), 227 231 });

+1 -1

crates/jacquard-api/src/community_lexicon/location/fsq.rs

··· 154 154 } 155 155 fn validate( 156 156 &self, 157 157 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 157 157 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 158 158 Ok(()) 159 159 } 160 160 }

+1 -1

crates/jacquard-api/src/community_lexicon/location/geo.rs

··· 147 147 } 148 148 fn validate( 149 149 &self, 150 150 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 150 150 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 151 151 Ok(()) 152 152 } 153 153 }

+1 -1

crates/jacquard-api/src/community_lexicon/location/hthree.rs

··· 112 112 } 113 113 fn validate( 114 114 &self, 115 115 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 115 115 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 116 116 Ok(()) 117 117 } 118 118 }

+1 -1

crates/jacquard-api/src/community_lexicon/payments/web_monetization.rs

··· 102 102 } 103 103 fn validate( 104 104 &self, 105 105 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 105 105 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 106 106 Ok(()) 107 107 } 108 108 }

+1 -1

crates/jacquard-api/src/dev_baileytownsend/health/calories.rs

··· 97 97 } 98 98 fn validate( 99 99 &self, 100 100 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 100 100 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 101 101 Ok(()) 102 102 } 103 103 }

+1 -1

crates/jacquard-api/src/dev_baileytownsend/health/rings.rs

··· 107 107 } 108 108 fn validate( 109 109 &self, 110 110 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 110 110 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 111 111 Ok(()) 112 112 } 113 113 }

+1 -1

crates/jacquard-api/src/dev_baileytownsend/health/steps.rs

··· 95 95 } 96 96 fn validate( 97 97 &self, 98 98 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 98 98 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 99 99 Ok(()) 100 100 } 101 101 }

+1 -1

crates/jacquard-api/src/dev_baileytownsend/health/workout.rs

··· 111 111 } 112 112 fn validate( 113 113 &self, 114 114 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 114 114 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 115 115 Ok(()) 116 116 } 117 117 }

+21 -11

crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/post.rs

··· 114 114 } 115 115 fn validate( 116 116 &self, 117 117 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 117 117 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 118 118 { 119 119 let value = &self.content; 120 120 #[allow(unused_comparisons)] 121 121 if <str>::len(value.as_ref()) > 10000usize { 122 122 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 123 123 - field: "content", 122 122 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 123 123 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 124 124 + "content", 125 125 + ), 124 126 max: 10000usize, 125 127 actual: <str>::len(value.as_ref()), 126 128 }); ··· 130 132 let value = &self.content; 131 133 #[allow(unused_comparisons)] 132 134 if <str>::len(value.as_ref()) < 1usize { 133 133 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 134 134 - field: "content", 135 135 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 136 136 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 137 137 + "content", 138 138 + ), 135 139 min: 1usize, 136 140 actual: <str>::len(value.as_ref()), 137 141 }); ··· 141 145 let value = &self.tags; 142 146 #[allow(unused_comparisons)] 143 147 if value.len() > 20usize { 144 144 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 145 145 - field: "tags", 148 148 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 149 149 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 150 150 + "tags", 151 151 + ), 146 152 max: 20usize, 147 153 actual: value.len(), 148 154 }); ··· 152 158 let value = &self.title; 153 159 #[allow(unused_comparisons)] 154 160 if <str>::len(value.as_ref()) > 100usize { 155 155 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 156 156 - field: "title", 161 161 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 162 162 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 163 163 + "title", 164 164 + ), 157 165 max: 100usize, 158 166 actual: <str>::len(value.as_ref()), 159 167 }); ··· 163 171 let value = &self.title; 164 172 #[allow(unused_comparisons)] 165 173 if <str>::len(value.as_ref()) < 1usize { 166 166 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 167 167 - field: "title", 174 174 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 175 175 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 176 176 + "title", 177 177 + ), 168 178 min: 1usize, 169 179 actual: <str>::len(value.as_ref()), 170 180 });

+5 -3

crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/reply.rs

··· 103 103 } 104 104 fn validate( 105 105 &self, 106 106 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 106 106 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 107 107 { 108 108 let value = &self.content; 109 109 #[allow(unused_comparisons)] 110 110 if <str>::len(value.as_ref()) > 10000usize { 111 111 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 112 112 - field: "content", 111 111 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 112 112 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 113 113 + "content", 114 114 + ), 113 115 max: 10000usize, 114 116 actual: <str>::len(value.as_ref()), 115 117 });

+17 -9

crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/announcement.rs

··· 102 102 } 103 103 fn validate( 104 104 &self, 105 105 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 105 105 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 106 106 { 107 107 let value = &self.body; 108 108 #[allow(unused_comparisons)] 109 109 if <str>::len(value.as_ref()) > 10000usize { 110 110 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 111 111 - field: "body", 110 110 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 111 111 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 112 112 + "body", 113 113 + ), 112 114 max: 10000usize, 113 115 actual: <str>::len(value.as_ref()), 114 116 }); ··· 118 120 let value = &self.body; 119 121 #[allow(unused_comparisons)] 120 122 if <str>::len(value.as_ref()) < 1usize { 121 121 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 122 122 - field: "body", 123 123 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 124 124 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 125 125 + "body", 126 126 + ), 123 127 min: 1usize, 124 128 actual: <str>::len(value.as_ref()), 125 129 }); ··· 129 133 let value = &self.title; 130 134 #[allow(unused_comparisons)] 131 135 if <str>::len(value.as_ref()) > 100usize { 132 132 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 133 133 - field: "title", 136 136 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 137 137 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 138 138 + "title", 139 139 + ), 134 140 max: 100usize, 135 141 actual: <str>::len(value.as_ref()), 136 142 }); ··· 140 146 let value = &self.title; 141 147 #[allow(unused_comparisons)] 142 148 if <str>::len(value.as_ref()) < 1usize { 143 143 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 144 144 - field: "title", 149 149 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 150 150 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 151 151 + "title", 152 152 + ), 145 153 min: 1usize, 146 154 actual: <str>::len(value.as_ref()), 147 155 });

+17 -9

crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/category.rs

··· 106 106 } 107 107 fn validate( 108 108 &self, 109 109 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 109 109 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 110 110 { 111 111 let value = &self.category_type; 112 112 #[allow(unused_comparisons)] 113 113 if <str>::len(value.as_ref()) > 30usize { 114 114 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 115 115 - field: "category_type", 114 114 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 115 115 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 116 116 + "category_type", 117 117 + ), 116 118 max: 30usize, 117 119 actual: <str>::len(value.as_ref()), 118 120 }); ··· 121 123 if let Some(ref value) = self.description { 122 124 #[allow(unused_comparisons)] 123 125 if <str>::len(value.as_ref()) > 300usize { 124 124 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 125 125 - field: "description", 126 126 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 127 127 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 128 128 + "description", 129 129 + ), 126 130 max: 300usize, 127 131 actual: <str>::len(value.as_ref()), 128 132 }); ··· 132 136 let value = &self.name; 133 137 #[allow(unused_comparisons)] 134 138 if <str>::len(value.as_ref()) > 100usize { 135 135 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 136 136 - field: "name", 139 139 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 140 140 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 141 141 + "name", 142 142 + ), 137 143 max: 100usize, 138 144 actual: <str>::len(value.as_ref()), 139 145 }); ··· 143 149 let value = &self.name; 144 150 #[allow(unused_comparisons)] 145 151 if <str>::len(value.as_ref()) < 1usize { 146 146 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 147 147 - field: "name", 152 152 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 153 153 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 154 154 + "name", 155 155 + ), 148 156 min: 1usize, 149 157 actual: <str>::len(value.as_ref()), 150 158 });

+13 -7

crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/group.rs

··· 101 101 } 102 102 fn validate( 103 103 &self, 104 104 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 104 104 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 105 105 if let Some(ref value) = self.description { 106 106 #[allow(unused_comparisons)] 107 107 if <str>::len(value.as_ref()) > 300usize { 108 108 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 109 109 - field: "description", 108 108 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 109 109 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 110 110 + "description", 111 111 + ), 110 112 max: 300usize, 111 113 actual: <str>::len(value.as_ref()), 112 114 }); ··· 116 118 let value = &self.name; 117 119 #[allow(unused_comparisons)] 118 120 if <str>::len(value.as_ref()) > 100usize { 119 119 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 120 120 - field: "name", 121 121 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 122 122 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 123 123 + "name", 124 124 + ), 121 125 max: 100usize, 122 126 actual: <str>::len(value.as_ref()), 123 127 }); ··· 127 131 let value = &self.name; 128 132 #[allow(unused_comparisons)] 129 133 if <str>::len(value.as_ref()) < 1usize { 130 130 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 131 131 - field: "name", 134 134 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 135 135 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 136 136 + "name", 137 137 + ), 132 138 min: 1usize, 133 139 actual: <str>::len(value.as_ref()), 134 140 });

+17 -9

crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/identity.rs

··· 105 105 } 106 106 fn validate( 107 107 &self, 108 108 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 108 108 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 109 109 if let Some(ref value) = self.accent { 110 110 #[allow(unused_comparisons)] 111 111 if <str>::len(value.as_ref()) > 7usize { 112 112 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 113 113 - field: "accent", 112 112 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 113 113 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 114 114 + "accent", 115 115 + ), 114 116 max: 7usize, 115 117 actual: <str>::len(value.as_ref()), 116 118 }); ··· 119 121 if let Some(ref value) = self.accent { 120 122 #[allow(unused_comparisons)] 121 123 if <str>::len(value.as_ref()) < 7usize { 122 122 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 123 123 - field: "accent", 124 124 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 125 125 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 126 126 + "accent", 127 127 + ), 124 128 min: 7usize, 125 129 actual: <str>::len(value.as_ref()), 126 130 }); ··· 129 133 if let Some(ref value) = self.description { 130 134 #[allow(unused_comparisons)] 131 135 if <str>::len(value.as_ref()) > 300usize { 132 132 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 133 133 - field: "description", 136 136 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 137 137 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 138 138 + "description", 139 139 + ), 134 140 max: 300usize, 135 141 actual: <str>::len(value.as_ref()), 136 142 }); ··· 140 146 let value = &self.name; 141 147 #[allow(unused_comparisons)] 142 148 if <str>::len(value.as_ref()) > 100usize { 143 143 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 144 144 - field: "name", 149 149 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 150 150 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 151 151 + "name", 152 152 + ), 145 153 max: 100usize, 146 154 actual: <str>::len(value.as_ref()), 147 155 });

+9 -5

crates/jacquard-api/src/dev_ocbwoy3/blueboard/board.rs

··· 105 105 } 106 106 fn validate( 107 107 &self, 108 108 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 108 108 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 109 109 { 110 110 let value = &self.description; 111 111 { ··· 115 115 ) 116 116 .count(); 117 117 if count > 30usize { 118 118 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 119 119 - field: "description", 118 118 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 119 119 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 120 120 + "description", 121 121 + ), 120 122 max: 30usize, 121 123 actual: count, 122 124 }); ··· 127 129 let value = &self.title; 128 130 #[allow(unused_comparisons)] 129 131 if <str>::len(value.as_ref()) > 10usize { 130 130 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 131 131 - field: "title", 132 132 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 133 133 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 134 134 + "title", 135 135 + ), 132 136 max: 10usize, 133 137 actual: <str>::len(value.as_ref()), 134 138 });

+5 -3

crates/jacquard-api/src/dev_ocbwoy3/blueboard/post.rs

··· 107 107 } 108 108 fn validate( 109 109 &self, 110 110 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 110 110 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 111 111 { 112 112 let value = &self.text; 113 113 #[allow(unused_comparisons)] 114 114 if <str>::len(value.as_ref()) > 1000usize { 115 115 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 116 116 - field: "text", 115 115 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 116 116 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 117 117 + "text", 118 118 + ), 117 119 max: 1000usize, 118 120 actual: <str>::len(value.as_ref()), 119 121 });

+1 -1

crates/jacquard-api/src/dev_regnault/webfishing/savefile.rs

··· 99 99 } 100 100 fn validate( 101 101 &self, 102 102 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 102 102 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 103 103 Ok(()) 104 104 } 105 105 }

+3 -3

crates/jacquard-api/src/fm_teal/alpha/actor.rs

··· 380 380 } 381 381 fn validate( 382 382 &self, 383 383 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 383 383 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 384 384 Ok(()) 385 385 } 386 386 } ··· 448 448 } 449 449 fn validate( 450 450 &self, 451 451 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 451 451 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 452 452 Ok(()) 453 453 } 454 454 } ··· 490 490 } 491 491 fn validate( 492 492 &self, 493 493 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 493 493 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 494 494 Ok(()) 495 495 } 496 496 }

+18 -10

crates/jacquard-api/src/fm_teal/alpha/actor/profile.rs

··· 234 234 } 235 235 fn validate( 236 236 &self, 237 237 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 237 237 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 238 238 Ok(()) 239 239 } 240 240 } ··· 360 360 } 361 361 fn validate( 362 362 &self, 363 363 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 363 363 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 364 364 if let Some(ref value) = self.description { 365 365 #[allow(unused_comparisons)] 366 366 if <str>::len(value.as_ref()) > 2560usize { 367 367 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 368 368 - field: "description", 367 367 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 368 368 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 369 369 + "description", 370 370 + ), 369 371 max: 2560usize, 370 372 actual: <str>::len(value.as_ref()), 371 373 }); ··· 379 381 ) 380 382 .count(); 381 383 if count > 256usize { 382 382 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 383 383 - field: "description", 384 384 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 385 385 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 386 386 + "description", 387 387 + ), 384 388 max: 256usize, 385 389 actual: count, 386 390 }); ··· 390 394 if let Some(ref value) = self.display_name { 391 395 #[allow(unused_comparisons)] 392 396 if <str>::len(value.as_ref()) > 640usize { 393 393 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 394 394 - field: "display_name", 397 397 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 398 398 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 399 399 + "display_name", 400 400 + ), 395 401 max: 640usize, 396 402 actual: <str>::len(value.as_ref()), 397 403 }); ··· 405 411 ) 406 412 .count(); 407 413 if count > 64usize { 408 408 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 409 409 - field: "display_name", 414 414 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 415 415 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 416 416 + "display_name", 417 417 + ), 410 418 max: 64usize, 411 419 actual: count, 412 420 });

+1 -1

crates/jacquard-api/src/fm_teal/alpha/actor/profile_status.rs

··· 106 106 } 107 107 fn validate( 108 108 &self, 109 109 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 109 109 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 110 110 Ok(()) 111 111 } 112 112 }

+1 -1

crates/jacquard-api/src/fm_teal/alpha/actor/status.rs

··· 102 102 } 103 103 fn validate( 104 104 &self, 105 105 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 105 105 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 106 106 Ok(()) 107 107 } 108 108 }

+42 -22

crates/jacquard-api/src/fm_teal/alpha/feed.rs

··· 372 372 } 373 373 fn validate( 374 374 &self, 375 375 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 375 375 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 376 376 { 377 377 let value = &self.artist_name; 378 378 #[allow(unused_comparisons)] 379 379 if <str>::len(value.as_ref()) > 256usize { 380 380 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 381 381 - field: "artist_name", 380 380 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 381 381 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 382 382 + "artist_name", 383 383 + ), 382 384 max: 256usize, 383 385 actual: <str>::len(value.as_ref()), 384 386 }); ··· 388 390 let value = &self.artist_name; 389 391 #[allow(unused_comparisons)] 390 392 if <str>::len(value.as_ref()) < 1usize { 391 391 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 392 392 - field: "artist_name", 393 393 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 394 394 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 395 395 + "artist_name", 396 396 + ), 393 397 min: 1usize, 394 398 actual: <str>::len(value.as_ref()), 395 399 }); ··· 404 408 ) 405 409 .count(); 406 410 if count > 2560usize { 407 407 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 408 408 - field: "artist_name", 411 411 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 412 412 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 413 413 + "artist_name", 414 414 + ), 409 415 max: 2560usize, 410 416 actual: count, 411 417 }); ··· 498 504 } 499 505 fn validate( 500 506 &self, 501 501 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 507 507 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 502 508 if let Some(ref value) = self.release_name { 503 509 #[allow(unused_comparisons)] 504 510 if <str>::len(value.as_ref()) > 256usize { 505 505 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 506 506 - field: "release_name", 511 511 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 512 512 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 513 513 + "release_name", 514 514 + ), 507 515 max: 256usize, 508 516 actual: <str>::len(value.as_ref()), 509 517 }); ··· 517 525 ) 518 526 .count(); 519 527 if count > 2560usize { 520 520 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 521 521 - field: "release_name", 528 528 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 529 529 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 530 530 + "release_name", 531 531 + ), 522 532 max: 2560usize, 523 533 actual: count, 524 534 }); ··· 528 538 if let Some(ref value) = self.submission_client_agent { 529 539 #[allow(unused_comparisons)] 530 540 if <str>::len(value.as_ref()) > 256usize { 531 531 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 532 532 - field: "submission_client_agent", 541 541 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 542 542 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 543 543 + "submission_client_agent", 544 544 + ), 533 545 max: 256usize, 534 546 actual: <str>::len(value.as_ref()), 535 547 }); ··· 543 555 ) 544 556 .count(); 545 557 if count > 2560usize { 546 546 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 547 547 - field: "submission_client_agent", 558 558 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 559 559 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 560 560 + "submission_client_agent", 561 561 + ), 548 562 max: 2560usize, 549 563 actual: count, 550 564 }); ··· 555 569 let value = &self.track_name; 556 570 #[allow(unused_comparisons)] 557 571 if <str>::len(value.as_ref()) > 256usize { 558 558 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 559 559 - field: "track_name", 572 572 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 573 573 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 574 574 + "track_name", 575 575 + ), 560 576 max: 256usize, 561 577 actual: <str>::len(value.as_ref()), 562 578 }); ··· 566 582 let value = &self.track_name; 567 583 #[allow(unused_comparisons)] 568 584 if <str>::len(value.as_ref()) < 1usize { 569 569 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 570 570 - field: "track_name", 585 585 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 586 586 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 587 587 + "track_name", 588 588 + ), 571 589 min: 1usize, 572 590 actual: <str>::len(value.as_ref()), 573 591 }); ··· 582 600 ) 583 601 .count(); 584 602 if count > 2560usize { 585 585 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 586 586 - field: "track_name", 603 603 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 604 604 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 605 605 + "track_name", 606 606 + ), 587 607 max: 2560usize, 588 608 actual: count, 589 609 });

+45 -23

crates/jacquard-api/src/fm_teal/alpha/feed/play.rs

··· 170 170 } 171 171 fn validate( 172 172 &self, 173 173 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 173 173 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 174 174 if let Some(ref value) = self.release_discriminant { 175 175 #[allow(unused_comparisons)] 176 176 if <str>::len(value.as_ref()) > 128usize { 177 177 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 178 178 - field: "release_discriminant", 177 177 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 178 178 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 179 179 + "release_discriminant", 180 180 + ), 179 181 max: 128usize, 180 182 actual: <str>::len(value.as_ref()), 181 183 }); ··· 189 191 ) 190 192 .count(); 191 193 if count > 1280usize { 192 192 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 193 193 - field: "release_discriminant", 194 194 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 195 195 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 196 196 + "release_discriminant", 197 197 + ), 194 198 max: 1280usize, 195 199 actual: count, 196 200 }); ··· 200 204 if let Some(ref value) = self.release_name { 201 205 #[allow(unused_comparisons)] 202 206 if <str>::len(value.as_ref()) > 256usize { 203 203 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 204 204 - field: "release_name", 207 207 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 208 208 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 209 209 + "release_name", 210 210 + ), 205 211 max: 256usize, 206 212 actual: <str>::len(value.as_ref()), 207 213 }); ··· 215 221 ) 216 222 .count(); 217 223 if count > 2560usize { 218 218 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 219 219 - field: "release_name", 224 224 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 225 225 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 226 226 + "release_name", 227 227 + ), 220 228 max: 2560usize, 221 229 actual: count, 222 230 }); ··· 226 234 if let Some(ref value) = self.submission_client_agent { 227 235 #[allow(unused_comparisons)] 228 236 if <str>::len(value.as_ref()) > 256usize { 229 229 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 230 230 - field: "submission_client_agent", 237 237 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 238 238 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 239 239 + "submission_client_agent", 240 240 + ), 231 241 max: 256usize, 232 242 actual: <str>::len(value.as_ref()), 233 243 }); ··· 241 251 ) 242 252 .count(); 243 253 if count > 2560usize { 244 244 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 245 245 - field: "submission_client_agent", 254 254 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 255 255 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 256 256 + "submission_client_agent", 257 257 + ), 246 258 max: 2560usize, 247 259 actual: count, 248 260 }); ··· 252 264 if let Some(ref value) = self.track_discriminant { 253 265 #[allow(unused_comparisons)] 254 266 if <str>::len(value.as_ref()) > 128usize { 255 255 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 256 256 - field: "track_discriminant", 267 267 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 268 268 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 269 269 + "track_discriminant", 270 270 + ), 257 271 max: 128usize, 258 272 actual: <str>::len(value.as_ref()), 259 273 }); ··· 267 281 ) 268 282 .count(); 269 283 if count > 1280usize { 270 270 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 271 271 - field: "track_discriminant", 284 284 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 285 285 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 286 286 + "track_discriminant", 287 287 + ), 272 288 max: 1280usize, 273 289 actual: count, 274 290 }); ··· 279 295 let value = &self.track_name; 280 296 #[allow(unused_comparisons)] 281 297 if <str>::len(value.as_ref()) > 256usize { 282 282 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 283 283 - field: "track_name", 298 298 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 299 299 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 300 300 + "track_name", 301 301 + ), 284 302 max: 256usize, 285 303 actual: <str>::len(value.as_ref()), 286 304 }); ··· 290 308 let value = &self.track_name; 291 309 #[allow(unused_comparisons)] 292 310 if <str>::len(value.as_ref()) < 1usize { 293 293 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 294 294 - field: "track_name", 311 311 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 312 312 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 313 313 + "track_name", 314 314 + ), 295 315 min: 1usize, 296 316 actual: <str>::len(value.as_ref()), 297 317 }); ··· 306 326 ) 307 327 .count(); 308 328 if count > 2560usize { 309 309 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 310 310 - field: "track_name", 329 329 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 330 330 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 331 331 + "track_name", 332 332 + ), 311 333 max: 2560usize, 312 334 actual: count, 313 335 });

+3 -3

crates/jacquard-api/src/fm_teal/alpha/stats.rs

··· 269 269 } 270 270 fn validate( 271 271 &self, 272 272 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 272 272 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 273 273 Ok(()) 274 274 } 275 275 } ··· 311 311 } 312 312 fn validate( 313 313 &self, 314 314 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 314 314 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 315 315 Ok(()) 316 316 } 317 317 } ··· 353 353 } 354 354 fn validate( 355 355 &self, 356 356 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 356 356 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 357 357 Ok(()) 358 358 } 359 359 }

+5 -3

crates/jacquard-api/src/fyi_frontpage/feed/comment.rs

··· 105 105 } 106 106 fn validate( 107 107 &self, 108 108 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 108 108 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 109 109 { 110 110 let value = &self.blocks; 111 111 #[allow(unused_comparisons)] 112 112 if value.len() > 50usize { 113 113 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 114 114 - field: "blocks", 113 113 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 114 114 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 115 115 + "blocks", 116 116 + ), 115 117 max: 50usize, 116 118 actual: value.len(), 117 119 });

+10 -6

crates/jacquard-api/src/fyi_frontpage/feed/post.rs

··· 105 105 } 106 106 fn validate( 107 107 &self, 108 108 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 108 108 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 109 109 { 110 110 let value = &self.title; 111 111 #[allow(unused_comparisons)] 112 112 if <str>::len(value.as_ref()) > 3000usize { 113 113 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 114 114 - field: "title", 113 113 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 114 114 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 115 115 + "title", 116 116 + ), 115 117 max: 3000usize, 116 118 actual: <str>::len(value.as_ref()), 117 119 }); ··· 126 128 ) 127 129 .count(); 128 130 if count > 300usize { 129 129 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 130 130 - field: "title", 131 131 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 132 132 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 133 133 + "title", 134 134 + ), 131 135 max: 300usize, 132 136 actual: count, 133 137 }); ··· 296 300 } 297 301 fn validate( 298 302 &self, 299 299 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 303 303 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 300 304 Ok(()) 301 305 } 302 306 }

+1 -1

crates/jacquard-api/src/fyi_frontpage/feed/vote.rs

··· 99 99 } 100 100 fn validate( 101 101 &self, 102 102 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 102 102 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 103 103 Ok(()) 104 104 } 105 105 }

+10 -6

crates/jacquard-api/src/fyi_frontpage/richtext/block.rs

··· 104 104 } 105 105 fn validate( 106 106 &self, 107 107 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 107 107 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 108 108 Ok(()) 109 109 } 110 110 } ··· 138 138 } 139 139 fn validate( 140 140 &self, 141 141 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 141 141 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 142 142 { 143 143 let value = &self.text; 144 144 #[allow(unused_comparisons)] 145 145 if <str>::len(value.as_ref()) > 100000usize { 146 146 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 147 147 - field: "text", 146 146 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 147 147 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 148 148 + "text", 149 149 + ), 148 150 max: 100000usize, 149 151 actual: <str>::len(value.as_ref()), 150 152 }); ··· 159 161 ) 160 162 .count(); 161 163 if count > 10000usize { 162 162 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 163 163 - field: "text", 164 164 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 165 165 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 166 166 + "text", 167 167 + ), 164 168 max: 10000usize, 165 169 actual: count, 166 170 });

+9 -5

crates/jacquard-api/src/fyi_unravel/frontpage/comment.rs

··· 106 106 } 107 107 fn validate( 108 108 &self, 109 109 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 109 109 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 110 110 { 111 111 let value = &self.content; 112 112 #[allow(unused_comparisons)] 113 113 if <str>::len(value.as_ref()) > 100000usize { 114 114 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 115 115 - field: "content", 114 114 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 115 115 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 116 116 + "content", 117 117 + ), 116 118 max: 100000usize, 117 119 actual: <str>::len(value.as_ref()), 118 120 }); ··· 127 129 ) 128 130 .count(); 129 131 if count > 10000usize { 130 130 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 131 131 - field: "content", 132 132 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 133 133 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 134 134 + "content", 135 135 + ), 132 136 max: 10000usize, 133 137 actual: count, 134 138 });

+9 -5

crates/jacquard-api/src/fyi_unravel/frontpage/post.rs

··· 103 103 } 104 104 fn validate( 105 105 &self, 106 106 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 106 106 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 107 107 { 108 108 let value = &self.title; 109 109 #[allow(unused_comparisons)] 110 110 if <str>::len(value.as_ref()) > 3000usize { 111 111 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 112 112 - field: "title", 111 111 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 112 112 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 113 113 + "title", 114 114 + ), 113 115 max: 3000usize, 114 116 actual: <str>::len(value.as_ref()), 115 117 }); ··· 124 126 ) 125 127 .count(); 126 128 if count > 300usize { 127 127 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 128 128 - field: "title", 129 129 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 130 130 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 131 131 + "title", 132 132 + ), 129 133 max: 300usize, 130 134 actual: count, 131 135 });

+1 -1

crates/jacquard-api/src/fyi_unravel/frontpage/vote.rs

··· 98 98 } 99 99 fn validate( 100 100 &self, 101 101 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 101 101 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 102 102 Ok(()) 103 103 } 104 104 }

+9 -5

crates/jacquard-api/src/moe_karashiiro/kpaste/paste.rs

··· 112 112 } 113 113 fn validate( 114 114 &self, 115 115 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 115 115 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 116 116 if let Some(ref value) = self.language { 117 117 #[allow(unused_comparisons)] 118 118 if <str>::len(value.as_ref()) > 50usize { 119 119 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 120 120 - field: "language", 119 119 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 120 120 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 121 121 + "language", 122 122 + ), 121 123 max: 50usize, 122 124 actual: <str>::len(value.as_ref()), 123 125 }); ··· 126 128 if let Some(ref value) = self.title { 127 129 #[allow(unused_comparisons)] 128 130 if <str>::len(value.as_ref()) > 200usize { 129 129 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 130 130 - field: "title", 131 131 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 132 132 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 133 133 + "title", 134 134 + ), 131 135 max: 200usize, 132 136 actual: <str>::len(value.as_ref()), 133 137 });

+1 -1

crates/jacquard-api/src/my_skylights.rs

··· 101 101 } 102 102 fn validate( 103 103 &self, 104 104 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 104 104 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 105 105 Ok(()) 106 106 } 107 107 }

+1 -1

crates/jacquard-api/src/my_skylights/list.rs

··· 136 136 } 137 137 fn validate( 138 138 &self, 139 139 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 139 139 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 140 140 Ok(()) 141 141 } 142 142 }

+2 -2

crates/jacquard-api/src/my_skylights/list_item.rs

··· 236 236 } 237 237 fn validate( 238 238 &self, 239 239 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 239 239 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 240 240 Ok(()) 241 241 } 242 242 } ··· 319 319 } 320 320 fn validate( 321 321 &self, 322 322 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 322 322 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 323 323 Ok(()) 324 324 } 325 325 }

+11 -7

crates/jacquard-api/src/my_skylights/rel.rs

··· 106 106 } 107 107 fn validate( 108 108 &self, 109 109 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 109 109 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 110 110 Ok(()) 111 111 } 112 112 } ··· 344 344 } 345 345 fn validate( 346 346 &self, 347 347 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 347 347 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 348 348 Ok(()) 349 349 } 350 350 } ··· 378 378 } 379 379 fn validate( 380 380 &self, 381 381 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 381 381 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 382 382 { 383 383 let value = &self.value; 384 384 if *value > 10i64 { 385 385 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 386 386 - field: "value", 385 385 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 386 386 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 387 387 + "value", 388 388 + ), 387 389 max: 10i64, 388 390 actual: *value, 389 391 }); ··· 392 394 { 393 395 let value = &self.value; 394 396 if *value < 1i64 { 395 395 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 396 396 - field: "value", 397 397 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 398 398 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 399 399 + "value", 400 400 + ), 397 401 min: 1i64, 398 402 actual: *value, 399 403 });

+13 -7

crates/jacquard-api/src/net_aftertheinter/coolthingtwo.rs

··· 97 97 } 98 98 fn validate( 99 99 &self, 100 100 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 100 100 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 101 101 { 102 102 let value = &self.status; 103 103 #[allow(unused_comparisons)] 104 104 if <str>::len(value.as_ref()) > 32usize { 105 105 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 106 106 - field: "status", 105 105 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 106 106 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 107 107 + "status", 108 108 + ), 107 109 max: 32usize, 108 110 actual: <str>::len(value.as_ref()), 109 111 }); ··· 113 115 let value = &self.status; 114 116 #[allow(unused_comparisons)] 115 117 if <str>::len(value.as_ref()) < 1usize { 116 116 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 117 117 - field: "status", 118 118 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 119 119 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 120 120 + "status", 121 121 + ), 118 122 min: 1usize, 119 123 actual: <str>::len(value.as_ref()), 120 124 }); ··· 129 133 ) 130 134 .count(); 131 135 if count > 1usize { 132 132 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 133 133 - field: "status", 136 136 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 137 137 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 138 138 + "status", 139 139 + ), 134 140 max: 1usize, 135 141 actual: count, 136 142 });

+27 -15

crates/jacquard-api/src/net_altq/aqfile.rs

··· 303 303 } 304 304 fn validate( 305 305 &self, 306 306 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 306 306 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 307 307 { 308 308 let value = &self.algo; 309 309 #[allow(unused_comparisons)] 310 310 if <str>::len(value.as_ref()) > 32usize { 311 311 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 312 312 - field: "algo", 311 311 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 312 312 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 313 313 + "algo", 314 314 + ), 313 315 max: 32usize, 314 316 actual: <str>::len(value.as_ref()), 315 317 }); ··· 319 321 let value = &self.hash; 320 322 #[allow(unused_comparisons)] 321 323 if <str>::len(value.as_ref()) > 128usize { 322 322 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 323 323 - field: "hash", 324 324 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 325 325 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 326 326 + "hash", 327 327 + ), 324 328 max: 128usize, 325 329 actual: <str>::len(value.as_ref()), 326 330 }); ··· 373 377 } 374 378 fn validate( 375 379 &self, 376 376 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 380 380 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 377 381 if let Some(ref value) = self.mime_type { 378 382 #[allow(unused_comparisons)] 379 383 if <str>::len(value.as_ref()) > 255usize { 380 380 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 381 381 - field: "mime_type", 384 384 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 385 385 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 386 386 + "mime_type", 387 387 + ), 382 388 max: 255usize, 383 389 actual: <str>::len(value.as_ref()), 384 390 }); ··· 388 394 let value = &self.name; 389 395 #[allow(unused_comparisons)] 390 396 if <str>::len(value.as_ref()) > 512usize { 391 391 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 392 392 - field: "name", 397 397 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 398 398 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 399 399 + "name", 400 400 + ), 393 401 max: 512usize, 394 402 actual: <str>::len(value.as_ref()), 395 403 }); ··· 398 406 { 399 407 let value = &self.size; 400 408 if *value > 1000000000i64 { 401 401 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 402 402 - field: "size", 409 409 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 410 410 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 411 411 + "size", 412 412 + ), 403 413 max: 1000000000i64, 404 414 actual: *value, 405 415 }); ··· 408 418 { 409 419 let value = &self.size; 410 420 if *value < 0i64 { 411 411 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 412 412 - field: "size", 421 421 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 422 422 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 423 423 + "size", 424 424 + ), 413 425 min: 0i64, 414 426 actual: *value, 415 427 }); ··· 526 538 } 527 539 fn validate( 528 540 &self, 529 529 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 541 541 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 530 542 Ok(()) 531 543 } 532 544 }

+31 -17

crates/jacquard-api/src/net_anisota/beta/game/collection.rs

··· 169 169 } 170 170 fn validate( 171 171 &self, 172 172 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 172 172 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 173 173 if let Some(ref value) = self.common_name { 174 174 #[allow(unused_comparisons)] 175 175 if <str>::len(value.as_ref()) > 200usize { 176 176 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 177 177 - field: "common_name", 176 176 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 177 177 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 178 178 + "common_name", 179 179 + ), 178 180 max: 200usize, 179 181 actual: <str>::len(value.as_ref()), 180 182 }); ··· 183 185 if let Some(ref value) = self.family { 184 186 #[allow(unused_comparisons)] 185 187 if <str>::len(value.as_ref()) > 100usize { 186 186 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 187 187 - field: "family", 188 188 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 189 189 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 190 190 + "family", 191 191 + ), 188 192 max: 100usize, 189 193 actual: <str>::len(value.as_ref()), 190 194 }); ··· 193 197 if let Some(ref value) = self.genus { 194 198 #[allow(unused_comparisons)] 195 199 if <str>::len(value.as_ref()) > 100usize { 196 196 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 197 197 - field: "genus", 200 200 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 201 201 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 202 202 + "genus", 203 203 + ), 198 204 max: 100usize, 199 205 actual: <str>::len(value.as_ref()), 200 206 }); ··· 203 209 { 204 210 let value = &self.quantity; 205 211 if *value < 1i64 { 206 206 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 207 207 - field: "quantity", 212 212 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 213 213 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 214 214 + "quantity", 215 215 + ), 208 216 min: 1i64, 209 217 actual: *value, 210 218 }); ··· 213 221 if let Some(ref value) = self.scientific_name { 214 222 #[allow(unused_comparisons)] 215 223 if <str>::len(value.as_ref()) > 200usize { 216 216 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 217 217 - field: "scientific_name", 224 224 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 225 225 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 226 226 + "scientific_name", 227 227 + ), 218 228 max: 200usize, 219 229 actual: <str>::len(value.as_ref()), 220 230 }); ··· 223 233 if let Some(ref value) = self.species { 224 234 #[allow(unused_comparisons)] 225 235 if <str>::len(value.as_ref()) > 100usize { 226 226 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 227 227 - field: "species", 236 236 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 237 237 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 238 238 + "species", 239 239 + ), 228 240 max: 100usize, 229 241 actual: <str>::len(value.as_ref()), 230 242 }); ··· 234 246 let value = &self.specimen_id; 235 247 #[allow(unused_comparisons)] 236 248 if <str>::len(value.as_ref()) > 100usize { 237 237 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 238 238 - field: "specimen_id", 249 249 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 250 250 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 251 251 + "specimen_id", 252 252 + ), 239 253 max: 100usize, 240 254 actual: <str>::len(value.as_ref()), 241 255 }); ··· 798 812 } 799 813 fn validate( 800 814 &self, 801 801 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 815 815 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 802 816 Ok(()) 803 817 } 804 818 } ··· 839 853 } 840 854 fn validate( 841 855 &self, 842 842 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 856 856 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 843 857 Ok(()) 844 858 } 845 859 }

+26 -14

crates/jacquard-api/src/net_anisota/beta/game/inventory.rs

··· 156 156 } 157 157 fn validate( 158 158 &self, 159 159 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 159 159 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 160 160 { 161 161 let value = &self.item_id; 162 162 #[allow(unused_comparisons)] 163 163 if <str>::len(value.as_ref()) > 100usize { 164 164 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 165 165 - field: "item_id", 164 164 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 165 165 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 166 166 + "item_id", 167 167 + ), 166 168 max: 100usize, 167 169 actual: <str>::len(value.as_ref()), 168 170 }); ··· 171 173 if let Some(ref value) = self.item_name { 172 174 #[allow(unused_comparisons)] 173 175 if <str>::len(value.as_ref()) > 200usize { 174 174 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 175 175 - field: "item_name", 176 176 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 177 177 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 178 178 + "item_name", 179 179 + ), 176 180 max: 200usize, 177 181 actual: <str>::len(value.as_ref()), 178 182 }); ··· 181 185 if let Some(ref value) = self.item_type { 182 186 #[allow(unused_comparisons)] 183 187 if <str>::len(value.as_ref()) > 50usize { 184 184 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 185 185 - field: "item_type", 188 188 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 189 189 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 190 190 + "item_type", 191 191 + ), 186 192 max: 50usize, 187 193 actual: <str>::len(value.as_ref()), 188 194 }); ··· 190 196 } 191 197 if let Some(ref value) = self.item_value { 192 198 if *value < 0i64 { 193 193 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 194 194 - field: "item_value", 199 199 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 200 200 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 201 201 + "item_value", 202 202 + ), 195 203 min: 0i64, 196 204 actual: *value, 197 205 }); ··· 199 207 } 200 208 if let Some(ref value) = self.max_stack { 201 209 if *value < 1i64 { 202 202 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 203 203 - field: "max_stack", 210 210 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 211 211 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 212 212 + "max_stack", 213 213 + ), 204 214 min: 1i64, 205 215 actual: *value, 206 216 }); ··· 209 219 { 210 220 let value = &self.quantity; 211 221 if *value < 1i64 { 212 212 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 213 213 - field: "quantity", 222 222 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 223 223 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 224 224 + "quantity", 225 225 + ), 214 226 min: 1i64, 215 227 actual: *value, 216 228 }); ··· 629 641 } 630 642 fn validate( 631 643 &self, 632 632 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 644 644 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 633 645 Ok(()) 634 646 } 635 647 }

+68 -38

crates/jacquard-api/src/net_anisota/beta/game/log.rs

··· 982 982 } 983 983 fn validate( 984 984 &self, 985 985 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 985 985 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 986 986 if let Some(ref value) = self.time_since_generation { 987 987 if *value < 0i64 { 988 988 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 989 989 - field: "time_since_generation", 988 988 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 989 989 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 990 990 + "time_since_generation", 991 991 + ), 990 992 min: 0i64, 991 993 actual: *value, 992 994 }); ··· 994 996 } 995 997 if let Some(ref value) = self.time_since_viewed { 996 998 if *value < 0i64 { 997 997 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 998 998 - field: "time_since_viewed", 999 999 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1000 1000 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1001 1001 + "time_since_viewed", 1002 1002 + ), 999 1003 min: 0i64, 1000 1004 actual: *value, 1001 1005 }); ··· 1047 1051 } 1048 1052 fn validate( 1049 1053 &self, 1050 1050 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1054 1054 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1051 1055 if let Some(ref value) = self.rewards_count { 1052 1056 if *value < 1i64 { 1053 1053 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1054 1054 - field: "rewards_count", 1057 1057 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1058 1058 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1059 1059 + "rewards_count", 1060 1060 + ), 1055 1061 min: 1i64, 1056 1062 actual: *value, 1057 1063 }); ··· 1059 1065 } 1060 1066 if let Some(ref value) = self.streak { 1061 1067 if *value < 1i64 { 1062 1062 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1063 1063 - field: "streak", 1068 1068 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1069 1069 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1070 1070 + "streak", 1071 1071 + ), 1064 1072 min: 1i64, 1065 1073 actual: *value, 1066 1074 }); ··· 1068 1076 } 1069 1077 if let Some(ref value) = self.time_since_last_claim { 1070 1078 if *value < 0i64 { 1071 1071 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1072 1072 - field: "time_since_last_claim", 1079 1079 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1080 1080 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1081 1081 + "time_since_last_claim", 1082 1082 + ), 1073 1083 min: 0i64, 1074 1084 actual: *value, 1075 1085 }); ··· 1120 1130 } 1121 1131 fn validate( 1122 1132 &self, 1123 1123 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1133 1133 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1124 1134 if let Some(ref value) = self.game_card_count { 1125 1135 if *value < 0i64 { 1126 1126 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1127 1127 - field: "game_card_count", 1136 1136 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1137 1137 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1138 1138 + "game_card_count", 1139 1139 + ), 1128 1140 min: 0i64, 1129 1141 actual: *value, 1130 1142 }); ··· 1132 1144 } 1133 1145 if let Some(ref value) = self.post_count { 1134 1146 if *value < 0i64 { 1135 1135 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1136 1136 - field: "post_count", 1147 1147 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1148 1148 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1149 1149 + "post_count", 1150 1150 + ), 1137 1151 min: 0i64, 1138 1152 actual: *value, 1139 1153 }); ··· 1141 1155 } 1142 1156 if let Some(ref value) = self.scroll_position { 1143 1157 if *value < 0i64 { 1144 1144 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1145 1145 - field: "scroll_position", 1158 1158 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1159 1159 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1160 1160 + "scroll_position", 1161 1161 + ), 1146 1162 min: 0i64, 1147 1163 actual: *value, 1148 1164 }); ··· 1206 1222 } 1207 1223 fn validate( 1208 1224 &self, 1209 1209 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1225 1225 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1210 1226 if let Some(ref value) = self.injection_position { 1211 1227 if *value < 0i64 { 1212 1212 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1213 1213 - field: "injection_position", 1228 1228 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1229 1229 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1230 1230 + "injection_position", 1231 1231 + ), 1214 1232 min: 0i64, 1215 1233 actual: *value, 1216 1234 }); ··· 1218 1236 } 1219 1237 if let Some(ref value) = self.quantity { 1220 1238 if *value < 1i64 { 1221 1221 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1222 1222 - field: "quantity", 1239 1239 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1240 1240 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1241 1241 + "quantity", 1242 1242 + ), 1223 1243 min: 1i64, 1224 1244 actual: *value, 1225 1245 }); ··· 1275 1295 } 1276 1296 fn validate( 1277 1297 &self, 1278 1278 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1298 1298 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1279 1299 if let Some(ref value) = self.quantity_used { 1280 1300 if *value < 1i64 { 1281 1281 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1282 1282 - field: "quantity_used", 1301 1301 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1302 1302 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1303 1303 + "quantity_used", 1304 1304 + ), 1283 1305 min: 1i64, 1284 1306 actual: *value, 1285 1307 }); ··· 1287 1309 } 1288 1310 if let Some(ref value) = self.remaining_quantity { 1289 1311 if *value < 0i64 { 1290 1290 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1291 1291 - field: "remaining_quantity", 1312 1312 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1313 1313 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1314 1314 + "remaining_quantity", 1315 1315 + ), 1292 1316 min: 0i64, 1293 1317 actual: *value, 1294 1318 }); ··· 1447 1471 } 1448 1472 fn validate( 1449 1473 &self, 1450 1450 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1474 1474 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1451 1475 { 1452 1476 let value = &self.session_id; 1453 1477 #[allow(unused_comparisons)] 1454 1478 if <str>::len(value.as_ref()) > 64usize { 1455 1455 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1456 1456 - field: "session_id", 1479 1479 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 1480 1480 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1481 1481 + "session_id", 1482 1482 + ), 1457 1483 max: 64usize, 1458 1484 actual: <str>::len(value.as_ref()), 1459 1485 }); ··· 1508 1534 } 1509 1535 fn validate( 1510 1536 &self, 1511 1511 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1537 1537 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1512 1538 if let Some(ref value) = self.network_latency { 1513 1539 if *value < 0i64 { 1514 1514 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1515 1515 - field: "network_latency", 1540 1540 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1541 1541 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1542 1542 + "network_latency", 1543 1543 + ), 1516 1544 min: 0i64, 1517 1545 actual: *value, 1518 1546 }); ··· 1558 1586 } 1559 1587 fn validate( 1560 1588 &self, 1561 1561 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1589 1589 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1562 1590 if let Some(ref value) = self.quantity { 1563 1591 if *value < 1i64 { 1564 1564 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1565 1565 - field: "quantity", 1592 1592 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1593 1593 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1594 1594 + "quantity", 1595 1595 + ), 1566 1596 min: 1i64, 1567 1597 actual: *value, 1568 1598 });

+19 -11

crates/jacquard-api/src/net_anisota/beta/game/pack.rs

··· 117 117 } 118 118 fn validate( 119 119 &self, 120 120 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 120 120 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 121 121 if let Some(ref value) = self.longest_streak { 122 122 if *value < 0i64 { 123 123 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 124 124 - field: "longest_streak", 123 123 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 124 124 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 125 125 + "longest_streak", 126 126 + ), 125 127 min: 0i64, 126 128 actual: *value, 127 129 }); ··· 130 132 if let Some(ref value) = self.pack_history { 131 133 #[allow(unused_comparisons)] 132 134 if value.len() > 30usize { 133 133 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 134 134 - field: "pack_history", 135 135 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 136 136 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 137 137 + "pack_history", 138 138 + ), 135 139 max: 30usize, 136 140 actual: value.len(), 137 141 }); ··· 140 144 { 141 145 let value = &self.streak; 142 146 if *value < 0i64 { 143 143 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 144 144 - field: "streak", 147 147 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 148 148 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 149 149 + "streak", 150 150 + ), 145 151 min: 0i64, 146 152 actual: *value, 147 153 }); ··· 150 156 { 151 157 let value = &self.total_opens; 152 158 if *value < 0i64 { 153 153 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 154 154 - field: "total_opens", 159 159 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 160 160 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 161 161 + "total_opens", 162 162 + ), 155 163 min: 0i64, 156 164 actual: *value, 157 165 }); ··· 505 513 } 506 514 fn validate( 507 515 &self, 508 508 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 516 516 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 509 517 Ok(()) 510 518 } 511 519 } ··· 549 557 } 550 558 fn validate( 551 559 &self, 552 552 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 560 560 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 553 561 Ok(()) 554 562 } 555 563 }

+51 -27

crates/jacquard-api/src/net_anisota/beta/game/progress.rs

··· 152 152 } 153 153 fn validate( 154 154 &self, 155 155 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 155 155 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 156 156 { 157 157 let value = &self.level; 158 158 if *value < 1i64 { 159 159 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 160 160 - field: "level", 159 159 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 160 160 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 161 161 + "level", 162 162 + ), 161 163 min: 1i64, 162 164 actual: *value, 163 165 }); ··· 165 167 } 166 168 if let Some(ref value) = self.previous_level { 167 169 if *value < 1i64 { 168 168 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 169 169 - field: "previous_level", 170 170 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 171 171 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 172 172 + "previous_level", 173 173 + ), 170 174 min: 1i64, 171 175 actual: *value, 172 176 }); ··· 175 179 { 176 180 let value = &self.total_xp; 177 181 if *value < 0i64 { 178 178 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 179 179 - field: "total_xp", 182 182 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 183 183 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 184 184 + "total_xp", 185 185 + ), 180 186 min: 0i64, 181 187 actual: *value, 182 188 }); ··· 184 190 } 185 191 if let Some(ref value) = self.xp_gained_since_last_save { 186 192 if *value < 0i64 { 187 187 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 188 188 - field: "xp_gained_since_last_save", 193 193 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 194 194 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 195 195 + "xp_gained_since_last_save", 196 196 + ), 189 197 min: 0i64, 190 198 actual: *value, 191 199 }); ··· 194 202 { 195 203 let value = &self.xp_to_next_level; 196 204 if *value < 0i64 { 197 197 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 198 198 - field: "xp_to_next_level", 205 205 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 206 206 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 207 207 + "xp_to_next_level", 208 208 + ), 199 209 min: 0i64, 200 210 actual: *value, 201 211 }); ··· 723 733 } 724 734 fn validate( 725 735 &self, 726 726 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 736 736 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 727 737 Ok(()) 728 738 } 729 739 } ··· 782 792 } 783 793 fn validate( 784 794 &self, 785 785 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 795 795 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 786 796 if let Some(ref value) = self.daily_rewards_claimed { 787 797 if *value < 0i64 { 788 788 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 789 789 - field: "daily_rewards_claimed", 798 798 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 799 799 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 800 800 + "daily_rewards_claimed", 801 801 + ), 790 802 min: 0i64, 791 803 actual: *value, 792 804 }); ··· 794 806 } 795 807 if let Some(ref value) = self.items_collected { 796 808 if *value < 0i64 { 797 797 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 798 798 - field: "items_collected", 809 809 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 810 810 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 811 811 + "items_collected", 812 812 + ), 799 813 min: 0i64, 800 814 actual: *value, 801 815 }); ··· 803 817 } 804 818 if let Some(ref value) = self.posts_read_today { 805 819 if *value < 0i64 { 806 806 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 807 807 - field: "posts_read_today", 820 820 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 821 821 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 822 822 + "posts_read_today", 823 823 + ), 808 824 min: 0i64, 809 825 actual: *value, 810 826 }); ··· 812 828 } 813 829 if let Some(ref value) = self.posts_read_total { 814 830 if *value < 0i64 { 815 815 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 816 816 - field: "posts_read_total", 831 831 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 832 832 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 833 833 + "posts_read_total", 834 834 + ), 817 835 min: 0i64, 818 836 actual: *value, 819 837 }); ··· 821 839 } 822 840 if let Some(ref value) = self.posts_viewed { 823 841 if *value < 0i64 { 824 824 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 825 825 - field: "posts_viewed", 842 842 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 843 843 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 844 844 + "posts_viewed", 845 845 + ), 826 846 min: 0i64, 827 847 actual: *value, 828 848 }); ··· 830 850 } 831 851 if let Some(ref value) = self.shuffles_performed { 832 852 if *value < 0i64 { 833 833 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 834 834 - field: "shuffles_performed", 853 853 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 854 854 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 855 855 + "shuffles_performed", 856 856 + ), 835 857 min: 0i64, 836 858 actual: *value, 837 859 }); ··· 839 861 } 840 862 if let Some(ref value) = self.specimens_collected { 841 863 if *value < 0i64 { 842 842 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 843 843 - field: "specimens_collected", 864 864 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 865 865 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 866 866 + "specimens_collected", 867 867 + ), 844 868 min: 0i64, 845 869 actual: *value, 846 870 });

+58 -32

crates/jacquard-api/src/net_anisota/beta/game/session.rs

··· 834 834 } 835 835 fn validate( 836 836 &self, 837 837 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 837 837 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 838 838 if let Some(ref value) = self.current_level { 839 839 if *value < 1i64 { 840 840 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 841 841 - field: "current_level", 840 840 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 841 841 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 842 842 + "current_level", 843 843 + ), 842 844 min: 1i64, 843 845 actual: *value, 844 846 }); ··· 846 848 } 847 849 if let Some(ref value) = self.current_xp { 848 850 if *value < 0i64 { 849 849 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 850 850 - field: "current_xp", 851 851 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 852 852 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 853 853 + "current_xp", 854 854 + ), 851 855 min: 0i64, 852 856 actual: *value, 853 857 }); ··· 855 859 } 856 860 if let Some(ref value) = self.total_events { 857 861 if *value < 0i64 { 858 858 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 859 859 - field: "total_events", 862 862 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 863 863 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 864 864 + "total_events", 865 865 + ), 860 866 min: 0i64, 861 867 actual: *value, 862 868 }); ··· 864 870 } 865 871 if let Some(ref value) = self.xp_gained_this_session { 866 872 if *value < 0i64 { 867 867 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 868 868 - field: "xp_gained_this_session", 873 873 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 874 874 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 875 875 + "xp_gained_this_session", 876 876 + ), 869 877 min: 0i64, 870 878 actual: *value, 871 879 }); ··· 915 923 } 916 924 fn validate( 917 925 &self, 918 918 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 926 926 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 919 927 if let Some(ref value) = self.daily_rewards_claimed { 920 928 if *value < 0i64 { 921 921 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 922 922 - field: "daily_rewards_claimed", 929 929 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 930 930 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 931 931 + "daily_rewards_claimed", 932 932 + ), 923 933 min: 0i64, 924 934 actual: *value, 925 935 }); ··· 927 937 } 928 938 if let Some(ref value) = self.feeds_loaded { 929 939 if *value < 0i64 { 930 930 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 931 931 - field: "feeds_loaded", 940 940 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 941 941 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 942 942 + "feeds_loaded", 943 943 + ), 932 944 min: 0i64, 933 945 actual: *value, 934 946 }); ··· 936 948 } 937 949 if let Some(ref value) = self.items_collected { 938 950 if *value < 0i64 { 939 939 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 940 940 - field: "items_collected", 951 951 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 952 952 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 953 953 + "items_collected", 954 954 + ), 941 955 min: 0i64, 942 956 actual: *value, 943 957 }); ··· 945 959 } 946 960 if let Some(ref value) = self.level_ups { 947 961 if *value < 0i64 { 948 948 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 949 949 - field: "level_ups", 962 962 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 963 963 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 964 964 + "level_ups", 965 965 + ), 950 966 min: 0i64, 951 967 actual: *value, 952 968 }); ··· 954 970 } 955 971 if let Some(ref value) = self.posts_viewed { 956 972 if *value < 0i64 { 957 957 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 958 958 - field: "posts_viewed", 973 973 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 974 974 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 975 975 + "posts_viewed", 976 976 + ), 959 977 min: 0i64, 960 978 actual: *value, 961 979 }); ··· 963 981 } 964 982 if let Some(ref value) = self.specimens_collected { 965 983 if *value < 0i64 { 966 966 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 967 967 - field: "specimens_collected", 984 984 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 985 985 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 986 986 + "specimens_collected", 987 987 + ), 968 988 min: 0i64, 969 989 actual: *value, 970 990 }); ··· 1138 1158 } 1139 1159 fn validate( 1140 1160 &self, 1141 1141 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1161 1161 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1142 1162 if let Some(ref value) = self.duration { 1143 1163 if *value < 0i64 { 1144 1144 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1145 1145 - field: "duration", 1164 1164 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1165 1165 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1166 1166 + "duration", 1167 1167 + ), 1146 1168 min: 0i64, 1147 1169 actual: *value, 1148 1170 }); ··· 1193 1215 } 1194 1216 fn validate( 1195 1217 &self, 1196 1196 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1218 1218 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1197 1219 Ok(()) 1198 1220 } 1199 1221 } ··· 1232 1254 } 1233 1255 fn validate( 1234 1256 &self, 1235 1235 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1257 1257 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1236 1258 if let Some(ref value) = self.average_response_time { 1237 1259 if *value < 0i64 { 1238 1238 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1239 1239 - field: "average_response_time", 1260 1260 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1261 1261 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1262 1262 + "average_response_time", 1263 1263 + ), 1240 1264 min: 0i64, 1241 1265 actual: *value, 1242 1266 }); ··· 1244 1268 } 1245 1269 if let Some(ref value) = self.error_count { 1246 1270 if *value < 0i64 { 1247 1247 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1248 1248 - field: "error_count", 1271 1271 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1272 1272 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1273 1273 + "error_count", 1274 1274 + ), 1249 1275 min: 0i64, 1250 1276 actual: *value, 1251 1277 }); ··· 1298 1324 } 1299 1325 fn validate( 1300 1326 &self, 1301 1301 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1327 1327 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1302 1328 Ok(()) 1303 1329 } 1304 1330 }

+18 -10

crates/jacquard-api/src/net_anisota/feed/draft.rs

··· 156 156 } 157 157 fn validate( 158 158 &self, 159 159 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 159 159 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 160 160 if let Some(ref value) = self.langs { 161 161 #[allow(unused_comparisons)] 162 162 if value.len() > 3usize { 163 163 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 164 164 - field: "langs", 163 163 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 164 164 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 165 165 + "langs", 166 166 + ), 165 167 max: 3usize, 166 168 actual: value.len(), 167 169 }); ··· 170 172 if let Some(ref value) = self.tags { 171 173 #[allow(unused_comparisons)] 172 174 if value.len() > 8usize { 173 173 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 174 174 - field: "tags", 175 175 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 176 176 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 177 177 + "tags", 178 178 + ), 175 179 max: 8usize, 176 180 actual: value.len(), 177 181 }); ··· 181 185 let value = &self.text; 182 186 #[allow(unused_comparisons)] 183 187 if <str>::len(value.as_ref()) > 3000usize { 184 184 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 185 185 - field: "text", 188 188 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 189 189 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 190 190 + "text", 191 191 + ), 186 192 max: 3000usize, 187 193 actual: <str>::len(value.as_ref()), 188 194 }); ··· 197 203 ) 198 204 .count(); 199 205 if count > 300usize { 200 200 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 201 201 - field: "text", 206 206 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 207 207 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 208 208 + "text", 209 209 + ), 202 210 max: 300usize, 203 211 actual: count, 204 212 }); ··· 485 493 } 486 494 fn validate( 487 495 &self, 488 488 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 496 496 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 489 497 Ok(()) 490 498 } 491 499 }

+1 -1

crates/jacquard-api/src/net_anisota/feed/like.rs

··· 99 99 } 100 100 fn validate( 101 101 &self, 102 102 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 102 102 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 103 103 Ok(()) 104 104 } 105 105 }

+13 -7

crates/jacquard-api/src/net_anisota/feed/list.rs

··· 115 115 } 116 116 fn validate( 117 117 &self, 118 118 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 118 118 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 119 119 if let Some(ref value) = self.description { 120 120 #[allow(unused_comparisons)] 121 121 if <str>::len(value.as_ref()) > 300usize { 122 122 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 123 123 - field: "description", 122 122 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 123 123 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 124 124 + "description", 125 125 + ), 124 126 max: 300usize, 125 127 actual: <str>::len(value.as_ref()), 126 128 }); ··· 130 132 let value = &self.name; 131 133 #[allow(unused_comparisons)] 132 134 if <str>::len(value.as_ref()) > 64usize { 133 133 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 134 134 - field: "name", 135 135 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 136 136 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 137 137 + "name", 138 138 + ), 135 139 max: 64usize, 136 140 actual: <str>::len(value.as_ref()), 137 141 }); ··· 140 144 if let Some(ref value) = self.tags { 141 145 #[allow(unused_comparisons)] 142 146 if value.len() > 10usize { 143 143 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 144 144 - field: "tags", 147 147 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 148 148 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 149 149 + "tags", 150 150 + ), 145 151 max: 10usize, 146 152 actual: value.len(), 147 153 });

+1 -1

crates/jacquard-api/src/net_anisota/feed/list_item.rs

··· 102 102 } 103 103 fn validate( 104 104 &self, 105 105 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 105 105 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 106 106 Ok(()) 107 107 } 108 108 }

+18 -10

crates/jacquard-api/src/net_anisota/feed/post.rs

··· 152 152 } 153 153 fn validate( 154 154 &self, 155 155 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 155 155 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 156 156 if let Some(ref value) = self.langs { 157 157 #[allow(unused_comparisons)] 158 158 if value.len() > 3usize { 159 159 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 160 160 - field: "langs", 159 159 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 160 160 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 161 161 + "langs", 162 162 + ), 161 163 max: 3usize, 162 164 actual: value.len(), 163 165 }); ··· 166 168 if let Some(ref value) = self.tags { 167 169 #[allow(unused_comparisons)] 168 170 if value.len() > 8usize { 169 169 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 170 170 - field: "tags", 171 171 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 172 172 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 173 173 + "tags", 174 174 + ), 171 175 max: 8usize, 172 176 actual: value.len(), 173 177 }); ··· 177 181 let value = &self.text; 178 182 #[allow(unused_comparisons)] 179 183 if <str>::len(value.as_ref()) > 3000usize { 180 180 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 181 181 - field: "text", 184 184 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 185 185 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 186 186 + "text", 187 187 + ), 182 188 max: 3000usize, 183 189 actual: <str>::len(value.as_ref()), 184 190 }); ··· 193 199 ) 194 200 .count(); 195 201 if count > 300usize { 196 196 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 197 197 - field: "text", 202 202 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 203 203 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 204 204 + "text", 205 205 + ), 198 206 max: 300usize, 199 207 actual: count, 200 208 }); ··· 458 466 } 459 467 fn validate( 460 468 &self, 461 461 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 469 469 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 462 470 Ok(()) 463 471 } 464 472 }

+1 -1

crates/jacquard-api/src/net_anisota/feed/repost.rs

··· 99 99 } 100 100 fn validate( 101 101 &self, 102 102 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 102 102 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 103 103 Ok(()) 104 104 } 105 105 }

+10 -6

crates/jacquard-api/src/net_anisota/graph/list_mute.rs

··· 260 260 } 261 261 fn validate( 262 262 &self, 263 263 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 263 263 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 264 264 Ok(()) 265 265 } 266 266 } ··· 378 378 } 379 379 fn validate( 380 380 &self, 381 381 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 381 381 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 382 382 if let Some(ref value) = self.reason { 383 383 #[allow(unused_comparisons)] 384 384 if <str>::len(value.as_ref()) > 300usize { 385 385 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 386 386 - field: "reason", 385 385 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 386 386 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 387 387 + "reason", 388 388 + ), 387 389 max: 300usize, 388 390 actual: <str>::len(value.as_ref()), 389 391 }); ··· 392 394 if let Some(ref value) = self.target_feeds { 393 395 #[allow(unused_comparisons)] 394 396 if value.len() > 50usize { 395 395 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 396 396 - field: "target_feeds", 397 397 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 398 398 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 399 399 + "target_feeds", 400 400 + ), 397 401 max: 50usize, 398 402 actual: value.len(), 399 403 });

+10 -6

crates/jacquard-api/src/net_anisota/graph/mute.rs

··· 260 260 } 261 261 fn validate( 262 262 &self, 263 263 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 263 263 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 264 264 Ok(()) 265 265 } 266 266 } ··· 378 378 } 379 379 fn validate( 380 380 &self, 381 381 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 381 381 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 382 382 if let Some(ref value) = self.reason { 383 383 #[allow(unused_comparisons)] 384 384 if <str>::len(value.as_ref()) > 300usize { 385 385 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 386 386 - field: "reason", 385 385 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 386 386 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 387 387 + "reason", 388 388 + ), 387 389 max: 300usize, 388 390 actual: <str>::len(value.as_ref()), 389 391 }); ··· 392 394 if let Some(ref value) = self.target_feeds { 393 395 #[allow(unused_comparisons)] 394 396 if value.len() > 50usize { 395 395 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 396 396 - field: "target_feeds", 397 397 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 398 398 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 399 399 + "target_feeds", 400 400 + ), 397 401 max: 50usize, 398 402 actual: value.len(), 399 403 });

+17 -9

crates/jacquard-api/src/net_bnewbold/demo/mushies.rs

··· 104 104 } 105 105 fn validate( 106 106 &self, 107 107 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 107 107 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 108 108 { 109 109 let value = &self.common_name; 110 110 #[allow(unused_comparisons)] 111 111 if <str>::len(value.as_ref()) > 2560usize { 112 112 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 113 113 - field: "common_name", 112 112 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 113 113 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 114 114 + "common_name", 115 115 + ), 114 116 max: 2560usize, 115 117 actual: <str>::len(value.as_ref()), 116 118 }); ··· 125 127 ) 126 128 .count(); 127 129 if count > 256usize { 128 128 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 129 129 - field: "common_name", 130 130 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 131 131 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 132 132 + "common_name", 133 133 + ), 130 134 max: 256usize, 131 135 actual: count, 132 136 }); ··· 136 140 if let Some(ref value) = self.species { 137 141 #[allow(unused_comparisons)] 138 142 if <str>::len(value.as_ref()) > 2560usize { 139 139 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 140 140 - field: "species", 143 143 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 144 144 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 145 145 + "species", 146 146 + ), 141 147 max: 2560usize, 142 148 actual: <str>::len(value.as_ref()), 143 149 }); ··· 151 157 ) 152 158 .count(); 153 159 if count > 256usize { 154 154 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 155 155 - field: "species", 160 160 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 161 161 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 162 162 + "species", 163 163 + ), 156 164 max: 256usize, 157 165 actual: count, 158 166 });

+17 -9

crates/jacquard-api/src/net_bnewbold/demo/mushroom.rs

··· 104 104 } 105 105 fn validate( 106 106 &self, 107 107 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 107 107 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 108 108 { 109 109 let value = &self.common_name; 110 110 #[allow(unused_comparisons)] 111 111 if <str>::len(value.as_ref()) > 2560usize { 112 112 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 113 113 - field: "common_name", 112 112 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 113 113 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 114 114 + "common_name", 115 115 + ), 114 116 max: 2560usize, 115 117 actual: <str>::len(value.as_ref()), 116 118 }); ··· 125 127 ) 126 128 .count(); 127 129 if count > 256usize { 128 128 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 129 129 - field: "common_name", 130 130 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 131 131 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 132 132 + "common_name", 133 133 + ), 130 134 max: 256usize, 131 135 actual: count, 132 136 }); ··· 136 140 if let Some(ref value) = self.species { 137 141 #[allow(unused_comparisons)] 138 142 if <str>::len(value.as_ref()) > 2560usize { 139 139 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 140 140 - field: "species", 143 143 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 144 144 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 145 145 + "species", 146 146 + ), 141 147 max: 2560usize, 142 148 actual: <str>::len(value.as_ref()), 143 149 }); ··· 151 157 ) 152 158 .count(); 153 159 if count > 256usize { 154 154 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 155 155 - field: "species", 160 160 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 161 161 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 162 162 + "species", 163 163 + ), 156 164 max: 256usize, 157 165 actual: count, 158 166 });

+17 -9

crates/jacquard-api/src/net_bnewbold/m.rs

··· 104 104 } 105 105 fn validate( 106 106 &self, 107 107 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 107 107 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 108 108 { 109 109 let value = &self.common_name; 110 110 #[allow(unused_comparisons)] 111 111 if <str>::len(value.as_ref()) > 2560usize { 112 112 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 113 113 - field: "common_name", 112 112 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 113 113 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 114 114 + "common_name", 115 115 + ), 114 116 max: 2560usize, 115 117 actual: <str>::len(value.as_ref()), 116 118 }); ··· 125 127 ) 126 128 .count(); 127 129 if count > 256usize { 128 128 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 129 129 - field: "common_name", 130 130 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 131 131 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 132 132 + "common_name", 133 133 + ), 130 134 max: 256usize, 131 135 actual: count, 132 136 }); ··· 136 140 if let Some(ref value) = self.species { 137 141 #[allow(unused_comparisons)] 138 142 if <str>::len(value.as_ref()) > 2560usize { 139 139 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 140 140 - field: "species", 143 143 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 144 144 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 145 145 + "species", 146 146 + ), 141 147 max: 2560usize, 142 148 actual: <str>::len(value.as_ref()), 143 149 }); ··· 151 157 ) 152 158 .count(); 153 159 if count > 256usize { 154 154 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 155 155 - field: "species", 160 160 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 161 161 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 162 162 + "species", 163 163 + ), 156 164 max: 256usize, 157 165 actual: count, 158 166 });

+1 -1

crates/jacquard-api/src/net_mmatt/right/now.rs

··· 105 105 } 106 106 fn validate( 107 107 &self, 108 108 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 108 108 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 109 109 Ok(()) 110 110 } 111 111 }

+1 -1

crates/jacquard-api/src/net_mmatt/vitals/car.rs

··· 121 121 } 122 122 fn validate( 123 123 &self, 124 124 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 124 124 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 125 125 Ok(()) 126 126 } 127 127 }

+17 -9

crates/jacquard-api/src/network_slices/actor.rs

··· 171 171 } 172 172 fn validate( 173 173 &self, 174 174 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 174 174 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 175 175 if let Some(ref value) = self.description { 176 176 #[allow(unused_comparisons)] 177 177 if <str>::len(value.as_ref()) > 2560usize { 178 178 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 179 179 - field: "description", 178 178 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 179 179 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 180 180 + "description", 181 181 + ), 180 182 max: 2560usize, 181 183 actual: <str>::len(value.as_ref()), 182 184 }); ··· 190 192 ) 191 193 .count(); 192 194 if count > 256usize { 193 193 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 194 194 - field: "description", 195 195 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 196 196 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 197 197 + "description", 198 198 + ), 195 199 max: 256usize, 196 200 actual: count, 197 201 }); ··· 201 205 if let Some(ref value) = self.display_name { 202 206 #[allow(unused_comparisons)] 203 207 if <str>::len(value.as_ref()) > 640usize { 204 204 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 205 205 - field: "display_name", 208 208 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 209 209 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 210 210 + "display_name", 211 211 + ), 206 212 max: 640usize, 207 213 actual: <str>::len(value.as_ref()), 208 214 }); ··· 216 222 ) 217 223 .count(); 218 224 if count > 64usize { 219 219 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 220 220 - field: "display_name", 225 225 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 226 226 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 227 227 + "display_name", 228 228 + ), 221 229 max: 64usize, 222 230 actual: count, 223 231 });

+17 -9

crates/jacquard-api/src/network_slices/actor/profile.rs

··· 111 111 } 112 112 fn validate( 113 113 &self, 114 114 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 114 114 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 115 115 if let Some(ref value) = self.description { 116 116 #[allow(unused_comparisons)] 117 117 if <str>::len(value.as_ref()) > 2560usize { 118 118 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 119 119 - field: "description", 118 118 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 119 119 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 120 120 + "description", 121 121 + ), 120 122 max: 2560usize, 121 123 actual: <str>::len(value.as_ref()), 122 124 }); ··· 130 132 ) 131 133 .count(); 132 134 if count > 256usize { 133 133 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 134 134 - field: "description", 135 135 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 136 136 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 137 137 + "description", 138 138 + ), 135 139 max: 256usize, 136 140 actual: count, 137 141 }); ··· 141 145 if let Some(ref value) = self.display_name { 142 146 #[allow(unused_comparisons)] 143 147 if <str>::len(value.as_ref()) > 640usize { 144 144 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 145 145 - field: "display_name", 148 148 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 149 149 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 150 150 + "display_name", 151 151 + ), 146 152 max: 640usize, 147 153 actual: <str>::len(value.as_ref()), 148 154 }); ··· 156 162 ) 157 163 .count(); 158 164 if count > 64usize { 159 159 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 160 160 - field: "display_name", 165 165 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 166 166 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 167 167 + "display_name", 168 168 + ), 161 169 max: 64usize, 162 170 actual: count, 163 171 });

+9 -5

crates/jacquard-api/src/network_slices/lexicon.rs

··· 119 119 } 120 120 fn validate( 121 121 &self, 122 122 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 122 122 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 123 123 if let Some(ref value) = self.description { 124 124 #[allow(unused_comparisons)] 125 125 if <str>::len(value.as_ref()) > 500usize { 126 126 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 127 127 - field: "description", 126 126 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 127 127 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 128 128 + "description", 129 129 + ), 128 130 max: 500usize, 129 131 actual: <str>::len(value.as_ref()), 130 132 }); ··· 134 136 let value = &self.nsid; 135 137 #[allow(unused_comparisons)] 136 138 if <str>::len(value.as_ref()) > 256usize { 137 137 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 138 138 - field: "nsid", 139 139 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 140 140 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 141 141 + "nsid", 142 142 + ), 139 143 max: 256usize, 140 144 actual: <str>::len(value.as_ref()), 141 145 });

+15 -9

crates/jacquard-api/src/network_slices/slice.rs

··· 120 120 } 121 121 fn validate( 122 122 &self, 123 123 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 123 123 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 124 124 { 125 125 let value = &self.domain; 126 126 #[allow(unused_comparisons)] 127 127 if <str>::len(value.as_ref()) > 256usize { 128 128 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 129 129 - field: "domain", 128 128 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 129 129 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 130 130 + "domain", 131 131 + ), 130 132 max: 256usize, 131 133 actual: <str>::len(value.as_ref()), 132 134 }); ··· 136 138 let value = &self.name; 137 139 #[allow(unused_comparisons)] 138 140 if <str>::len(value.as_ref()) > 256usize { 139 139 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 140 140 - field: "name", 141 141 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 142 142 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 143 143 + "name", 144 144 + ), 141 145 max: 256usize, 142 146 actual: <str>::len(value.as_ref()), 143 147 }); ··· 582 586 } 583 587 fn validate( 584 588 &self, 585 585 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 589 589 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 586 590 Ok(()) 587 591 } 588 592 } ··· 616 620 } 617 621 fn validate( 618 622 &self, 619 619 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 623 623 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 620 624 { 621 625 let value = &self.count; 622 626 if *value < 0i64 { 623 623 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 624 624 - field: "count", 627 627 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 628 628 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 629 629 + "count", 630 630 + ), 625 631 min: 0i64, 626 632 actual: *value, 627 633 });

+1 -1

crates/jacquard-api/src/network_slices/slice/get_actors.rs

··· 250 250 } 251 251 fn validate( 252 252 &self, 253 253 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 253 253 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 254 254 Ok(()) 255 255 } 256 256 }

+1 -1

crates/jacquard-api/src/network_slices/slice/get_job_logs.rs

··· 307 307 } 308 308 fn validate( 309 309 &self, 310 310 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 310 310 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 311 311 Ok(()) 312 312 } 313 313 }

+2 -2

crates/jacquard-api/src/network_slices/slice/get_job_status.rs

··· 387 387 } 388 388 fn validate( 389 389 &self, 390 390 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 390 390 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 391 391 Ok(()) 392 392 } 393 393 } ··· 493 493 } 494 494 fn validate( 495 495 &self, 496 496 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 496 496 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 497 497 Ok(()) 498 498 } 499 499 }

+1 -1

crates/jacquard-api/src/network_slices/slice/get_o_auth_clients.rs

··· 516 516 } 517 517 fn validate( 518 518 &self, 519 519 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 519 519 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 520 520 Ok(()) 521 521 } 522 522 }

+1 -1

crates/jacquard-api/src/network_slices/slice/get_slice_records.rs

··· 295 295 } 296 296 fn validate( 297 297 &self, 298 298 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 298 298 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 299 299 Ok(()) 300 300 } 301 301 }

+1 -1

crates/jacquard-api/src/network_slices/slice/get_sparklines.rs

··· 287 287 } 288 288 fn validate( 289 289 &self, 290 290 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 290 290 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 291 291 Ok(()) 292 292 } 293 293 }

+1 -1

crates/jacquard-api/src/network_slices/slice/get_sync_summary.rs

··· 217 217 } 218 218 fn validate( 219 219 &self, 220 220 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 220 220 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 221 221 Ok(()) 222 222 } 223 223 }

+1 -1

crates/jacquard-api/src/network_slices/slice/stats.rs

··· 162 162 } 163 163 fn validate( 164 164 &self, 165 165 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 165 165 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 166 166 Ok(()) 167 167 } 168 168 }

+2 -2

crates/jacquard-api/src/network_slices/waitlist.rs

··· 289 289 } 290 290 fn validate( 291 291 &self, 292 292 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 292 292 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 293 293 Ok(()) 294 294 } 295 295 } ··· 332 332 } 333 333 fn validate( 334 334 &self, 335 335 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 335 335 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 336 336 Ok(()) 337 337 } 338 338 }

+1 -1

crates/jacquard-api/src/network_slices/waitlist/invite.rs

··· 106 106 } 107 107 fn validate( 108 108 &self, 109 109 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 109 109 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 110 110 Ok(()) 111 111 } 112 112 }

+1 -1

crates/jacquard-api/src/network_slices/waitlist/request.rs

··· 99 99 } 100 100 fn validate( 101 101 &self, 102 102 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 102 102 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 103 103 Ok(()) 104 104 } 105 105 }

+1 -1

crates/jacquard-api/src/org_devcon/event/test.rs

··· 119 119 } 120 120 fn validate( 121 121 &self, 122 122 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 122 122 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 123 123 Ok(()) 124 124 } 125 125 }

+17 -9

crates/jacquard-api/src/org_robocracy/demo/fungus.rs

··· 104 104 } 105 105 fn validate( 106 106 &self, 107 107 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 107 107 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 108 108 { 109 109 let value = &self.common_name; 110 110 #[allow(unused_comparisons)] 111 111 if <str>::len(value.as_ref()) > 2560usize { 112 112 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 113 113 - field: "common_name", 112 112 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 113 113 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 114 114 + "common_name", 115 115 + ), 114 116 max: 2560usize, 115 117 actual: <str>::len(value.as_ref()), 116 118 }); ··· 125 127 ) 126 128 .count(); 127 129 if count > 256usize { 128 128 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 129 129 - field: "common_name", 130 130 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 131 131 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 132 132 + "common_name", 133 133 + ), 130 134 max: 256usize, 131 135 actual: count, 132 136 }); ··· 136 140 if let Some(ref value) = self.species { 137 141 #[allow(unused_comparisons)] 138 142 if <str>::len(value.as_ref()) > 2560usize { 139 139 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 140 140 - field: "species", 143 143 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 144 144 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 145 145 + "species", 146 146 + ), 141 147 max: 2560usize, 142 148 actual: <str>::len(value.as_ref()), 143 149 }); ··· 151 157 ) 152 158 .count(); 153 159 if count > 256usize { 154 154 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 155 155 - field: "species", 160 160 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 161 161 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 162 162 + "species", 163 163 + ), 156 164 max: 256usize, 157 165 actual: count, 158 166 });

+17 -9

crates/jacquard-api/src/org_robocracy/demo/mushies.rs

··· 104 104 } 105 105 fn validate( 106 106 &self, 107 107 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 107 107 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 108 108 { 109 109 let value = &self.common_name; 110 110 #[allow(unused_comparisons)] 111 111 if <str>::len(value.as_ref()) > 2560usize { 112 112 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 113 113 - field: "common_name", 112 112 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 113 113 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 114 114 + "common_name", 115 115 + ), 114 116 max: 2560usize, 115 117 actual: <str>::len(value.as_ref()), 116 118 }); ··· 125 127 ) 126 128 .count(); 127 129 if count > 256usize { 128 128 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 129 129 - field: "common_name", 130 130 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 131 131 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 132 132 + "common_name", 133 133 + ), 130 134 max: 256usize, 131 135 actual: count, 132 136 }); ··· 136 140 if let Some(ref value) = self.species { 137 141 #[allow(unused_comparisons)] 138 142 if <str>::len(value.as_ref()) > 2560usize { 139 139 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 140 140 - field: "species", 143 143 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 144 144 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 145 145 + "species", 146 146 + ), 141 147 max: 2560usize, 142 148 actual: <str>::len(value.as_ref()), 143 149 }); ··· 151 157 ) 152 158 .count(); 153 159 if count > 256usize { 154 154 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 155 155 - field: "species", 160 160 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 161 161 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 162 162 + "species", 163 163 + ), 156 164 max: 256usize, 157 165 actual: count, 158 166 });

+9 -5

crates/jacquard-api/src/place_atwork/endorsement.rs

··· 111 111 } 112 112 fn validate( 113 113 &self, 114 114 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 114 114 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 115 115 { 116 116 let value = &self.text; 117 117 #[allow(unused_comparisons)] 118 118 if <str>::len(value.as_ref()) > 1000usize { 119 119 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 120 120 - field: "text", 119 119 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 120 120 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 121 121 + "text", 122 122 + ), 121 123 max: 1000usize, 122 124 actual: <str>::len(value.as_ref()), 123 125 }); ··· 132 134 ) 133 135 .count(); 134 136 if count > 1000usize { 135 135 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 136 136 - field: "text", 137 137 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 138 138 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 139 139 + "text", 140 140 + ), 137 141 max: 1000usize, 138 142 actual: count, 139 143 });

+1 -1

crates/jacquard-api/src/place_atwork/endorsement_proof.rs

··· 97 97 } 98 98 fn validate( 99 99 &self, 100 100 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 100 100 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 101 101 Ok(()) 102 102 } 103 103 }

+1 -1

crates/jacquard-api/src/place_atwork/get_listings.rs

··· 191 191 } 192 192 fn validate( 193 193 &self, 194 194 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 194 194 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 195 195 Ok(()) 196 196 } 197 197 }

+13 -7

crates/jacquard-api/src/place_atwork/listing.rs

··· 126 126 } 127 127 fn validate( 128 128 &self, 129 129 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 129 129 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 130 130 { 131 131 let value = &self.description; 132 132 #[allow(unused_comparisons)] 133 133 if <str>::len(value.as_ref()) > 10000usize { 134 134 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 135 135 - field: "description", 134 134 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 135 135 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 136 136 + "description", 137 137 + ), 136 138 max: 10000usize, 137 139 actual: <str>::len(value.as_ref()), 138 140 }); ··· 147 149 ) 148 150 .count(); 149 151 if count > 10000usize { 150 150 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 151 151 - field: "description", 152 152 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 153 153 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 154 154 + "description", 155 155 + ), 152 156 max: 10000usize, 153 157 actual: count, 154 158 }); ··· 159 163 let value = &self.title; 160 164 #[allow(unused_comparisons)] 161 165 if <str>::len(value.as_ref()) > 200usize { 162 162 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 163 163 - field: "title", 166 166 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 167 167 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 168 168 + "title", 169 169 + ), 164 170 max: 200usize, 165 171 actual: <str>::len(value.as_ref()), 166 172 });

+17 -9

crates/jacquard-api/src/place_atwork/profile.rs

··· 170 170 } 171 171 fn validate( 172 172 &self, 173 173 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 173 173 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 174 174 if let Some(ref value) = self.description { 175 175 #[allow(unused_comparisons)] 176 176 if <str>::len(value.as_ref()) > 2000usize { 177 177 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 178 178 - field: "description", 177 177 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 178 178 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 179 179 + "description", 180 180 + ), 179 181 max: 2000usize, 180 182 actual: <str>::len(value.as_ref()), 181 183 }); ··· 189 191 ) 190 192 .count(); 191 193 if count > 2000usize { 192 192 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 193 193 - field: "description", 194 194 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 195 195 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 196 196 + "description", 197 197 + ), 194 198 max: 2000usize, 195 199 actual: count, 196 200 }); ··· 200 204 if let Some(ref value) = self.display_name { 201 205 #[allow(unused_comparisons)] 202 206 if <str>::len(value.as_ref()) > 200usize { 203 203 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 204 204 - field: "display_name", 207 207 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 208 208 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 209 209 + "display_name", 210 210 + ), 205 211 max: 200usize, 206 212 actual: <str>::len(value.as_ref()), 207 213 }); ··· 215 221 ) 216 222 .count(); 217 223 if count > 200usize { 218 218 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 219 219 - field: "display_name", 224 224 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 225 225 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 226 226 + "display_name", 227 227 + ), 220 228 max: 200usize, 221 229 actual: count, 222 230 });

+1 -1

crates/jacquard-api/src/place_atwork/search_listings.rs

··· 174 174 } 175 175 fn validate( 176 176 &self, 177 177 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 177 177 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 178 178 Ok(()) 179 179 } 180 180 }

+3 -3

crates/jacquard-api/src/place_stream.rs

··· 218 218 } 219 219 fn validate( 220 220 &self, 221 221 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 221 221 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 222 222 Ok(()) 223 223 } 224 224 } ··· 252 252 } 253 253 fn validate( 254 254 &self, 255 255 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 255 255 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 256 256 Ok(()) 257 257 } 258 258 } ··· 286 286 } 287 287 fn validate( 288 288 &self, 289 289 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 289 289 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 290 290 Ok(()) 291 291 } 292 292 }

+1 -1

crates/jacquard-api/src/place_stream/broadcast.rs

··· 128 128 } 129 129 fn validate( 130 130 &self, 131 131 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 131 131 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 132 132 Ok(()) 133 133 } 134 134 }

+5 -3

crates/jacquard-api/src/place_stream/broadcast/origin.rs

··· 112 112 } 113 113 fn validate( 114 114 &self, 115 115 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 115 115 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 116 116 if let Some(ref value) = self.iroh_ticket { 117 117 #[allow(unused_comparisons)] 118 118 if <str>::len(value.as_ref()) > 2048usize { 119 119 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 120 120 - field: "iroh_ticket", 119 119 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 120 120 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 121 121 + "iroh_ticket", 122 122 + ), 121 123 max: 2048usize, 122 124 actual: <str>::len(value.as_ref()), 123 125 });

+1 -1

crates/jacquard-api/src/place_stream/broadcast/syndication.rs

··· 102 102 } 103 103 fn validate( 104 104 &self, 105 105 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 105 105 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 106 106 Ok(()) 107 107 } 108 108 }

+1 -1

crates/jacquard-api/src/place_stream/chat.rs

··· 207 207 } 208 208 fn validate( 209 209 &self, 210 210 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 210 210 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 211 211 Ok(()) 212 212 } 213 213 }

+1 -1

crates/jacquard-api/src/place_stream/chat/gate.rs

··· 97 97 } 98 98 fn validate( 99 99 &self, 100 100 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 100 100 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 101 101 Ok(()) 102 102 } 103 103 }

+10 -6

crates/jacquard-api/src/place_stream/chat/message.rs

··· 112 112 } 113 113 fn validate( 114 114 &self, 115 115 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 115 115 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 116 116 { 117 117 let value = &self.text; 118 118 #[allow(unused_comparisons)] 119 119 if <str>::len(value.as_ref()) > 3000usize { 120 120 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 121 121 - field: "text", 120 120 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 121 121 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 122 122 + "text", 123 123 + ), 122 124 max: 3000usize, 123 125 actual: <str>::len(value.as_ref()), 124 126 }); ··· 133 135 ) 134 136 .count(); 135 137 if count > 300usize { 136 136 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 137 137 - field: "text", 138 138 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 139 139 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 140 140 + "text", 141 141 + ), 138 142 max: 300usize, 139 143 actual: count, 140 144 }); ··· 344 348 } 345 349 fn validate( 346 350 &self, 347 347 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 351 351 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 348 352 Ok(()) 349 353 } 350 354 }

+26 -14

crates/jacquard-api/src/place_stream/chat/profile.rs

··· 135 135 } 136 136 fn validate( 137 137 &self, 138 138 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 138 138 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 139 139 { 140 140 let value = &self.blue; 141 141 if *value > 255i64 { 142 142 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 143 143 - field: "blue", 142 142 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 143 143 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 144 144 + "blue", 145 145 + ), 144 146 max: 255i64, 145 147 actual: *value, 146 148 }); ··· 149 151 { 150 152 let value = &self.blue; 151 153 if *value < 0i64 { 152 152 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 153 153 - field: "blue", 154 154 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 155 155 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 156 156 + "blue", 157 157 + ), 154 158 min: 0i64, 155 159 actual: *value, 156 160 }); ··· 159 163 { 160 164 let value = &self.green; 161 165 if *value > 255i64 { 162 162 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 163 163 - field: "green", 166 166 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 167 167 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 168 168 + "green", 169 169 + ), 164 170 max: 255i64, 165 171 actual: *value, 166 172 }); ··· 169 175 { 170 176 let value = &self.green; 171 177 if *value < 0i64 { 172 172 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 173 173 - field: "green", 178 178 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 179 179 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 180 180 + "green", 181 181 + ), 174 182 min: 0i64, 175 183 actual: *value, 176 184 }); ··· 179 187 { 180 188 let value = &self.red; 181 189 if *value > 255i64 { 182 182 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 183 183 - field: "red", 190 190 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 191 191 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 192 192 + "red", 193 193 + ), 184 194 max: 255i64, 185 195 actual: *value, 186 196 }); ··· 189 199 { 190 200 let value = &self.red; 191 201 if *value < 0i64 { 192 192 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 193 193 - field: "red", 202 202 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 203 203 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 204 204 + "red", 205 205 + ), 194 206 min: 0i64, 195 207 actual: *value, 196 208 }); ··· 293 305 } 294 306 fn validate( 295 307 &self, 296 296 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 308 308 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 297 309 Ok(()) 298 310 } 299 311 }

+9 -5

crates/jacquard-api/src/place_stream/key.rs

··· 105 105 } 106 106 fn validate( 107 107 &self, 108 108 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 108 108 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 109 109 { 110 110 let value = &self.signing_key; 111 111 #[allow(unused_comparisons)] 112 112 if <str>::len(value.as_ref()) > 57usize { 113 113 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 114 114 - field: "signing_key", 113 113 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 114 114 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 115 115 + "signing_key", 116 116 + ), 115 117 max: 57usize, 116 118 actual: <str>::len(value.as_ref()), 117 119 }); ··· 121 123 let value = &self.signing_key; 122 124 #[allow(unused_comparisons)] 123 125 if <str>::len(value.as_ref()) < 57usize { 124 124 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 125 125 - field: "signing_key", 126 126 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 127 127 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 128 128 + "signing_key", 129 129 + ), 126 130 min: 57usize, 127 131 actual: <str>::len(value.as_ref()), 128 132 });

+13 -9

crates/jacquard-api/src/place_stream/livestream.rs

··· 401 401 } 402 402 fn validate( 403 403 &self, 404 404 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 404 404 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 405 405 Ok(()) 406 406 } 407 407 } ··· 531 531 } 532 532 fn validate( 533 533 &self, 534 534 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 534 534 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 535 535 { 536 536 let value = &self.title; 537 537 #[allow(unused_comparisons)] 538 538 if <str>::len(value.as_ref()) > 1400usize { 539 539 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 540 540 - field: "title", 539 539 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 540 540 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 541 541 + "title", 542 542 + ), 541 543 max: 1400usize, 542 544 actual: <str>::len(value.as_ref()), 543 545 }); ··· 552 554 ) 553 555 .count(); 554 556 if count > 140usize { 555 555 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 556 556 - field: "title", 557 557 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 558 558 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 559 559 + "title", 560 560 + ), 557 561 max: 140usize, 558 562 actual: count, 559 563 }); ··· 594 598 } 595 599 fn validate( 596 600 &self, 597 597 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 601 601 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 598 602 Ok(()) 599 603 } 600 604 } ··· 655 659 } 656 660 fn validate( 657 661 &self, 658 658 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 662 662 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 659 663 Ok(()) 660 664 } 661 665 } ··· 688 692 } 689 693 fn validate( 690 694 &self, 691 691 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 695 695 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 692 696 Ok(()) 693 697 } 694 698 }

+1 -1

crates/jacquard-api/src/place_stream/metadata/configuration.rs

··· 112 112 } 113 113 fn validate( 114 114 &self, 115 115 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 115 115 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 116 116 Ok(()) 117 117 } 118 118 }

+1 -1

crates/jacquard-api/src/place_stream/metadata/content_rights.rs

··· 369 369 } 370 370 fn validate( 371 371 &self, 372 372 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 372 372 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 373 373 Ok(()) 374 374 } 375 375 }

+1 -1

crates/jacquard-api/src/place_stream/metadata/content_warnings.rs

··· 258 258 } 259 259 fn validate( 260 260 &self, 261 261 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 261 261 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 262 262 Ok(()) 263 263 } 264 264 }

+1 -1

crates/jacquard-api/src/place_stream/metadata/distribution_policy.rs

··· 113 113 } 114 114 fn validate( 115 115 &self, 116 116 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 116 116 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 117 117 Ok(()) 118 118 } 119 119 }

+1 -1

crates/jacquard-api/src/place_stream/richtext/facet.rs

··· 118 118 } 119 119 fn validate( 120 120 &self, 121 121 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 121 121 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 122 122 Ok(()) 123 123 } 124 124 }

+5 -5

crates/jacquard-api/src/place_stream/segment.rs

··· 451 451 } 452 452 fn validate( 453 453 &self, 454 454 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 454 454 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 455 455 Ok(()) 456 456 } 457 457 } ··· 485 485 } 486 486 fn validate( 487 487 &self, 488 488 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 488 488 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 489 489 Ok(()) 490 490 } 491 491 } ··· 625 625 } 626 626 fn validate( 627 627 &self, 628 628 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 628 628 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 629 629 Ok(()) 630 630 } 631 631 } ··· 661 661 } 662 662 fn validate( 663 663 &self, 664 664 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 664 664 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 665 665 Ok(()) 666 666 } 667 667 } ··· 705 705 } 706 706 fn validate( 707 707 &self, 708 708 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 708 708 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 709 709 Ok(()) 710 710 } 711 711 }

+30 -16

crates/jacquard-api/src/place_stream/server.rs

··· 415 415 } 416 416 fn validate( 417 417 &self, 418 418 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 418 418 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 419 419 { 420 420 let value = &self.from; 421 421 #[allow(unused_comparisons)] 422 422 if <str>::len(value.as_ref()) > 100usize { 423 423 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 424 424 - field: "from", 423 423 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 424 424 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 425 425 + "from", 426 426 + ), 425 427 max: 100usize, 426 428 actual: <str>::len(value.as_ref()), 427 429 }); ··· 431 433 let value = &self.from; 432 434 #[allow(unused_comparisons)] 433 435 if <str>::len(value.as_ref()) < 1usize { 434 434 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 435 435 - field: "from", 436 436 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 437 437 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 438 438 + "from", 439 439 + ), 436 440 min: 1usize, 437 441 actual: <str>::len(value.as_ref()), 438 442 }); ··· 442 446 let value = &self.to; 443 447 #[allow(unused_comparisons)] 444 448 if <str>::len(value.as_ref()) > 100usize { 445 445 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 446 446 - field: "to", 449 449 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 450 450 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 451 451 + "to", 452 452 + ), 447 453 max: 100usize, 448 454 actual: <str>::len(value.as_ref()), 449 455 }); ··· 537 543 } 538 544 fn validate( 539 545 &self, 540 540 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 546 546 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 541 547 if let Some(ref value) = self.description { 542 548 #[allow(unused_comparisons)] 543 549 if <str>::len(value.as_ref()) > 500usize { 544 544 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 545 545 - field: "description", 550 550 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 551 551 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 552 552 + "description", 553 553 + ), 546 554 max: 500usize, 547 555 actual: <str>::len(value.as_ref()), 548 556 }); ··· 551 559 if let Some(ref value) = self.name { 552 560 #[allow(unused_comparisons)] 553 561 if <str>::len(value.as_ref()) > 100usize { 554 554 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 555 555 - field: "name", 562 562 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 563 563 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 564 564 + "name", 565 565 + ), 556 566 max: 100usize, 557 567 actual: <str>::len(value.as_ref()), 558 568 }); ··· 561 571 if let Some(ref value) = self.prefix { 562 572 #[allow(unused_comparisons)] 563 573 if <str>::len(value.as_ref()) > 100usize { 564 564 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 565 565 - field: "prefix", 574 574 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 575 575 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 576 576 + "prefix", 577 577 + ), 566 578 max: 100usize, 567 579 actual: <str>::len(value.as_ref()), 568 580 }); ··· 571 583 if let Some(ref value) = self.suffix { 572 584 #[allow(unused_comparisons)] 573 585 if <str>::len(value.as_ref()) > 100usize { 574 574 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 575 575 - field: "suffix", 586 586 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 587 587 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 588 588 + "suffix", 589 589 + ), 576 590 max: 100usize, 577 591 actual: <str>::len(value.as_ref()), 578 592 });

+1 -1

crates/jacquard-api/src/place_stream/server/settings.rs

··· 98 98 } 99 99 fn validate( 100 100 &self, 101 101 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 101 101 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 102 102 Ok(()) 103 103 } 104 104 }

+20 -12

crates/jacquard-api/src/place_wisp/fs.rs

··· 261 261 } 262 262 fn validate( 263 263 &self, 264 264 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 264 264 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 265 265 { 266 266 let value = &self.entries; 267 267 #[allow(unused_comparisons)] 268 268 if value.len() > 500usize { 269 269 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 270 270 - field: "entries", 269 269 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 270 270 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 271 271 + "entries", 272 272 + ), 271 273 max: 500usize, 272 274 actual: value.len(), 273 275 }); ··· 328 330 } 329 331 fn validate( 330 332 &self, 331 331 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 333 333 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 332 334 { 333 335 let value = &self.name; 334 336 #[allow(unused_comparisons)] 335 337 if <str>::len(value.as_ref()) > 255usize { 336 336 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 337 337 - field: "name", 338 338 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 339 339 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 340 340 + "name", 341 341 + ), 338 342 max: 255usize, 339 343 actual: <str>::len(value.as_ref()), 340 344 }); ··· 377 381 } 378 382 fn validate( 379 383 &self, 380 380 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 384 384 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 381 385 Ok(()) 382 386 } 383 387 } ··· 480 484 } 481 485 fn validate( 482 486 &self, 483 483 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 487 487 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 484 488 if let Some(ref value) = self.file_count { 485 489 if *value > 1000i64 { 486 486 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 487 487 - field: "file_count", 490 490 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 491 491 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 492 492 + "file_count", 493 493 + ), 488 494 max: 1000i64, 489 495 actual: *value, 490 496 }); ··· 492 498 } 493 499 if let Some(ref value) = self.file_count { 494 500 if *value < 0i64 { 495 495 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 496 496 - field: "file_count", 501 501 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 502 502 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 503 503 + "file_count", 504 504 + ), 497 505 min: 0i64, 498 506 actual: *value, 499 507 });

+1 -1

crates/jacquard-api/src/pub_leaflet/blocks/blockquote.rs

··· 100 100 } 101 101 fn validate( 102 102 &self, 103 103 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 103 103 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 104 104 Ok(()) 105 105 } 106 106 }

+1 -1

crates/jacquard-api/src/pub_leaflet/blocks/bsky_post.rs

··· 73 73 } 74 74 fn validate( 75 75 &self, 76 76 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 76 76 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 77 77 Ok(()) 78 78 } 79 79 }

+1 -1

crates/jacquard-api/src/pub_leaflet/blocks/code.rs

··· 121 121 } 122 122 fn validate( 123 123 &self, 124 124 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 124 124 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 125 125 Ok(()) 126 126 } 127 127 }

+9 -5

crates/jacquard-api/src/pub_leaflet/blocks/header.rs

··· 113 113 } 114 114 fn validate( 115 115 &self, 116 116 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 116 116 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 117 117 if let Some(ref value) = self.level { 118 118 if *value > 6i64 { 119 119 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 120 120 - field: "level", 119 119 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 120 120 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 121 121 + "level", 122 122 + ), 121 123 max: 6i64, 122 124 actual: *value, 123 125 }); ··· 125 127 } 126 128 if let Some(ref value) = self.level { 127 129 if *value < 1i64 { 128 128 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 129 129 - field: "level", 130 130 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 131 131 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 132 132 + "level", 133 133 + ), 130 134 min: 1i64, 131 135 actual: *value, 132 136 });

+1 -1

crates/jacquard-api/src/pub_leaflet/blocks/horizontal_rule.rs

··· 58 58 } 59 59 fn validate( 60 60 &self, 61 61 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 61 61 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 62 62 Ok(()) 63 63 } 64 64 }

+9 -5

crates/jacquard-api/src/pub_leaflet/blocks/iframe.rs

··· 95 95 } 96 96 fn validate( 97 97 &self, 98 98 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 98 98 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 99 99 if let Some(ref value) = self.height { 100 100 if *value > 1600i64 { 101 101 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 102 102 - field: "height", 101 101 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 102 102 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 103 103 + "height", 104 104 + ), 103 105 max: 1600i64, 104 106 actual: *value, 105 107 }); ··· 107 109 } 108 110 if let Some(ref value) = self.height { 109 111 if *value < 16i64 { 110 110 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 111 111 - field: "height", 112 112 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 113 113 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 114 114 + "height", 115 115 + ), 112 116 min: 16i64, 113 117 actual: *value, 114 118 });

+2 -2

crates/jacquard-api/src/pub_leaflet/blocks/image.rs

··· 143 143 } 144 144 fn validate( 145 145 &self, 146 146 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 146 146 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 147 147 Ok(()) 148 148 } 149 149 } ··· 184 184 } 185 185 fn validate( 186 186 &self, 187 187 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 187 187 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 188 188 Ok(()) 189 189 } 190 190 }

+1 -1

crates/jacquard-api/src/pub_leaflet/blocks/math.rs

··· 79 79 } 80 80 fn validate( 81 81 &self, 82 82 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 82 82 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 83 83 Ok(()) 84 84 } 85 85 }

+1 -1

crates/jacquard-api/src/pub_leaflet/blocks/page.rs

··· 79 79 } 80 80 fn validate( 81 81 &self, 82 82 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 82 82 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 83 83 Ok(()) 84 84 } 85 85 }

+1 -1

crates/jacquard-api/src/pub_leaflet/blocks/poll.rs

··· 73 73 } 74 74 fn validate( 75 75 &self, 76 76 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 76 76 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 77 77 Ok(()) 78 78 } 79 79 }

+1 -1

crates/jacquard-api/src/pub_leaflet/blocks/text.rs

··· 100 100 } 101 101 fn validate( 102 102 &self, 103 103 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 103 103 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 104 104 Ok(()) 105 105 } 106 106 }

+2 -2

crates/jacquard-api/src/pub_leaflet/blocks/unordered_list.rs

··· 142 142 } 143 143 fn validate( 144 144 &self, 145 145 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 145 145 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 146 146 Ok(()) 147 147 } 148 148 } ··· 176 176 } 177 177 fn validate( 178 178 &self, 179 179 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 179 179 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 180 180 Ok(()) 181 181 } 182 182 }

+1 -1

crates/jacquard-api/src/pub_leaflet/blocks/website.rs

··· 135 135 } 136 136 fn validate( 137 137 &self, 138 138 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 138 138 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 139 139 Ok(()) 140 140 } 141 141 }

+3 -3

crates/jacquard-api/src/pub_leaflet/comment.rs

··· 255 255 } 256 256 fn validate( 257 257 &self, 258 258 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 258 258 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 259 259 Ok(()) 260 260 } 261 261 } ··· 371 371 } 372 372 fn validate( 373 373 &self, 374 374 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 374 374 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 375 375 Ok(()) 376 376 } 377 377 } ··· 405 405 } 406 406 fn validate( 407 407 &self, 408 408 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 408 408 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 409 409 Ok(()) 410 410 } 411 411 }

+17 -9

crates/jacquard-api/src/pub_leaflet/document.rs

··· 133 133 } 134 134 fn validate( 135 135 &self, 136 136 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 136 136 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 137 137 if let Some(ref value) = self.description { 138 138 #[allow(unused_comparisons)] 139 139 if <str>::len(value.as_ref()) > 3000usize { 140 140 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 141 141 - field: "description", 140 140 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 141 141 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 142 142 + "description", 143 143 + ), 142 144 max: 3000usize, 143 145 actual: <str>::len(value.as_ref()), 144 146 }); ··· 152 154 ) 153 155 .count(); 154 156 if count > 300usize { 155 155 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 156 156 - field: "description", 157 157 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 158 158 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 159 159 + "description", 160 160 + ), 157 161 max: 300usize, 158 162 actual: count, 159 163 }); ··· 164 168 let value = &self.title; 165 169 #[allow(unused_comparisons)] 166 170 if <str>::len(value.as_ref()) > 1280usize { 167 167 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 168 168 - field: "title", 171 171 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 172 172 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 173 173 + "title", 174 174 + ), 169 175 max: 1280usize, 170 176 actual: <str>::len(value.as_ref()), 171 177 }); ··· 180 186 ) 181 187 .count(); 182 188 if count > 128usize { 183 183 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 184 184 - field: "title", 189 189 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 190 190 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 191 191 + "title", 192 192 + ), 185 193 max: 128usize, 186 194 actual: count, 187 195 });

+1 -1

crates/jacquard-api/src/pub_leaflet/graph/subscription.rs

··· 96 96 } 97 97 fn validate( 98 98 &self, 99 99 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 99 99 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 100 100 Ok(()) 101 101 } 102 102 }

+4 -4

crates/jacquard-api/src/pub_leaflet/pages/canvas.rs

··· 330 330 } 331 331 fn validate( 332 332 &self, 333 333 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 333 333 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 334 334 Ok(()) 335 335 } 336 336 } ··· 368 368 } 369 369 fn validate( 370 370 &self, 371 371 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 371 371 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 372 372 Ok(()) 373 373 } 374 374 } ··· 402 402 } 403 403 fn validate( 404 404 &self, 405 405 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 405 405 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 406 406 Ok(()) 407 407 } 408 408 } ··· 438 438 } 439 439 fn validate( 440 440 &self, 441 441 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 441 441 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 442 442 Ok(()) 443 443 } 444 444 }

+4 -4

crates/jacquard-api/src/pub_leaflet/pages/linear_document.rs

··· 285 285 } 286 286 fn validate( 287 287 &self, 288 288 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 288 288 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 289 289 Ok(()) 290 290 } 291 291 } ··· 323 323 } 324 324 fn validate( 325 325 &self, 326 326 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 326 326 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 327 327 Ok(()) 328 328 } 329 329 } ··· 357 357 } 358 358 fn validate( 359 359 &self, 360 360 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 360 360 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 361 361 Ok(()) 362 362 } 363 363 } ··· 393 393 } 394 394 fn validate( 395 395 &self, 396 396 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 396 396 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 397 397 Ok(()) 398 398 } 399 399 }

+18 -10

crates/jacquard-api/src/pub_leaflet/poll/definition.rs

··· 102 102 } 103 103 fn validate( 104 104 &self, 105 105 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 105 105 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 106 106 { 107 107 let value = &self.name; 108 108 #[allow(unused_comparisons)] 109 109 if <str>::len(value.as_ref()) > 500usize { 110 110 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 111 111 - field: "name", 110 110 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 111 111 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 112 112 + "name", 113 113 + ), 112 114 max: 500usize, 113 115 actual: <str>::len(value.as_ref()), 114 116 }); ··· 123 125 ) 124 126 .count(); 125 127 if count > 100usize { 126 126 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 127 127 - field: "name", 128 128 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 129 129 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 130 130 + "name", 131 131 + ), 128 132 max: 100usize, 129 133 actual: count, 130 134 }); ··· 276 280 } 277 281 fn validate( 278 282 &self, 279 279 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 283 283 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 280 284 if let Some(ref value) = self.text { 281 285 #[allow(unused_comparisons)] 282 286 if <str>::len(value.as_ref()) > 500usize { 283 283 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 284 284 - field: "text", 287 287 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 288 288 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 289 289 + "text", 290 290 + ), 285 291 max: 500usize, 286 292 actual: <str>::len(value.as_ref()), 287 293 }); ··· 295 301 ) 296 302 .count(); 297 303 if count > 50usize { 298 298 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 299 299 - field: "text", 304 304 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 305 305 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 306 306 + "text", 307 307 + ), 300 308 max: 50usize, 301 309 actual: count, 302 310 });

+1 -1

crates/jacquard-api/src/pub_leaflet/poll/vote.rs

··· 98 98 } 99 99 fn validate( 100 100 &self, 101 101 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 101 101 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 102 102 Ok(()) 103 103 } 104 104 }

+11 -7

crates/jacquard-api/src/pub_leaflet/publication.rs

··· 117 117 } 118 118 fn validate( 119 119 &self, 120 120 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 120 120 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 121 121 if let Some(ref value) = self.description { 122 122 #[allow(unused_comparisons)] 123 123 if <str>::len(value.as_ref()) > 2000usize { 124 124 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 125 125 - field: "description", 124 124 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 125 125 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 126 126 + "description", 127 127 + ), 126 128 max: 2000usize, 127 129 actual: <str>::len(value.as_ref()), 128 130 }); ··· 132 134 let value = &self.name; 133 135 #[allow(unused_comparisons)] 134 136 if <str>::len(value.as_ref()) > 2000usize { 135 135 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 136 136 - field: "name", 137 137 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 138 138 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 139 139 + "name", 140 140 + ), 137 141 max: 2000usize, 138 142 actual: <str>::len(value.as_ref()), 139 143 }); ··· 417 421 } 418 422 fn validate( 419 423 &self, 420 420 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 424 424 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 421 425 Ok(()) 422 426 } 423 427 } ··· 566 570 } 567 571 fn validate( 568 572 &self, 569 569 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 573 573 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 570 574 Ok(()) 571 575 } 572 576 }

+18 -14

crates/jacquard-api/src/pub_leaflet/richtext/facet.rs

··· 311 311 } 312 312 fn validate( 313 313 &self, 314 314 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 314 314 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 315 315 Ok(()) 316 316 } 317 317 } ··· 346 346 } 347 347 fn validate( 348 348 &self, 349 349 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 349 349 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 350 350 { 351 351 let value = &self.byte_end; 352 352 if *value < 0i64 { 353 353 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 354 354 - field: "byte_end", 353 353 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 354 354 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 355 355 + "byte_end", 356 356 + ), 355 357 min: 0i64, 356 358 actual: *value, 357 359 }); ··· 360 362 { 361 363 let value = &self.byte_start; 362 364 if *value < 0i64 { 363 363 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 364 364 - field: "byte_start", 365 365 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 366 366 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 367 367 + "byte_start", 368 368 + ), 365 369 min: 0i64, 366 370 actual: *value, 367 371 }); ··· 397 401 } 398 402 fn validate( 399 403 &self, 400 400 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 404 404 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 401 405 Ok(()) 402 406 } 403 407 } ··· 428 432 } 429 433 fn validate( 430 434 &self, 431 431 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 435 435 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 432 436 Ok(()) 433 437 } 434 438 } ··· 464 468 } 465 469 fn validate( 466 470 &self, 467 467 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 471 471 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 468 472 Ok(()) 469 473 } 470 474 } ··· 495 499 } 496 500 fn validate( 497 501 &self, 498 498 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 502 502 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 499 503 Ok(()) 500 504 } 501 505 } ··· 530 534 } 531 535 fn validate( 532 536 &self, 533 533 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 537 537 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 534 538 Ok(()) 535 539 } 536 540 } ··· 598 602 } 599 603 fn validate( 600 604 &self, 601 601 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 605 605 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 602 606 Ok(()) 603 607 } 604 608 } ··· 629 633 } 630 634 fn validate( 631 635 &self, 632 632 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 636 636 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 633 637 Ok(()) 634 638 } 635 639 } ··· 660 664 } 661 665 fn validate( 662 666 &self, 663 663 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 667 667 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 664 668 Ok(()) 665 669 } 666 670 }

+1 -1

crates/jacquard-api/src/pub_leaflet/theme/background_image.rs

··· 97 97 } 98 98 fn validate( 99 99 &self, 100 100 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 100 100 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 101 101 Ok(()) 102 102 } 103 103 }

+58 -30

crates/jacquard-api/src/pub_leaflet/theme/color.rs

··· 166 166 } 167 167 fn validate( 168 168 &self, 169 169 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 169 169 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 170 170 { 171 171 let value = &self.b; 172 172 if *value > 255i64 { 173 173 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 174 174 - field: "b", 173 173 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 174 174 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 175 175 + "b", 176 176 + ), 175 177 max: 255i64, 176 178 actual: *value, 177 179 }); ··· 180 182 { 181 183 let value = &self.b; 182 184 if *value < 0i64 { 183 183 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 184 184 - field: "b", 185 185 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 186 186 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 187 187 + "b", 188 188 + ), 185 189 min: 0i64, 186 190 actual: *value, 187 191 }); ··· 190 194 { 191 195 let value = &self.g; 192 196 if *value > 255i64 { 193 193 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 194 194 - field: "g", 197 197 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 198 198 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 199 199 + "g", 200 200 + ), 195 201 max: 255i64, 196 202 actual: *value, 197 203 }); ··· 200 206 { 201 207 let value = &self.g; 202 208 if *value < 0i64 { 203 203 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 204 204 - field: "g", 209 209 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 210 210 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 211 211 + "g", 212 212 + ), 205 213 min: 0i64, 206 214 actual: *value, 207 215 }); ··· 210 218 { 211 219 let value = &self.r; 212 220 if *value > 255i64 { 213 213 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 214 214 - field: "r", 221 221 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 222 222 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 223 223 + "r", 224 224 + ), 215 225 max: 255i64, 216 226 actual: *value, 217 227 }); ··· 220 230 { 221 231 let value = &self.r; 222 232 if *value < 0i64 { 223 223 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 224 224 - field: "r", 233 233 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 234 234 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 235 235 + "r", 236 236 + ), 225 237 min: 0i64, 226 238 actual: *value, 227 239 }); ··· 262 274 } 263 275 fn validate( 264 276 &self, 265 265 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 277 277 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 266 278 { 267 279 let value = &self.a; 268 280 if *value > 100i64 { 269 269 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 270 270 - field: "a", 281 281 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 282 282 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 283 283 + "a", 284 284 + ), 271 285 max: 100i64, 272 286 actual: *value, 273 287 }); ··· 276 290 { 277 291 let value = &self.a; 278 292 if *value < 0i64 { 279 279 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 280 280 - field: "a", 293 293 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 294 294 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 295 295 + "a", 296 296 + ), 281 297 min: 0i64, 282 298 actual: *value, 283 299 }); ··· 286 302 { 287 303 let value = &self.b; 288 304 if *value > 255i64 { 289 289 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 290 290 - field: "b", 305 305 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 306 306 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 307 307 + "b", 308 308 + ), 291 309 max: 255i64, 292 310 actual: *value, 293 311 }); ··· 296 314 { 297 315 let value = &self.b; 298 316 if *value < 0i64 { 299 299 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 300 300 - field: "b", 317 317 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 318 318 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 319 319 + "b", 320 320 + ), 301 321 min: 0i64, 302 322 actual: *value, 303 323 }); ··· 306 326 { 307 327 let value = &self.g; 308 328 if *value > 255i64 { 309 309 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 310 310 - field: "g", 329 329 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 330 330 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 331 331 + "g", 332 332 + ), 311 333 max: 255i64, 312 334 actual: *value, 313 335 }); ··· 316 338 { 317 339 let value = &self.g; 318 340 if *value < 0i64 { 319 319 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 320 320 - field: "g", 341 341 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 342 342 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 343 343 + "g", 344 344 + ), 321 345 min: 0i64, 322 346 actual: *value, 323 347 }); ··· 326 350 { 327 351 let value = &self.r; 328 352 if *value > 255i64 { 329 329 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 330 330 - field: "r", 353 353 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 354 354 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 355 355 + "r", 356 356 + ), 331 357 max: 255i64, 332 358 actual: *value, 333 359 }); ··· 336 362 { 337 363 let value = &self.r; 338 364 if *value < 0i64 { 339 339 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 340 340 - field: "r", 365 365 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 366 366 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 367 367 + "r", 368 368 + ), 341 369 min: 0i64, 342 370 actual: *value, 343 371 });

+41 -21

crates/jacquard-api/src/sh_tangled/actor/profile.rs

··· 119 119 } 120 120 fn validate( 121 121 &self, 122 122 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 122 122 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 123 123 if let Some(ref value) = self.description { 124 124 #[allow(unused_comparisons)] 125 125 if <str>::len(value.as_ref()) > 2560usize { 126 126 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 127 127 - field: "description", 126 126 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 127 127 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 128 128 + "description", 129 129 + ), 128 130 max: 2560usize, 129 131 actual: <str>::len(value.as_ref()), 130 132 }); ··· 138 140 ) 139 141 .count(); 140 142 if count > 256usize { 141 141 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 142 142 - field: "description", 143 143 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 144 144 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 145 145 + "description", 146 146 + ), 143 147 max: 256usize, 144 148 actual: count, 145 149 }); ··· 149 153 if let Some(ref value) = self.links { 150 154 #[allow(unused_comparisons)] 151 155 if value.len() > 5usize { 152 152 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 153 153 - field: "links", 156 156 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 157 157 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 158 158 + "links", 159 159 + ), 154 160 max: 5usize, 155 161 actual: value.len(), 156 162 }); ··· 159 165 if let Some(ref value) = self.links { 160 166 #[allow(unused_comparisons)] 161 167 if value.len() < 0usize { 162 162 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 163 163 - field: "links", 168 168 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 169 169 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 170 170 + "links", 171 171 + ), 164 172 min: 0usize, 165 173 actual: value.len(), 166 174 }); ··· 169 177 if let Some(ref value) = self.location { 170 178 #[allow(unused_comparisons)] 171 179 if <str>::len(value.as_ref()) > 400usize { 172 172 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 173 173 - field: "location", 180 180 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 181 181 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 182 182 + "location", 183 183 + ), 174 184 max: 400usize, 175 185 actual: <str>::len(value.as_ref()), 176 186 }); ··· 184 194 ) 185 195 .count(); 186 196 if count > 40usize { 187 187 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 188 188 - field: "location", 197 197 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 198 198 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 199 199 + "location", 200 200 + ), 189 201 max: 40usize, 190 202 actual: count, 191 203 }); ··· 195 207 if let Some(ref value) = self.pinned_repositories { 196 208 #[allow(unused_comparisons)] 197 209 if value.len() > 6usize { 198 198 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 199 199 - field: "pinned_repositories", 210 210 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 211 211 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 212 212 + "pinned_repositories", 213 213 + ), 200 214 max: 6usize, 201 215 actual: value.len(), 202 216 }); ··· 205 219 if let Some(ref value) = self.pinned_repositories { 206 220 #[allow(unused_comparisons)] 207 221 if value.len() < 0usize { 208 208 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 209 209 - field: "pinned_repositories", 222 222 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 223 223 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 224 224 + "pinned_repositories", 225 225 + ), 210 226 min: 0usize, 211 227 actual: value.len(), 212 228 }); ··· 215 231 if let Some(ref value) = self.stats { 216 232 #[allow(unused_comparisons)] 217 233 if value.len() > 2usize { 218 218 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 219 219 - field: "stats", 234 234 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 235 235 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 236 236 + "stats", 237 237 + ), 220 238 max: 2usize, 221 239 actual: value.len(), 222 240 }); ··· 225 243 if let Some(ref value) = self.stats { 226 244 #[allow(unused_comparisons)] 227 245 if value.len() < 0usize { 228 228 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 229 229 - field: "stats", 246 246 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 247 247 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 248 248 + "stats", 249 249 + ), 230 250 min: 0usize, 231 251 actual: value.len(), 232 252 });

+1 -1

crates/jacquard-api/src/sh_tangled/feed/reaction.rs

··· 99 99 } 100 100 fn validate( 101 101 &self, 102 102 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 102 102 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 103 103 Ok(()) 104 104 } 105 105 }

+1 -1

crates/jacquard-api/src/sh_tangled/feed/star.rs

··· 96 96 } 97 97 fn validate( 98 98 &self, 99 99 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 99 99 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 100 100 Ok(()) 101 101 } 102 102 }

+30 -18

crates/jacquard-api/src/sh_tangled/git/ref_update.rs

··· 400 400 } 401 401 fn validate( 402 402 &self, 403 403 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 403 403 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 404 404 Ok(()) 405 405 } 406 406 } ··· 436 436 } 437 437 fn validate( 438 438 &self, 439 439 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 439 439 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 440 440 Ok(()) 441 441 } 442 442 } ··· 472 472 } 473 473 fn validate( 474 474 &self, 475 475 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 475 475 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 476 476 Ok(()) 477 477 } 478 478 } ··· 509 509 } 510 510 fn validate( 511 511 &self, 512 512 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 512 512 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 513 513 Ok(()) 514 514 } 515 515 } ··· 627 627 } 628 628 fn validate( 629 629 &self, 630 630 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 630 630 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 631 631 { 632 632 let value = &self.new_sha; 633 633 #[allow(unused_comparisons)] 634 634 if <str>::len(value.as_ref()) > 40usize { 635 635 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 636 636 - field: "new_sha", 635 635 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 636 636 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 637 637 + "new_sha", 638 638 + ), 637 639 max: 40usize, 638 640 actual: <str>::len(value.as_ref()), 639 641 }); ··· 643 645 let value = &self.new_sha; 644 646 #[allow(unused_comparisons)] 645 647 if <str>::len(value.as_ref()) < 40usize { 646 646 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 647 647 - field: "new_sha", 648 648 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 649 649 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 650 650 + "new_sha", 651 651 + ), 648 652 min: 40usize, 649 653 actual: <str>::len(value.as_ref()), 650 654 }); ··· 654 658 let value = &self.old_sha; 655 659 #[allow(unused_comparisons)] 656 660 if <str>::len(value.as_ref()) > 40usize { 657 657 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 658 658 - field: "old_sha", 661 661 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 662 662 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 663 663 + "old_sha", 664 664 + ), 659 665 max: 40usize, 660 666 actual: <str>::len(value.as_ref()), 661 667 }); ··· 665 671 let value = &self.old_sha; 666 672 #[allow(unused_comparisons)] 667 673 if <str>::len(value.as_ref()) < 40usize { 668 668 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 669 669 - field: "old_sha", 674 674 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 675 675 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 676 676 + "old_sha", 677 677 + ), 670 678 min: 40usize, 671 679 actual: <str>::len(value.as_ref()), 672 680 }); ··· 676 684 let value = &self.r#ref; 677 685 #[allow(unused_comparisons)] 678 686 if <str>::len(value.as_ref()) > 2560usize { 679 679 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 680 680 - field: "ref", 687 687 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 688 688 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 689 689 + "ref", 690 690 + ), 681 691 max: 2560usize, 682 692 actual: <str>::len(value.as_ref()), 683 693 }); ··· 692 702 ) 693 703 .count(); 694 704 if count > 256usize { 695 695 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 696 696 - field: "ref", 705 705 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 706 706 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 707 707 + "ref", 708 708 + ), 697 709 max: 256usize, 698 710 actual: count, 699 711 }); ··· 738 750 } 739 751 fn validate( 740 752 &self, 741 741 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 753 753 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 742 754 Ok(()) 743 755 } 744 756 }

+1 -1

crates/jacquard-api/src/sh_tangled/graph/follow.rs

··· 96 96 } 97 97 fn validate( 98 98 &self, 99 99 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 99 99 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 100 100 Ok(()) 101 101 } 102 102 }

+1 -1

crates/jacquard-api/src/sh_tangled/knot.rs

··· 98 98 } 99 99 fn validate( 100 100 &self, 101 101 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 101 101 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 102 102 Ok(()) 103 103 } 104 104 }

+5 -3

crates/jacquard-api/src/sh_tangled/knot/list_keys.rs

··· 286 286 } 287 287 fn validate( 288 288 &self, 289 289 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 289 289 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 290 290 { 291 291 let value = &self.key; 292 292 #[allow(unused_comparisons)] 293 293 if <str>::len(value.as_ref()) > 4096usize { 294 294 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 295 295 - field: "key", 294 294 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 295 295 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 296 296 + "key", 297 297 + ), 296 298 max: 4096usize, 297 299 actual: <str>::len(value.as_ref()), 298 300 });

+1 -1

crates/jacquard-api/src/sh_tangled/knot/member.rs

··· 100 100 } 101 101 fn validate( 102 102 &self, 103 103 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 103 103 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 104 104 Ok(()) 105 105 } 106 106 }

+10 -6

crates/jacquard-api/src/sh_tangled/label/definition.rs

··· 113 113 } 114 114 fn validate( 115 115 &self, 116 116 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 116 116 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 117 117 { 118 118 let value = &self.name; 119 119 { ··· 123 123 ) 124 124 .count(); 125 125 if count > 40usize { 126 126 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 127 127 - field: "name", 126 126 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 127 127 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 128 128 + "name", 129 129 + ), 128 130 max: 40usize, 129 131 actual: count, 130 132 }); ··· 140 142 ) 141 143 .count(); 142 144 if count < 1usize { 143 143 - return Err(::jacquard_lexicon::schema::ValidationError::MinGraphemes { 144 144 - field: "name", 145 145 + return Err(::jacquard_lexicon::validation::ConstraintError::MinGraphemes { 146 146 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 147 147 + "name", 148 148 + ), 145 149 min: 1usize, 146 150 actual: count, 147 151 }); ··· 410 414 } 411 415 fn validate( 412 416 &self, 413 413 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 417 417 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 414 418 Ok(()) 415 419 } 416 420 }

+2 -2

crates/jacquard-api/src/sh_tangled/label/op.rs

··· 101 101 } 102 102 fn validate( 103 103 &self, 104 104 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 104 104 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 105 105 Ok(()) 106 106 } 107 107 } ··· 301 301 } 302 302 fn validate( 303 303 &self, 304 304 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 304 304 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 305 305 Ok(()) 306 306 } 307 307 }

+33 -21

crates/jacquard-api/src/sh_tangled/pipeline.rs

··· 597 597 } 598 598 fn validate( 599 599 &self, 600 600 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 600 600 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 601 601 Ok(()) 602 602 } 603 603 } ··· 694 694 } 695 695 fn validate( 696 696 &self, 697 697 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 697 697 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 698 698 Ok(()) 699 699 } 700 700 } ··· 729 729 } 730 730 fn validate( 731 731 &self, 732 732 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 732 732 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 733 733 Ok(()) 734 734 } 735 735 } ··· 765 765 } 766 766 fn validate( 767 767 &self, 768 768 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 768 768 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 769 769 Ok(()) 770 770 } 771 771 } ··· 805 805 } 806 806 fn validate( 807 807 &self, 808 808 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 808 808 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 809 809 { 810 810 let value = &self.source_sha; 811 811 #[allow(unused_comparisons)] 812 812 if <str>::len(value.as_ref()) > 40usize { 813 813 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 814 814 - field: "source_sha", 813 813 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 814 814 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 815 815 + "source_sha", 816 816 + ), 815 817 max: 40usize, 816 818 actual: <str>::len(value.as_ref()), 817 819 }); ··· 821 823 let value = &self.source_sha; 822 824 #[allow(unused_comparisons)] 823 825 if <str>::len(value.as_ref()) < 40usize { 824 824 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 825 825 - field: "source_sha", 826 826 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 827 827 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 828 828 + "source_sha", 829 829 + ), 826 830 min: 40usize, 827 831 actual: <str>::len(value.as_ref()), 828 832 }); ··· 865 869 } 866 870 fn validate( 867 871 &self, 868 868 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 872 872 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 869 873 { 870 874 let value = &self.new_sha; 871 875 #[allow(unused_comparisons)] 872 876 if <str>::len(value.as_ref()) > 40usize { 873 873 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 874 874 - field: "new_sha", 877 877 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 878 878 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 879 879 + "new_sha", 880 880 + ), 875 881 max: 40usize, 876 882 actual: <str>::len(value.as_ref()), 877 883 }); ··· 881 887 let value = &self.new_sha; 882 888 #[allow(unused_comparisons)] 883 889 if <str>::len(value.as_ref()) < 40usize { 884 884 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 885 885 - field: "new_sha", 890 890 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 891 891 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 892 892 + "new_sha", 893 893 + ), 886 894 min: 40usize, 887 895 actual: <str>::len(value.as_ref()), 888 896 }); ··· 892 900 let value = &self.old_sha; 893 901 #[allow(unused_comparisons)] 894 902 if <str>::len(value.as_ref()) > 40usize { 895 895 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 896 896 - field: "old_sha", 903 903 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 904 904 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 905 905 + "old_sha", 906 906 + ), 897 907 max: 40usize, 898 908 actual: <str>::len(value.as_ref()), 899 909 }); ··· 903 913 let value = &self.old_sha; 904 914 #[allow(unused_comparisons)] 905 915 if <str>::len(value.as_ref()) < 40usize { 906 906 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 907 907 - field: "old_sha", 916 916 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 917 917 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 918 918 + "old_sha", 919 919 + ), 908 920 min: 40usize, 909 921 actual: <str>::len(value.as_ref()), 910 922 }); ··· 958 970 } 959 971 fn validate( 960 972 &self, 961 961 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 973 973 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 962 974 Ok(()) 963 975 } 964 976 } ··· 1001 1013 } 1002 1014 fn validate( 1003 1015 &self, 1004 1004 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1016 1016 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1005 1017 Ok(()) 1006 1018 } 1007 1019 } ··· 1044 1056 } 1045 1057 fn validate( 1046 1058 &self, 1047 1047 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1059 1059 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1048 1060 Ok(()) 1049 1061 } 1050 1062 }

+1 -1

crates/jacquard-api/src/sh_tangled/pipeline/status.rs

··· 114 114 } 115 115 fn validate( 116 116 &self, 117 117 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 117 117 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 118 118 Ok(()) 119 119 } 120 120 }

+5 -3

crates/jacquard-api/src/sh_tangled/public_key.rs

··· 103 103 } 104 104 fn validate( 105 105 &self, 106 106 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 106 106 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 107 107 { 108 108 let value = &self.key; 109 109 #[allow(unused_comparisons)] 110 110 if <str>::len(value.as_ref()) > 4096usize { 111 111 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 112 112 - field: "key", 111 111 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 112 112 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 113 113 + "key", 114 114 + ), 113 115 max: 4096usize, 114 116 actual: <str>::len(value.as_ref()), 115 117 });

+9 -5

crates/jacquard-api/src/sh_tangled/repo.rs

··· 149 149 } 150 150 fn validate( 151 151 &self, 152 152 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 152 152 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 153 153 if let Some(ref value) = self.description { 154 154 { 155 155 let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( ··· 158 158 ) 159 159 .count(); 160 160 if count > 140usize { 161 161 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 162 162 - field: "description", 161 161 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 162 162 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 163 163 + "description", 164 164 + ), 163 165 max: 140usize, 164 166 actual: count, 165 167 }); ··· 174 176 ) 175 177 .count(); 176 178 if count < 1usize { 177 177 - return Err(::jacquard_lexicon::schema::ValidationError::MinGraphemes { 178 178 - field: "description", 179 179 + return Err(::jacquard_lexicon::validation::ConstraintError::MinGraphemes { 180 180 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 181 181 + "description", 182 182 + ), 179 183 min: 1usize, 180 184 actual: count, 181 185 });

+1 -1

crates/jacquard-api/src/sh_tangled/repo/artifact.rs

··· 107 107 } 108 108 fn validate( 109 109 &self, 110 110 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 110 110 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 111 111 Ok(()) 112 112 } 113 113 }

+2 -2

crates/jacquard-api/src/sh_tangled/repo/blob.rs

··· 326 326 } 327 327 fn validate( 328 328 &self, 329 329 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 329 329 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 330 330 Ok(()) 331 331 } 332 332 } ··· 527 527 } 528 528 fn validate( 529 529 &self, 530 530 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 530 530 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 531 531 Ok(()) 532 532 } 533 533 }

+1 -1

crates/jacquard-api/src/sh_tangled/repo/branch.rs

··· 329 329 } 330 330 fn validate( 331 331 &self, 332 332 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 332 332 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 333 333 Ok(()) 334 334 } 335 335 }

+1 -1

crates/jacquard-api/src/sh_tangled/repo/collaborator.rs

··· 99 99 } 100 100 fn validate( 101 101 &self, 102 102 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 102 102 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 103 103 Ok(()) 104 104 } 105 105 }

+1 -1

crates/jacquard-api/src/sh_tangled/repo/get_default_branch.rs

··· 293 293 } 294 294 fn validate( 295 295 &self, 296 296 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 296 296 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 297 297 Ok(()) 298 298 } 299 299 }

+1 -1

crates/jacquard-api/src/sh_tangled/repo/issue.rs

··· 106 106 } 107 107 fn validate( 108 108 &self, 109 109 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 109 109 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 110 110 Ok(()) 111 111 } 112 112 }

+1 -1

crates/jacquard-api/src/sh_tangled/repo/issue/comment.rs

··· 103 103 } 104 104 fn validate( 105 105 &self, 106 106 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 106 106 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 107 107 Ok(()) 108 108 } 109 109 }

+1 -1

crates/jacquard-api/src/sh_tangled/repo/issue/state.rs

··· 102 102 } 103 103 fn validate( 104 104 &self, 105 105 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 105 105 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 106 106 Ok(()) 107 107 } 108 108 }

+1 -1

crates/jacquard-api/src/sh_tangled/repo/languages.rs

··· 250 250 } 251 251 fn validate( 252 252 &self, 253 253 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 253 253 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 254 254 Ok(()) 255 255 } 256 256 }

+9 -5

crates/jacquard-api/src/sh_tangled/repo/list_secrets.rs

··· 244 244 } 245 245 fn validate( 246 246 &self, 247 247 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 247 247 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 248 248 { 249 249 let value = &self.key; 250 250 #[allow(unused_comparisons)] 251 251 if <str>::len(value.as_ref()) > 50usize { 252 252 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 253 253 - field: "key", 252 252 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 253 253 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 254 254 + "key", 255 255 + ), 254 256 max: 50usize, 255 257 actual: <str>::len(value.as_ref()), 256 258 }); ··· 260 262 let value = &self.key; 261 263 #[allow(unused_comparisons)] 262 264 if <str>::len(value.as_ref()) < 1usize { 263 263 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 264 264 - field: "key", 265 265 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 266 266 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 267 267 + "key", 268 268 + ), 265 269 min: 1usize, 266 270 actual: <str>::len(value.as_ref()), 267 271 });

+1 -1

crates/jacquard-api/src/sh_tangled/repo/merge_check.rs

··· 221 221 } 222 222 fn validate( 223 223 &self, 224 224 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 224 224 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 225 225 Ok(()) 226 226 } 227 227 }

+11 -7

crates/jacquard-api/src/sh_tangled/repo/pull.rs

··· 113 113 } 114 114 fn validate( 115 115 &self, 116 116 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 116 116 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 117 117 Ok(()) 118 118 } 119 119 } ··· 384 384 } 385 385 fn validate( 386 386 &self, 387 387 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 387 387 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 388 388 { 389 389 let value = &self.sha; 390 390 #[allow(unused_comparisons)] 391 391 if <str>::len(value.as_ref()) > 40usize { 392 392 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 393 393 - field: "sha", 392 392 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 393 393 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 394 394 + "sha", 395 395 + ), 394 396 max: 40usize, 395 397 actual: <str>::len(value.as_ref()), 396 398 }); ··· 400 402 let value = &self.sha; 401 403 #[allow(unused_comparisons)] 402 404 if <str>::len(value.as_ref()) < 40usize { 403 403 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 404 404 - field: "sha", 405 405 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 406 406 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 407 407 + "sha", 408 408 + ), 405 409 min: 40usize, 406 410 actual: <str>::len(value.as_ref()), 407 411 }); ··· 443 447 } 444 448 fn validate( 445 449 &self, 446 446 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 450 450 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 447 451 Ok(()) 448 452 } 449 453 }

+1 -1

crates/jacquard-api/src/sh_tangled/repo/pull/comment.rs

··· 99 99 } 100 100 fn validate( 101 101 &self, 102 102 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 102 102 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 103 103 Ok(()) 104 104 } 105 105 }

+1 -1

crates/jacquard-api/src/sh_tangled/repo/pull/status.rs

··· 103 103 } 104 104 fn validate( 105 105 &self, 106 106 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 106 106 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 107 107 Ok(()) 108 108 } 109 109 }

+3 -3

crates/jacquard-api/src/sh_tangled/repo/tree.rs

··· 361 361 } 362 362 fn validate( 363 363 &self, 364 364 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 364 364 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 365 365 Ok(()) 366 366 } 367 367 } ··· 547 547 } 548 548 fn validate( 549 549 &self, 550 550 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 550 550 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 551 551 Ok(()) 552 552 } 553 553 } ··· 597 597 } 598 598 fn validate( 599 599 &self, 600 600 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 600 600 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 601 601 Ok(()) 602 602 } 603 603 }

+1 -1

crates/jacquard-api/src/sh_tangled/spindle.rs

··· 96 96 } 97 97 fn validate( 98 98 &self, 99 99 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 99 99 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 100 100 Ok(()) 101 101 } 102 102 }

+1 -1

crates/jacquard-api/src/sh_tangled/spindle/member.rs

··· 100 100 } 101 101 fn validate( 102 102 &self, 103 103 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 103 103 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 104 104 Ok(()) 105 105 } 106 106 }

+17 -9

crates/jacquard-api/src/sh_tangled/string.rs

··· 103 103 } 104 104 fn validate( 105 105 &self, 106 106 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 106 106 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 107 107 { 108 108 let value = &self.contents; 109 109 { ··· 113 113 ) 114 114 .count(); 115 115 if count < 1usize { 116 116 - return Err(::jacquard_lexicon::schema::ValidationError::MinGraphemes { 117 117 - field: "contents", 116 116 + return Err(::jacquard_lexicon::validation::ConstraintError::MinGraphemes { 117 117 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 118 118 + "contents", 119 119 + ), 118 120 min: 1usize, 119 121 actual: count, 120 122 }); ··· 130 132 ) 131 133 .count(); 132 134 if count > 280usize { 133 133 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 134 134 - field: "description", 135 135 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 136 136 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 137 137 + "description", 138 138 + ), 135 139 max: 280usize, 136 140 actual: count, 137 141 }); ··· 147 151 ) 148 152 .count(); 149 153 if count > 140usize { 150 150 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 151 151 - field: "filename", 154 154 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 155 155 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 156 156 + "filename", 157 157 + ), 152 158 max: 140usize, 153 159 actual: count, 154 160 }); ··· 164 170 ) 165 171 .count(); 166 172 if count < 1usize { 167 167 - return Err(::jacquard_lexicon::schema::ValidationError::MinGraphemes { 168 168 - field: "filename", 173 173 + return Err(::jacquard_lexicon::validation::ConstraintError::MinGraphemes { 174 174 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 175 175 + "filename", 176 176 + ), 169 177 min: 1usize, 170 178 actual: count, 171 179 });

+84 -44

crates/jacquard-api/src/sh_weaver/actor.rs

··· 543 543 } 544 544 fn validate( 545 545 &self, 546 546 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 546 546 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 547 547 if let Some(ref value) = self.display_name { 548 548 #[allow(unused_comparisons)] 549 549 if <str>::len(value.as_ref()) > 640usize { 550 550 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 551 551 - field: "display_name", 550 550 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 551 551 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 552 552 + "display_name", 553 553 + ), 552 554 max: 640usize, 553 555 actual: <str>::len(value.as_ref()), 554 556 }); ··· 562 564 ) 563 565 .count(); 564 566 if count > 64usize { 565 565 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 566 566 - field: "display_name", 567 567 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 568 568 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 569 569 + "display_name", 570 570 + ), 567 571 max: 64usize, 568 572 actual: count, 569 573 }); ··· 622 626 } 623 627 fn validate( 624 628 &self, 625 625 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 629 629 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 626 630 Ok(()) 627 631 } 628 632 } ··· 694 698 } 695 699 fn validate( 696 700 &self, 697 697 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 701 701 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 698 702 if let Some(ref value) = self.description { 699 703 #[allow(unused_comparisons)] 700 704 if <str>::len(value.as_ref()) > 2560usize { 701 701 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 702 702 - field: "description", 705 705 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 706 706 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 707 707 + "description", 708 708 + ), 703 709 max: 2560usize, 704 710 actual: <str>::len(value.as_ref()), 705 711 }); ··· 713 719 ) 714 720 .count(); 715 721 if count > 256usize { 716 716 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 717 717 - field: "description", 722 722 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 723 723 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 724 724 + "description", 725 725 + ), 718 726 max: 256usize, 719 727 actual: count, 720 728 }); ··· 724 732 if let Some(ref value) = self.display_name { 725 733 #[allow(unused_comparisons)] 726 734 if <str>::len(value.as_ref()) > 640usize { 727 727 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 728 728 - field: "display_name", 735 735 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 736 736 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 737 737 + "display_name", 738 738 + ), 729 739 max: 640usize, 730 740 actual: <str>::len(value.as_ref()), 731 741 }); ··· 739 749 ) 740 750 .count(); 741 751 if count > 64usize { 742 742 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 743 743 - field: "display_name", 752 752 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 753 753 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 754 754 + "display_name", 755 755 + ), 744 756 max: 64usize, 745 757 actual: count, 746 758 }); ··· 750 762 if let Some(ref value) = self.links { 751 763 #[allow(unused_comparisons)] 752 764 if value.len() > 5usize { 753 753 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 754 754 - field: "links", 765 765 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 766 766 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 767 767 + "links", 768 768 + ), 755 769 max: 5usize, 756 770 actual: value.len(), 757 771 }); ··· 760 774 if let Some(ref value) = self.links { 761 775 #[allow(unused_comparisons)] 762 776 if value.len() < 0usize { 763 763 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 764 764 - field: "links", 777 777 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 778 778 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 779 779 + "links", 780 780 + ), 765 781 min: 0usize, 766 782 actual: value.len(), 767 783 }); ··· 770 786 if let Some(ref value) = self.location { 771 787 #[allow(unused_comparisons)] 772 788 if <str>::len(value.as_ref()) > 400usize { 773 773 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 774 774 - field: "location", 789 789 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 790 790 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 791 791 + "location", 792 792 + ), 775 793 max: 400usize, 776 794 actual: <str>::len(value.as_ref()), 777 795 }); ··· 785 803 ) 786 804 .count(); 787 805 if count > 40usize { 788 788 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 789 789 - field: "location", 806 806 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 807 807 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 808 808 + "location", 809 809 + ), 790 810 max: 40usize, 791 811 actual: count, 792 812 }); ··· 853 873 } 854 874 fn validate( 855 875 &self, 856 856 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 876 876 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 857 877 if let Some(ref value) = self.description { 858 878 #[allow(unused_comparisons)] 859 879 if <str>::len(value.as_ref()) > 2560usize { 860 860 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 861 861 - field: "description", 880 880 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 881 881 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 882 882 + "description", 883 883 + ), 862 884 max: 2560usize, 863 885 actual: <str>::len(value.as_ref()), 864 886 }); ··· 872 894 ) 873 895 .count(); 874 896 if count > 256usize { 875 875 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 876 876 - field: "description", 897 897 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 898 898 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 899 899 + "description", 900 900 + ), 877 901 max: 256usize, 878 902 actual: count, 879 903 }); ··· 883 907 if let Some(ref value) = self.links { 884 908 #[allow(unused_comparisons)] 885 909 if value.len() > 5usize { 886 886 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 887 887 - field: "links", 910 910 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 911 911 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 912 912 + "links", 913 913 + ), 888 914 max: 5usize, 889 915 actual: value.len(), 890 916 }); ··· 893 919 if let Some(ref value) = self.links { 894 920 #[allow(unused_comparisons)] 895 921 if value.len() < 0usize { 896 896 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 897 897 - field: "links", 922 922 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 923 923 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 924 924 + "links", 925 925 + ), 898 926 min: 0usize, 899 927 actual: value.len(), 900 928 }); ··· 903 931 if let Some(ref value) = self.location { 904 932 #[allow(unused_comparisons)] 905 933 if <str>::len(value.as_ref()) > 400usize { 906 906 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 907 907 - field: "location", 934 934 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 935 935 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 936 936 + "location", 937 937 + ), 908 938 max: 400usize, 909 939 actual: <str>::len(value.as_ref()), 910 940 }); ··· 918 948 ) 919 949 .count(); 920 950 if count > 40usize { 921 921 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 922 922 - field: "location", 951 951 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 952 952 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 953 953 + "location", 954 954 + ), 923 955 max: 40usize, 924 956 actual: count, 925 957 }); ··· 929 961 if let Some(ref value) = self.pinned_repositories { 930 962 #[allow(unused_comparisons)] 931 963 if value.len() > 6usize { 932 932 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 933 933 - field: "pinned_repositories", 964 964 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 965 965 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 966 966 + "pinned_repositories", 967 967 + ), 934 968 max: 6usize, 935 969 actual: value.len(), 936 970 }); ··· 939 973 if let Some(ref value) = self.pinned_repositories { 940 974 #[allow(unused_comparisons)] 941 975 if value.len() < 0usize { 942 942 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 943 943 - field: "pinned_repositories", 976 976 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 977 977 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 978 978 + "pinned_repositories", 979 979 + ), 944 980 min: 0usize, 945 981 actual: value.len(), 946 982 }); ··· 949 985 if let Some(ref value) = self.stats { 950 986 #[allow(unused_comparisons)] 951 987 if value.len() > 2usize { 952 952 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 953 953 - field: "stats", 988 988 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 989 989 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 990 990 + "stats", 991 991 + ), 954 992 max: 2usize, 955 993 actual: value.len(), 956 994 }); ··· 959 997 if let Some(ref value) = self.stats { 960 998 #[allow(unused_comparisons)] 961 999 if value.len() < 0usize { 962 962 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 963 963 - field: "stats", 1000 1000 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 1001 1001 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1002 1002 + "stats", 1003 1003 + ), 964 1004 min: 0usize, 965 1005 actual: value.len(), 966 1006 });

+33 -17

crates/jacquard-api/src/sh_weaver/actor/profile.rs

··· 137 137 } 138 138 fn validate( 139 139 &self, 140 140 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 140 140 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 141 141 if let Some(ref value) = self.description { 142 142 #[allow(unused_comparisons)] 143 143 if <str>::len(value.as_ref()) > 2560usize { 144 144 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 145 145 - field: "description", 144 144 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 145 145 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 146 146 + "description", 147 147 + ), 146 148 max: 2560usize, 147 149 actual: <str>::len(value.as_ref()), 148 150 }); ··· 156 158 ) 157 159 .count(); 158 160 if count > 256usize { 159 159 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 160 160 - field: "description", 161 161 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 162 162 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 163 163 + "description", 164 164 + ), 161 165 max: 256usize, 162 166 actual: count, 163 167 }); ··· 167 171 if let Some(ref value) = self.display_name { 168 172 #[allow(unused_comparisons)] 169 173 if <str>::len(value.as_ref()) > 640usize { 170 170 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 171 171 - field: "display_name", 174 174 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 175 175 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 176 176 + "display_name", 177 177 + ), 172 178 max: 640usize, 173 179 actual: <str>::len(value.as_ref()), 174 180 }); ··· 182 188 ) 183 189 .count(); 184 190 if count > 64usize { 185 185 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 186 186 - field: "display_name", 191 191 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 192 192 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 193 193 + "display_name", 194 194 + ), 187 195 max: 64usize, 188 196 actual: count, 189 197 }); ··· 193 201 if let Some(ref value) = self.links { 194 202 #[allow(unused_comparisons)] 195 203 if value.len() > 5usize { 196 196 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 197 197 - field: "links", 204 204 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 205 205 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 206 206 + "links", 207 207 + ), 198 208 max: 5usize, 199 209 actual: value.len(), 200 210 }); ··· 203 213 if let Some(ref value) = self.links { 204 214 #[allow(unused_comparisons)] 205 215 if value.len() < 0usize { 206 206 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 207 207 - field: "links", 216 216 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 217 217 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 218 218 + "links", 219 219 + ), 208 220 min: 0usize, 209 221 actual: value.len(), 210 222 }); ··· 213 225 if let Some(ref value) = self.location { 214 226 #[allow(unused_comparisons)] 215 227 if <str>::len(value.as_ref()) > 400usize { 216 216 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 217 217 - field: "location", 228 228 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 229 229 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 230 230 + "location", 231 231 + ), 218 232 max: 400usize, 219 233 actual: <str>::len(value.as_ref()), 220 234 }); ··· 228 242 ) 229 243 .count(); 230 244 if count > 40usize { 231 231 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 232 232 - field: "location", 245 245 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 246 246 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 247 247 + "location", 248 248 + ), 233 249 max: 40usize, 234 250 actual: count, 235 251 });

+3 -3

crates/jacquard-api/src/sh_weaver/edit.rs

··· 150 150 } 151 151 fn validate( 152 152 &self, 153 153 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 153 153 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 154 154 Ok(()) 155 155 } 156 156 } ··· 184 184 } 185 185 fn validate( 186 186 &self, 187 187 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 187 187 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 188 188 Ok(()) 189 189 } 190 190 } ··· 218 218 } 219 219 fn validate( 220 220 &self, 221 221 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 221 221 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 222 222 Ok(()) 223 223 } 224 224 }

+6 -6

crates/jacquard-api/src/sh_weaver/edit/cursor.rs

··· 317 317 } 318 318 fn validate( 319 319 &self, 320 320 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 320 320 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 321 321 Ok(()) 322 322 } 323 323 } ··· 351 351 } 352 352 fn validate( 353 353 &self, 354 354 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 354 354 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 355 355 Ok(()) 356 356 } 357 357 } ··· 385 385 } 386 386 fn validate( 387 387 &self, 388 388 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 388 388 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 389 389 Ok(()) 390 390 } 391 391 } ··· 489 489 } 490 490 fn validate( 491 491 &self, 492 492 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 492 492 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 493 493 Ok(()) 494 494 } 495 495 } ··· 526 526 } 527 527 fn validate( 528 528 &self, 529 529 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 529 529 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 530 530 Ok(()) 531 531 } 532 532 } ··· 562 562 } 563 563 fn validate( 564 564 &self, 565 565 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 565 565 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 566 566 Ok(()) 567 567 } 568 568 }

+1 -1

crates/jacquard-api/src/sh_weaver/edit/diff.rs

··· 100 100 } 101 101 fn validate( 102 102 &self, 103 103 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 103 103 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 104 104 Ok(()) 105 105 } 106 106 }

+1 -1

crates/jacquard-api/src/sh_weaver/edit/root.rs

··· 102 102 } 103 103 fn validate( 104 104 &self, 105 105 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 105 105 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 106 106 Ok(()) 107 107 } 108 108 }

+2 -2

crates/jacquard-api/src/sh_weaver/embed.rs

··· 144 144 } 145 145 fn validate( 146 146 &self, 147 147 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 147 147 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 148 148 Ok(()) 149 149 } 150 150 } ··· 179 179 } 180 180 fn validate( 181 181 &self, 182 182 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 182 182 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 183 183 Ok(()) 184 184 } 185 185 }

+8 -6

crates/jacquard-api/src/sh_weaver/embed/external.rs

··· 273 273 } 274 274 fn validate( 275 275 &self, 276 276 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 276 276 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 277 277 Ok(()) 278 278 } 279 279 } ··· 307 307 } 308 308 fn validate( 309 309 &self, 310 310 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 310 310 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 311 311 { 312 312 let value = &self.embeds; 313 313 #[allow(unused_comparisons)] 314 314 if value.len() > 48usize { 315 315 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 316 316 - field: "embeds", 315 315 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 316 316 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 317 317 + "embeds", 318 318 + ), 317 319 max: 48usize, 318 320 actual: value.len(), 319 321 }); ··· 352 354 } 353 355 fn validate( 354 356 &self, 355 355 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 357 357 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 356 358 Ok(()) 357 359 } 358 360 } ··· 396 398 } 397 399 fn validate( 398 400 &self, 399 399 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 401 401 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 400 402 Ok(()) 401 403 } 402 404 }

+10 -6

crates/jacquard-api/src/sh_weaver/embed/images.rs

··· 188 188 } 189 189 fn validate( 190 190 &self, 191 191 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 191 191 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 192 192 if let Some(ref value) = self.blurhash { 193 193 #[allow(unused_comparisons)] 194 194 if <str>::len(value.as_ref()) > 32usize { 195 195 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 196 196 - field: "blurhash", 195 195 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 196 196 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 197 197 + "blurhash", 198 198 + ), 197 199 max: 32usize, 198 200 actual: <str>::len(value.as_ref()), 199 201 }); ··· 232 234 } 233 235 fn validate( 234 236 &self, 235 235 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 237 237 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 236 238 { 237 239 let value = &self.images; 238 240 #[allow(unused_comparisons)] 239 241 if value.len() > 48usize { 240 240 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 241 241 - field: "images", 242 242 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 243 243 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 244 244 + "images", 245 245 + ), 242 246 max: 48usize, 243 247 actual: value.len(), 244 248 });

+2 -2

crates/jacquard-api/src/sh_weaver/embed/record_with_media.rs

··· 181 181 } 182 182 fn validate( 183 183 &self, 184 184 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 184 184 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 185 185 Ok(()) 186 186 } 187 187 } ··· 261 261 } 262 262 fn validate( 263 263 &self, 264 264 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 264 264 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 265 265 Ok(()) 266 266 } 267 267 }

+10 -8

crates/jacquard-api/src/sh_weaver/embed/records.rs

··· 425 425 } 426 426 fn validate( 427 427 &self, 428 428 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 428 428 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 429 429 { 430 430 let value = &self.records; 431 431 #[allow(unused_comparisons)] 432 432 if value.len() > 48usize { 433 433 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 434 434 - field: "records", 433 433 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 434 434 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 435 435 + "records", 436 436 + ), 435 437 max: 48usize, 436 438 actual: value.len(), 437 439 }); ··· 501 503 } 502 504 fn validate( 503 505 &self, 504 504 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 506 506 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 505 507 Ok(()) 506 508 } 507 509 } ··· 538 540 } 539 541 fn validate( 540 542 &self, 541 541 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 543 543 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 542 544 Ok(()) 543 545 } 544 546 } ··· 573 575 } 574 576 fn validate( 575 577 &self, 576 576 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 578 578 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 577 579 Ok(()) 578 580 } 579 581 } ··· 608 610 } 609 611 fn validate( 610 612 &self, 611 611 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 613 613 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 612 614 Ok(()) 613 615 } 614 616 } ··· 697 699 } 698 700 fn validate( 699 701 &self, 700 700 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 702 702 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 701 703 Ok(()) 702 704 } 703 705 }

+23 -13

crates/jacquard-api/src/sh_weaver/embed/video.rs

··· 255 255 } 256 256 fn validate( 257 257 &self, 258 258 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 258 258 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 259 259 Ok(()) 260 260 } 261 261 } ··· 303 303 } 304 304 fn validate( 305 305 &self, 306 306 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 306 306 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 307 307 if let Some(ref value) = self.alt { 308 308 #[allow(unused_comparisons)] 309 309 if <str>::len(value.as_ref()) > 10000usize { 310 310 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 311 311 - field: "alt", 310 310 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 311 311 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 312 312 + "alt", 313 313 + ), 312 314 max: 10000usize, 313 315 actual: <str>::len(value.as_ref()), 314 316 }); ··· 322 324 ) 323 325 .count(); 324 326 if count > 1000usize { 325 325 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 326 326 - field: "alt", 327 327 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 328 328 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 329 329 + "alt", 330 330 + ), 327 331 max: 1000usize, 328 332 actual: count, 329 333 }); ··· 333 337 if let Some(ref value) = self.captions { 334 338 #[allow(unused_comparisons)] 335 339 if value.len() > 20usize { 336 336 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 337 337 - field: "captions", 340 340 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 341 341 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 342 342 + "captions", 343 343 + ), 338 344 max: 20usize, 339 345 actual: value.len(), 340 346 }); ··· 387 393 } 388 394 fn validate( 389 395 &self, 390 390 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 396 396 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 391 397 if let Some(ref value) = self.alt { 392 398 #[allow(unused_comparisons)] 393 399 if <str>::len(value.as_ref()) > 10000usize { 394 394 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 395 395 - field: "alt", 400 400 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 401 401 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 402 402 + "alt", 403 403 + ), 396 404 max: 10000usize, 397 405 actual: <str>::len(value.as_ref()), 398 406 }); ··· 406 414 ) 407 415 .count(); 408 416 if count > 1000usize { 409 409 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 410 410 - field: "alt", 417 417 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 418 418 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 419 419 + "alt", 420 420 + ), 411 421 max: 1000usize, 412 422 actual: count, 413 423 });

+7 -7

crates/jacquard-api/src/sh_weaver/notebook.rs

··· 541 541 } 542 542 fn validate( 543 543 &self, 544 544 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 544 544 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 545 545 Ok(()) 546 546 } 547 547 } ··· 575 575 } 576 576 fn validate( 577 577 &self, 578 578 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 578 578 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 579 579 Ok(()) 580 580 } 581 581 } ··· 619 619 } 620 620 fn validate( 621 621 &self, 622 622 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 622 622 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 623 623 Ok(()) 624 624 } 625 625 } ··· 656 656 } 657 657 fn validate( 658 658 &self, 659 659 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 659 659 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 660 660 Ok(()) 661 661 } 662 662 } ··· 711 711 } 712 712 fn validate( 713 713 &self, 714 714 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 714 714 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 715 715 Ok(()) 716 716 } 717 717 } ··· 762 762 } 763 763 fn validate( 764 764 &self, 765 765 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 765 765 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 766 766 Ok(()) 767 767 } 768 768 } ··· 801 801 } 802 802 fn validate( 803 803 &self, 804 804 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 804 804 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 805 805 Ok(()) 806 806 } 807 807 }

+2 -2

crates/jacquard-api/src/sh_weaver/notebook/authors.rs

··· 177 177 } 178 178 fn validate( 179 179 &self, 180 180 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 180 180 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 181 181 Ok(()) 182 182 } 183 183 } ··· 276 276 } 277 277 fn validate( 278 278 &self, 279 279 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 279 279 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 280 280 Ok(()) 281 281 } 282 282 }

+1 -1

crates/jacquard-api/src/sh_weaver/notebook/book.rs

··· 110 110 } 111 111 fn validate( 112 112 &self, 113 113 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 113 113 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 114 114 Ok(()) 115 115 } 116 116 }

+1 -1

crates/jacquard-api/src/sh_weaver/notebook/chapter.rs

··· 111 111 } 112 112 fn validate( 113 113 &self, 114 114 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 114 114 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 115 115 Ok(()) 116 116 } 117 117 }

+5 -3

crates/jacquard-api/src/sh_weaver/notebook/entry.rs

··· 111 111 } 112 112 fn validate( 113 113 &self, 114 114 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 114 114 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 115 115 { 116 116 let value = &self.content; 117 117 #[allow(unused_comparisons)] 118 118 if <str>::len(value.as_ref()) > 200000usize { 119 119 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 120 120 - field: "content", 119 119 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 120 120 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 121 121 + "content", 122 122 + ), 121 123 max: 200000usize, 122 124 actual: <str>::len(value.as_ref()), 123 125 });

+1 -1

crates/jacquard-api/src/sh_weaver/publish/blob.rs

··· 97 97 } 98 98 fn validate( 99 99 &self, 100 100 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 100 100 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 101 101 Ok(()) 102 102 } 103 103 }

+18 -10

crates/jacquard-api/src/social_clippr/actor.rs

··· 307 307 } 308 308 fn validate( 309 309 &self, 310 310 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 310 310 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 311 311 if let Some(ref value) = self.description { 312 312 #[allow(unused_comparisons)] 313 313 if <str>::len(value.as_ref()) > 5000usize { 314 314 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 315 315 - field: "description", 314 314 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 315 315 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 316 316 + "description", 317 317 + ), 316 318 max: 5000usize, 317 319 actual: <str>::len(value.as_ref()), 318 320 }); ··· 326 328 ) 327 329 .count(); 328 330 if count > 500usize { 329 329 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 330 330 - field: "description", 331 331 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 332 332 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 333 333 + "description", 334 334 + ), 331 335 max: 500usize, 332 336 actual: count, 333 337 }); ··· 338 342 let value = &self.display_name; 339 343 #[allow(unused_comparisons)] 340 344 if <str>::len(value.as_ref()) > 640usize { 341 341 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 342 342 - field: "display_name", 345 345 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 346 346 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 347 347 + "display_name", 348 348 + ), 343 349 max: 640usize, 344 350 actual: <str>::len(value.as_ref()), 345 351 }); ··· 354 360 ) 355 361 .count(); 356 362 if count > 64usize { 357 357 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 358 358 - field: "display_name", 363 363 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 364 364 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 365 365 + "display_name", 366 366 + ), 359 367 max: 64usize, 360 368 actual: count, 361 369 }); ··· 397 405 } 398 406 fn validate( 399 407 &self, 400 400 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 408 408 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 401 409 Ok(()) 402 410 } 403 411 }

+17 -9

crates/jacquard-api/src/social_clippr/actor/profile.rs

··· 110 110 } 111 111 fn validate( 112 112 &self, 113 113 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 113 113 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 114 114 if let Some(ref value) = self.description { 115 115 #[allow(unused_comparisons)] 116 116 if <str>::len(value.as_ref()) > 5000usize { 117 117 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 118 118 - field: "description", 117 117 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 118 118 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 119 119 + "description", 120 120 + ), 119 121 max: 5000usize, 120 122 actual: <str>::len(value.as_ref()), 121 123 }); ··· 129 131 ) 130 132 .count(); 131 133 if count > 500usize { 132 132 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 133 133 - field: "description", 134 134 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 135 135 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 136 136 + "description", 137 137 + ), 134 138 max: 500usize, 135 139 actual: count, 136 140 }); ··· 141 145 let value = &self.display_name; 142 146 #[allow(unused_comparisons)] 143 147 if <str>::len(value.as_ref()) > 640usize { 144 144 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 145 145 - field: "display_name", 148 148 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 149 149 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 150 150 + "display_name", 151 151 + ), 146 152 max: 640usize, 147 153 actual: <str>::len(value.as_ref()), 148 154 }); ··· 157 163 ) 158 164 .count(); 159 165 if count > 64usize { 160 160 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 161 161 - field: "display_name", 166 166 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 167 167 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 168 168 + "display_name", 169 169 + ), 162 170 max: 64usize, 163 171 actual: count, 164 172 });

+2 -2

crates/jacquard-api/src/social_clippr/feed.rs

··· 274 274 } 275 275 fn validate( 276 276 &self, 277 277 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 277 277 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 278 278 Ok(()) 279 279 } 280 280 } ··· 321 321 } 322 322 fn validate( 323 323 &self, 324 324 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 324 324 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 325 325 Ok(()) 326 326 } 327 327 }

+37 -19

crates/jacquard-api/src/social_clippr/feed/clip.rs

··· 127 127 } 128 128 fn validate( 129 129 &self, 130 130 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 130 130 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 131 131 { 132 132 let value = &self.description; 133 133 #[allow(unused_comparisons)] 134 134 if <str>::len(value.as_ref()) > 40960usize { 135 135 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 136 136 - field: "description", 135 135 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 136 136 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 137 137 + "description", 138 138 + ), 137 139 max: 40960usize, 138 140 actual: <str>::len(value.as_ref()), 139 141 }); ··· 148 150 ) 149 151 .count(); 150 152 if count > 4096usize { 151 151 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 152 152 - field: "description", 153 153 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 154 154 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 155 155 + "description", 156 156 + ), 153 157 max: 4096usize, 154 158 actual: count, 155 159 }); ··· 159 163 if let Some(ref value) = self.languages { 160 164 #[allow(unused_comparisons)] 161 165 if value.len() > 5usize { 162 162 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 163 163 - field: "languages", 166 166 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 167 167 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 168 168 + "languages", 169 169 + ), 164 170 max: 5usize, 165 171 actual: value.len(), 166 172 }); ··· 169 175 if let Some(ref value) = self.notes { 170 176 #[allow(unused_comparisons)] 171 177 if <str>::len(value.as_ref()) > 100000usize { 172 172 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 173 173 - field: "notes", 178 178 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 179 179 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 180 180 + "notes", 181 181 + ), 174 182 max: 100000usize, 175 183 actual: <str>::len(value.as_ref()), 176 184 }); ··· 184 192 ) 185 193 .count(); 186 194 if count > 10000usize { 187 187 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 188 188 - field: "notes", 195 195 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 196 196 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 197 197 + "notes", 198 198 + ), 189 199 max: 10000usize, 190 200 actual: count, 191 201 }); ··· 196 206 let value = &self.title; 197 207 #[allow(unused_comparisons)] 198 208 if <str>::len(value.as_ref()) > 20480usize { 199 199 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 200 200 - field: "title", 209 209 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 210 210 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 211 211 + "title", 212 212 + ), 201 213 max: 20480usize, 202 214 actual: <str>::len(value.as_ref()), 203 215 }); ··· 212 224 ) 213 225 .count(); 214 226 if count > 2048usize { 215 215 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 216 216 - field: "title", 227 227 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 228 228 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 229 229 + "title", 230 230 + ), 217 231 max: 2048usize, 218 232 actual: count, 219 233 }); ··· 224 238 let value = &self.url; 225 239 #[allow(unused_comparisons)] 226 240 if <str>::len(value.as_ref()) > 20000usize { 227 227 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 228 228 - field: "url", 241 241 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 242 242 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 243 243 + "url", 244 244 + ), 229 245 max: 20000usize, 230 246 actual: <str>::len(value.as_ref()), 231 247 }); ··· 240 256 ) 241 257 .count(); 242 258 if count > 2000usize { 243 243 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 244 244 - field: "url", 259 259 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 260 260 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 261 261 + "url", 262 262 + ), 245 263 max: 2000usize, 246 264 actual: count, 247 265 });

+25 -13

crates/jacquard-api/src/social_clippr/feed/tag.rs

··· 110 110 } 111 111 fn validate( 112 112 &self, 113 113 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 113 113 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 114 114 if let Some(ref value) = self.color { 115 115 #[allow(unused_comparisons)] 116 116 if <str>::len(value.as_ref()) > 70usize { 117 117 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 118 118 - field: "color", 117 117 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 118 118 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 119 119 + "color", 120 120 + ), 119 121 max: 70usize, 120 122 actual: <str>::len(value.as_ref()), 121 123 }); ··· 129 131 ) 130 132 .count(); 131 133 if count > 7usize { 132 132 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 133 133 - field: "color", 134 134 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 135 135 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 136 136 + "color", 137 137 + ), 134 138 max: 7usize, 135 139 actual: count, 136 140 }); ··· 140 144 if let Some(ref value) = self.description { 141 145 #[allow(unused_comparisons)] 142 146 if <str>::len(value.as_ref()) > 50000usize { 143 143 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 144 144 - field: "description", 147 147 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 148 148 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 149 149 + "description", 150 150 + ), 145 151 max: 50000usize, 146 152 actual: <str>::len(value.as_ref()), 147 153 }); ··· 155 161 ) 156 162 .count(); 157 163 if count > 5000usize { 158 158 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 159 159 - field: "description", 164 164 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 165 165 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 166 166 + "description", 167 167 + ), 160 168 max: 5000usize, 161 169 actual: count, 162 170 }); ··· 167 175 let value = &self.name; 168 176 #[allow(unused_comparisons)] 169 177 if <str>::len(value.as_ref()) > 640usize { 170 170 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 171 171 - field: "name", 178 178 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 179 179 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 180 180 + "name", 181 181 + ), 172 182 max: 640usize, 173 183 actual: <str>::len(value.as_ref()), 174 184 }); ··· 183 193 ) 184 194 .count(); 185 195 if count > 64usize { 186 186 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 187 187 - field: "name", 196 196 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 197 197 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 198 198 + "name", 199 199 + ), 188 200 max: 64usize, 189 201 actual: count, 190 202 });

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/action.rs

··· 547 547 } 548 548 fn validate( 549 549 &self, 550 550 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 550 550 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 551 551 Ok(()) 552 552 } 553 553 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/aggregaterating.rs

··· 356 356 } 357 357 fn validate( 358 358 &self, 359 359 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 359 359 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 360 360 Ok(()) 361 361 } 362 362 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/alignmentobject.rs

··· 300 300 } 301 301 fn validate( 302 302 &self, 303 303 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 303 303 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 304 304 Ok(()) 305 305 } 306 306 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/audience.rs

··· 300 300 } 301 301 fn validate( 302 302 &self, 303 303 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 303 303 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 304 304 Ok(()) 305 305 } 306 306 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/audioobject.rs

··· 2592 2592 } 2593 2593 fn validate( 2594 2594 &self, 2595 2595 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2595 2595 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2596 2596 Ok(()) 2597 2597 } 2598 2598 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/brand.rs

··· 352 352 } 353 353 fn validate( 354 354 &self, 355 355 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 355 355 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 356 356 Ok(()) 357 357 } 358 358 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/breadcrumblist.rs

··· 218 218 } 219 219 fn validate( 220 220 &self, 221 221 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 221 221 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 222 222 Ok(()) 223 223 } 224 224 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/categorycode.rs

··· 327 327 } 328 328 fn validate( 329 329 &self, 330 330 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 330 330 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 331 331 Ok(()) 332 332 } 333 333 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/certification.rs

··· 2447 2447 } 2448 2448 fn validate( 2449 2449 &self, 2450 2450 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2450 2450 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2451 2451 Ok(()) 2452 2452 } 2453 2453 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/claim.rs

··· 2366 2366 } 2367 2367 fn validate( 2368 2368 &self, 2369 2369 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2369 2369 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2370 2370 Ok(()) 2371 2371 } 2372 2372 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/clip.rs

··· 2537 2537 } 2538 2538 fn validate( 2539 2539 &self, 2540 2540 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2540 2540 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2541 2541 Ok(()) 2542 2542 } 2543 2543 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/comment.rs

··· 2346 2346 } 2347 2347 fn validate( 2348 2348 &self, 2349 2349 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2349 2349 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2350 2350 Ok(()) 2351 2351 } 2352 2352 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/correctioncomment.rs

··· 2346 2346 } 2347 2347 fn validate( 2348 2348 &self, 2349 2349 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2349 2349 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2350 2350 Ok(()) 2351 2351 } 2352 2352 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/country.rs

··· 1069 1069 } 1070 1070 fn validate( 1071 1071 &self, 1072 1072 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1072 1072 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1073 1073 Ok(()) 1074 1074 } 1075 1075 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/creativework.rs

··· 2288 2288 } 2289 2289 fn validate( 2290 2290 &self, 2291 2291 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2291 2291 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2292 2292 Ok(()) 2293 2293 } 2294 2294 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/creativeworkseason.rs

··· 2475 2475 } 2476 2476 fn validate( 2477 2477 &self, 2478 2478 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2478 2478 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2479 2479 Ok(()) 2480 2480 } 2481 2481 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/definedterm.rs

··· 300 300 } 301 301 fn validate( 302 302 &self, 303 303 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 303 303 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 304 304 Ok(()) 305 305 } 306 306 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/demand.rs

··· 854 854 } 855 855 fn validate( 856 856 &self, 857 857 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 857 857 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 858 858 Ok(()) 859 859 } 860 860 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/distance.rs

··· 273 273 } 274 274 fn validate( 275 275 &self, 276 276 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 276 276 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 277 277 Ok(()) 278 278 } 279 279 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/duration.rs

··· 273 273 } 274 274 fn validate( 275 275 &self, 276 276 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 276 276 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 277 277 Ok(()) 278 278 } 279 279 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/energyconsumptiondetails.rs

··· 288 288 } 289 289 fn validate( 290 290 &self, 291 291 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 291 291 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 292 292 Ok(()) 293 293 } 294 294 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/episode.rs

··· 2545 2545 } 2546 2546 fn validate( 2547 2547 &self, 2548 2548 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2548 2548 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2549 2549 Ok(()) 2550 2550 } 2551 2551 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/event.rs

··· 1074 1074 } 1075 1075 fn validate( 1076 1076 &self, 1077 1077 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1077 1077 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1078 1078 Ok(()) 1079 1079 } 1080 1080 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/grant.rs

··· 362 362 } 363 363 fn validate( 364 364 &self, 365 365 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 365 365 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 366 366 Ok(()) 367 367 } 368 368 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/howtosection.rs

··· 118 118 } 119 119 fn validate( 120 120 &self, 121 121 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 121 121 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 122 122 Ok(()) 123 123 } 124 124 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/howtostep.rs

··· 92 92 } 93 93 fn validate( 94 94 &self, 95 95 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 95 95 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 96 96 Ok(()) 97 97 } 98 98 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/howtosupply.rs

··· 402 402 } 403 403 fn validate( 404 404 &self, 405 405 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 405 405 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 406 406 Ok(()) 407 407 } 408 408 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/howtotool.rs

··· 376 376 } 377 377 fn validate( 378 378 &self, 379 379 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 379 379 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 380 380 Ok(()) 381 381 } 382 382 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/imageobject.rs

··· 2617 2617 } 2618 2618 fn validate( 2619 2619 &self, 2620 2620 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2620 2620 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2621 2621 Ok(()) 2622 2622 } 2623 2623 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/interactioncounter.rs

··· 357 357 } 358 358 fn validate( 359 359 &self, 360 360 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 360 360 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 361 361 Ok(()) 362 362 } 363 363 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/iptcdigitalsourceenumeration.rs

··· 203 203 } 204 204 fn validate( 205 205 &self, 206 206 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 206 206 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 207 207 Ok(()) 208 208 } 209 209 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/itemlist.rs

··· 349 349 } 350 350 fn validate( 351 351 &self, 352 352 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 352 352 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 353 353 Ok(()) 354 354 } 355 355 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/language.rs

··· 273 273 } 274 274 fn validate( 275 275 &self, 276 276 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 276 276 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 277 277 Ok(()) 278 278 } 279 279 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/listitem.rs

··· 350 350 } 351 351 fn validate( 352 352 &self, 353 353 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 353 353 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 354 354 Ok(()) 355 355 } 356 356 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/mass.rs

··· 273 273 } 274 274 fn validate( 275 275 &self, 276 276 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 276 276 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 277 277 Ok(()) 278 278 } 279 279 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/mediaobject.rs

··· 2558 2558 } 2559 2559 fn validate( 2560 2560 &self, 2561 2561 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2561 2561 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2562 2562 Ok(()) 2563 2563 } 2564 2564 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/merchantreturnpolicy.rs

··· 590 590 } 591 591 fn validate( 592 592 &self, 593 593 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 593 593 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 594 594 Ok(()) 595 595 } 596 596 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/monetaryamount.rs

··· 316 316 } 317 317 fn validate( 318 318 &self, 319 319 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 319 319 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 320 320 Ok(()) 321 321 } 322 322 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/musicgroup.rs

··· 1892 1892 } 1893 1893 fn validate( 1894 1894 &self, 1895 1895 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1895 1895 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1896 1896 Ok(()) 1897 1897 } 1898 1898 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/musicrecording.rs

··· 2413 2413 } 2414 2414 fn validate( 2415 2415 &self, 2416 2416 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2416 2416 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2417 2417 Ok(()) 2418 2418 } 2419 2419 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/newsarticle.rs

··· 1235 1235 } 1236 1236 fn validate( 1237 1237 &self, 1238 1238 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1238 1238 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1239 1239 Ok(()) 1240 1240 } 1241 1241 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/nutritioninformation.rs

··· 540 540 } 541 541 fn validate( 542 542 &self, 543 543 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 543 543 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 544 544 Ok(()) 545 545 } 546 546 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/offer.rs

··· 1206 1206 } 1207 1207 fn validate( 1208 1208 &self, 1209 1209 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1209 1209 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1210 1210 Ok(()) 1211 1211 } 1212 1212 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/offeritemcondition.rs

··· 295 295 } 296 296 fn validate( 297 297 &self, 298 298 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 298 298 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 299 299 Ok(()) 300 300 } 301 301 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/organization.rs

··· 1767 1767 } 1768 1768 fn validate( 1769 1769 &self, 1770 1770 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1770 1770 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1771 1771 Ok(()) 1772 1772 } 1773 1773 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/performinggroup.rs

··· 1769 1769 } 1770 1770 fn validate( 1771 1771 &self, 1772 1772 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1772 1772 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1773 1773 Ok(()) 1774 1774 } 1775 1775 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/person.rs

··· 1534 1534 } 1535 1535 fn validate( 1536 1536 &self, 1537 1537 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1537 1537 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1538 1538 Ok(()) 1539 1539 } 1540 1540 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/physicalactivitycategory.rs

··· 295 295 } 296 296 fn validate( 297 297 &self, 298 298 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 298 298 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 299 299 Ok(()) 300 300 } 301 301 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/place.rs

··· 1069 1069 } 1070 1070 fn validate( 1071 1071 &self, 1072 1072 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1072 1072 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1073 1073 Ok(()) 1074 1074 } 1075 1075 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/product.rs

··· 1302 1302 } 1303 1303 fn validate( 1304 1304 &self, 1305 1305 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1305 1305 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1306 1306 Ok(()) 1307 1307 } 1308 1308 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/productgroup.rs

··· 1361 1361 } 1362 1362 fn validate( 1363 1363 &self, 1364 1364 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1364 1364 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1365 1365 Ok(()) 1366 1366 } 1367 1367 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/productmodel.rs

··· 1354 1354 } 1355 1355 fn validate( 1356 1356 &self, 1357 1357 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1357 1357 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1358 1358 Ok(()) 1359 1359 } 1360 1360 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/propertyvalue.rs

··· 408 408 } 409 409 fn validate( 410 410 &self, 411 411 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 411 411 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 412 412 Ok(()) 413 413 } 414 414 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/publicationevent.rs

··· 1126 1126 } 1127 1127 fn validate( 1128 1128 &self, 1129 1129 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1129 1129 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1130 1130 Ok(()) 1131 1131 } 1132 1132 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/quantitativevalue.rs

··· 372 372 } 373 373 fn validate( 374 374 &self, 375 375 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 375 375 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 376 376 Ok(()) 377 377 } 378 378 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/rating.rs

··· 324 324 } 325 325 fn validate( 326 326 &self, 327 327 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 327 327 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 328 328 Ok(()) 329 329 } 330 330 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/recipe.rs

··· 2688 2688 } 2689 2689 fn validate( 2690 2690 &self, 2691 2691 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2691 2691 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2692 2692 Ok(()) 2693 2693 } 2694 2694 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/restricteddiet.rs

··· 295 295 } 296 296 fn validate( 297 297 &self, 298 298 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 298 298 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 299 299 Ok(()) 300 300 } 301 301 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/review.rs

··· 2479 2479 } 2480 2480 fn validate( 2481 2481 &self, 2482 2482 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2482 2482 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2483 2483 Ok(()) 2484 2484 } 2485 2485 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/service.rs

··· 815 815 } 816 816 fn validate( 817 817 &self, 818 818 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 818 818 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 819 819 Ok(()) 820 820 } 821 821 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/sizespecification.rs

··· 629 629 } 630 630 fn validate( 631 631 &self, 632 632 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 632 632 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 633 633 Ok(()) 634 634 } 635 635 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/socialmediaposting.rs

··· 1211 1211 } 1212 1212 fn validate( 1213 1213 &self, 1214 1214 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1214 1214 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1215 1215 Ok(()) 1216 1216 } 1217 1217 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/speakablespecification.rs

··· 190 190 } 191 191 fn validate( 192 192 &self, 193 193 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 193 193 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 194 194 Ok(()) 195 195 } 196 196 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/textobject.rs

··· 2558 2558 } 2559 2559 fn validate( 2560 2560 &self, 2561 2561 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2561 2561 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2562 2562 Ok(()) 2563 2563 } 2564 2564 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/thing.rs

··· 273 273 } 274 274 fn validate( 275 275 &self, 276 276 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 276 276 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 277 277 Ok(()) 278 278 } 279 279 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/videoobject.rs

··· 2728 2728 } 2729 2729 fn validate( 2730 2730 &self, 2731 2731 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2731 2731 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2732 2732 Ok(()) 2733 2733 } 2734 2734 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/webcontent.rs

··· 2288 2288 } 2289 2289 fn validate( 2290 2290 &self, 2291 2291 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2291 2291 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2292 2292 Ok(()) 2293 2293 } 2294 2294 }

+1 -1

crates/jacquard-api/src/social_flockfeeds/lexical/webpage.rs

··· 2469 2469 } 2470 2470 fn validate( 2471 2471 &self, 2472 2472 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2472 2472 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 2473 2473 Ok(()) 2474 2474 } 2475 2475 }

+9 -5

crates/jacquard-api/src/social_grain.rs

··· 97 97 } 98 98 fn validate( 99 99 &self, 100 100 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 100 100 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 101 101 { 102 102 let value = &self.height; 103 103 if *value < 1i64 { 104 104 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 105 105 - field: "height", 104 104 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 105 105 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 106 106 + "height", 107 107 + ), 106 108 min: 1i64, 107 109 actual: *value, 108 110 }); ··· 111 113 { 112 114 let value = &self.width; 113 115 if *value < 1i64 { 114 114 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 115 115 - field: "width", 116 116 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 117 117 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 118 118 + "width", 119 119 + ), 116 120 min: 1i64, 117 121 actual: *value, 118 122 });

+17 -9

crates/jacquard-api/src/social_grain/actor.rs

··· 208 208 } 209 209 fn validate( 210 210 &self, 211 211 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 211 211 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 212 212 if let Some(ref value) = self.description { 213 213 #[allow(unused_comparisons)] 214 214 if <str>::len(value.as_ref()) > 2560usize { 215 215 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 216 216 - field: "description", 215 215 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 216 216 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 217 217 + "description", 218 218 + ), 217 219 max: 2560usize, 218 220 actual: <str>::len(value.as_ref()), 219 221 }); ··· 227 229 ) 228 230 .count(); 229 231 if count > 256usize { 230 230 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 231 231 - field: "description", 232 232 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 233 233 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 234 234 + "description", 235 235 + ), 232 236 max: 256usize, 233 237 actual: count, 234 238 }); ··· 238 242 if let Some(ref value) = self.display_name { 239 243 #[allow(unused_comparisons)] 240 244 if <str>::len(value.as_ref()) > 640usize { 241 241 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 242 242 - field: "display_name", 245 245 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 246 246 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 247 247 + "display_name", 248 248 + ), 243 249 max: 640usize, 244 250 actual: <str>::len(value.as_ref()), 245 251 }); ··· 253 259 ) 254 260 .count(); 255 261 if count > 64usize { 256 256 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 257 257 - field: "display_name", 262 262 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 263 263 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 264 264 + "display_name", 265 265 + ), 258 266 max: 64usize, 259 267 actual: count, 260 268 });

+17 -9

crates/jacquard-api/src/social_grain/actor/profile.rs

··· 111 111 } 112 112 fn validate( 113 113 &self, 114 114 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 114 114 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 115 115 if let Some(ref value) = self.description { 116 116 #[allow(unused_comparisons)] 117 117 if <str>::len(value.as_ref()) > 2560usize { 118 118 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 119 119 - field: "description", 118 118 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 119 119 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 120 120 + "description", 121 121 + ), 120 122 max: 2560usize, 121 123 actual: <str>::len(value.as_ref()), 122 124 }); ··· 130 132 ) 131 133 .count(); 132 134 if count > 256usize { 133 133 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 134 134 - field: "description", 135 135 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 136 136 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 137 137 + "description", 138 138 + ), 135 139 max: 256usize, 136 140 actual: count, 137 141 }); ··· 141 145 if let Some(ref value) = self.display_name { 142 146 #[allow(unused_comparisons)] 143 147 if <str>::len(value.as_ref()) > 640usize { 144 144 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 145 145 - field: "display_name", 148 148 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 149 149 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 150 150 + "display_name", 151 151 + ), 146 152 max: 640usize, 147 153 actual: <str>::len(value.as_ref()), 148 154 }); ··· 156 162 ) 157 163 .count(); 158 164 if count > 64usize { 159 159 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 160 160 - field: "display_name", 165 165 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 166 166 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 167 167 + "display_name", 168 168 + ), 161 169 max: 64usize, 162 170 actual: count, 163 171 });

+1 -1

crates/jacquard-api/src/social_grain/favorite.rs

··· 96 96 } 97 97 fn validate( 98 98 &self, 99 99 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 99 99 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 100 100 Ok(()) 101 101 } 102 102 }

+10 -6

crates/jacquard-api/src/social_grain/gallery.rs

··· 108 108 } 109 109 fn validate( 110 110 &self, 111 111 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 111 111 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 112 112 if let Some(ref value) = self.description { 113 113 #[allow(unused_comparisons)] 114 114 if <str>::len(value.as_ref()) > 1000usize { 115 115 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 116 116 - field: "description", 115 115 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 116 116 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 117 117 + "description", 118 118 + ), 117 119 max: 1000usize, 118 120 actual: <str>::len(value.as_ref()), 119 121 }); ··· 123 125 let value = &self.title; 124 126 #[allow(unused_comparisons)] 125 127 if <str>::len(value.as_ref()) > 100usize { 126 126 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 127 127 - field: "title", 128 128 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 129 129 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 130 130 + "title", 131 131 + ), 128 132 max: 100usize, 129 133 actual: <str>::len(value.as_ref()), 130 134 }); ··· 413 417 } 414 418 fn validate( 415 419 &self, 416 416 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 420 420 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 417 421 Ok(()) 418 422 } 419 423 }

+1 -1

crates/jacquard-api/src/social_grain/gallery/item.rs

··· 101 101 } 102 102 fn validate( 103 103 &self, 104 104 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 104 104 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 105 105 Ok(()) 106 106 } 107 107 }

+3 -3

crates/jacquard-api/src/social_grain/photo.rs

··· 108 108 } 109 109 fn validate( 110 110 &self, 111 111 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 111 111 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 112 112 Ok(()) 113 113 } 114 114 } ··· 675 675 } 676 676 fn validate( 677 677 &self, 678 678 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 678 678 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 679 679 Ok(()) 680 680 } 681 681 } ··· 730 730 } 731 731 fn validate( 732 732 &self, 733 733 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 733 733 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 734 734 Ok(()) 735 735 } 736 736 }

+1 -1

crates/jacquard-api/src/social_grain/photo/exif.rs

··· 132 132 } 133 133 fn validate( 134 134 &self, 135 135 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 135 135 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 136 136 Ok(()) 137 137 } 138 138 }

+5 -3

crates/jacquard-api/src/social_pmsky/proposal.rs

··· 137 137 } 138 138 fn validate( 139 139 &self, 140 140 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 140 140 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 141 141 { 142 142 let value = &self.val; 143 143 #[allow(unused_comparisons)] 144 144 if <str>::len(value.as_ref()) > 128usize { 145 145 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 146 146 - field: "val", 145 145 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 146 146 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 147 147 + "val", 148 148 + ), 147 149 max: 128usize, 148 150 actual: <str>::len(value.as_ref()), 149 151 });

+1 -1

crates/jacquard-api/src/social_pmsky/vote.rs

··· 122 122 } 123 123 fn validate( 124 124 &self, 125 125 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 125 125 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 126 126 Ok(()) 127 127 } 128 128 }

+9 -5

crates/jacquard-api/src/social_psky/actor/profile.rs

··· 98 98 } 99 99 fn validate( 100 100 &self, 101 101 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 101 101 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 102 102 if let Some(ref value) = self.nickname { 103 103 #[allow(unused_comparisons)] 104 104 if <str>::len(value.as_ref()) > 320usize { 105 105 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 106 106 - field: "nickname", 105 105 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 106 106 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 107 107 + "nickname", 108 108 + ), 107 109 max: 320usize, 108 110 actual: <str>::len(value.as_ref()), 109 111 }); ··· 117 119 ) 118 120 .count(); 119 121 if count > 32usize { 120 120 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 121 121 - field: "nickname", 122 122 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 123 123 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 124 124 + "nickname", 125 125 + ), 122 126 max: 32usize, 123 127 actual: count, 124 128 });

+9 -5

crates/jacquard-api/src/social_psky/chat/message.rs

··· 109 109 } 110 110 fn validate( 111 111 &self, 112 112 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 112 112 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 113 113 { 114 114 let value = &self.content; 115 115 #[allow(unused_comparisons)] 116 116 if <str>::len(value.as_ref()) > 20480usize { 117 117 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 118 118 - field: "content", 117 117 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 118 118 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 119 119 + "content", 120 120 + ), 119 121 max: 20480usize, 120 122 actual: <str>::len(value.as_ref()), 121 123 }); ··· 130 132 ) 131 133 .count(); 132 134 if count > 2048usize { 133 133 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 134 134 - field: "content", 135 135 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 136 136 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 137 137 + "content", 138 138 + ), 135 139 max: 2048usize, 136 140 actual: count, 137 141 });

+26 -14

crates/jacquard-api/src/social_psky/chat/room.rs

··· 119 119 } 120 120 fn validate( 121 121 &self, 122 122 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 122 122 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 123 123 if let Some(ref value) = self.languages { 124 124 #[allow(unused_comparisons)] 125 125 if value.len() > 3usize { 126 126 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 127 127 - field: "languages", 126 126 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 127 127 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 128 128 + "languages", 129 129 + ), 128 130 max: 3usize, 129 131 actual: value.len(), 130 132 }); ··· 134 136 let value = &self.name; 135 137 #[allow(unused_comparisons)] 136 138 if <str>::len(value.as_ref()) > 320usize { 137 137 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 138 138 - field: "name", 139 139 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 140 140 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 141 141 + "name", 142 142 + ), 139 143 max: 320usize, 140 144 actual: <str>::len(value.as_ref()), 141 145 }); ··· 150 154 ) 151 155 .count(); 152 156 if count > 32usize { 153 153 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 154 154 - field: "name", 157 157 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 158 158 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 159 159 + "name", 160 160 + ), 155 161 max: 32usize, 156 162 actual: count, 157 163 }); ··· 161 167 if let Some(ref value) = self.tags { 162 168 #[allow(unused_comparisons)] 163 169 if value.len() > 20usize { 164 164 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 165 165 - field: "tags", 170 170 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 171 171 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 172 172 + "tags", 173 173 + ), 166 174 max: 20usize, 167 175 actual: value.len(), 168 176 }); ··· 171 179 if let Some(ref value) = self.topic { 172 180 #[allow(unused_comparisons)] 173 181 if <str>::len(value.as_ref()) > 2560usize { 174 174 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 175 175 - field: "topic", 182 182 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 183 183 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 184 184 + "topic", 185 185 + ), 176 186 max: 2560usize, 177 187 actual: <str>::len(value.as_ref()), 178 188 }); ··· 186 196 ) 187 197 .count(); 188 198 if count > 256usize { 189 189 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 190 190 - field: "topic", 199 199 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 200 200 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 201 201 + "topic", 202 202 + ), 191 203 max: 256usize, 192 204 actual: count, 193 205 }); ··· 412 424 } 413 425 fn validate( 414 426 &self, 415 415 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 427 427 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 416 428 Ok(()) 417 429 } 418 430 }

+21 -13

crates/jacquard-api/src/social_psky/richtext/facet.rs

··· 248 248 } 249 249 fn validate( 250 250 &self, 251 251 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 251 251 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 252 252 { 253 253 let value = &self.byte_end; 254 254 if *value < 0i64 { 255 255 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 256 256 - field: "byte_end", 255 255 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 256 256 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 257 257 + "byte_end", 258 258 + ), 257 259 min: 0i64, 258 260 actual: *value, 259 261 }); ··· 262 264 { 263 265 let value = &self.byte_start; 264 266 if *value < 0i64 { 265 265 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 266 266 - field: "byte_start", 267 267 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 268 268 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 269 269 + "byte_start", 270 270 + ), 267 271 min: 0i64, 268 272 actual: *value, 269 273 }); ··· 303 307 } 304 308 fn validate( 305 309 &self, 306 306 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 310 310 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 307 311 Ok(()) 308 312 } 309 313 } ··· 361 365 } 362 366 fn validate( 363 367 &self, 364 364 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 368 368 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 365 369 Ok(()) 366 370 } 367 371 } ··· 396 400 } 397 401 fn validate( 398 402 &self, 399 399 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 403 403 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 400 404 Ok(()) 401 405 } 402 406 } ··· 431 435 } 432 436 fn validate( 433 437 &self, 434 434 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 438 438 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 435 439 { 436 440 let value = &self.room; 437 441 #[allow(unused_comparisons)] 438 442 if <str>::len(value.as_ref()) > 640usize { 439 439 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 440 440 - field: "room", 443 443 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 444 444 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 445 445 + "room", 446 446 + ), 441 447 max: 640usize, 442 448 actual: <str>::len(value.as_ref()), 443 449 }); ··· 452 458 ) 453 459 .count(); 454 460 if count > 64usize { 455 455 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 456 456 - field: "room", 461 461 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 462 462 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 463 463 + "room", 464 464 + ), 457 465 max: 64usize, 458 466 actual: count, 459 467 });

+1 -1

crates/jacquard-api/src/tools_ozone/communication.rs

··· 263 263 } 264 264 fn validate( 265 265 &self, 266 266 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 266 266 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 267 267 Ok(()) 268 268 } 269 269 }

+6 -6

crates/jacquard-api/src/tools_ozone/hosting/get_account_history.rs

··· 360 360 } 361 361 fn validate( 362 362 &self, 363 363 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 363 363 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 364 364 Ok(()) 365 365 } 366 366 } ··· 394 394 } 395 395 fn validate( 396 396 &self, 397 397 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 397 397 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 398 398 Ok(()) 399 399 } 400 400 } ··· 428 428 } 429 429 fn validate( 430 430 &self, 431 431 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 431 431 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 432 432 Ok(()) 433 433 } 434 434 } ··· 501 501 } 502 502 fn validate( 503 503 &self, 504 504 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 504 504 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 505 505 Ok(()) 506 506 } 507 507 } ··· 535 535 } 536 536 fn validate( 537 537 &self, 538 538 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 538 538 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 539 539 Ok(()) 540 540 } 541 541 } ··· 637 637 } 638 638 fn validate( 639 639 &self, 640 640 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 640 640 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 641 641 Ok(()) 642 642 } 643 643 }

+66 -56

crates/jacquard-api/src/tools_ozone/moderation.rs

··· 4328 4328 } 4329 4329 fn validate( 4330 4330 &self, 4331 4331 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4331 4331 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4332 4332 Ok(()) 4333 4333 } 4334 4334 } ··· 4372 4372 } 4373 4373 fn validate( 4374 4374 &self, 4375 4375 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4375 4375 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4376 4376 Ok(()) 4377 4377 } 4378 4378 } ··· 4420 4420 } 4421 4421 fn validate( 4422 4422 &self, 4423 4423 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4423 4423 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4424 4424 Ok(()) 4425 4425 } 4426 4426 } ··· 4483 4483 } 4484 4484 fn validate( 4485 4485 &self, 4486 4486 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4486 4486 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4487 4487 Ok(()) 4488 4488 } 4489 4489 } ··· 4522 4522 } 4523 4523 fn validate( 4524 4524 &self, 4525 4525 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4525 4525 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4526 4526 Ok(()) 4527 4527 } 4528 4528 } ··· 4588 4588 } 4589 4589 fn validate( 4590 4590 &self, 4591 4591 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4591 4591 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4592 4592 Ok(()) 4593 4593 } 4594 4594 } ··· 4624 4624 } 4625 4625 fn validate( 4626 4626 &self, 4627 4627 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4627 4627 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4628 4628 Ok(()) 4629 4629 } 4630 4630 } ··· 4673 4673 } 4674 4674 fn validate( 4675 4675 &self, 4676 4676 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4676 4676 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4677 4677 Ok(()) 4678 4678 } 4679 4679 } ··· 4707 4707 } 4708 4708 fn validate( 4709 4709 &self, 4710 4710 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4710 4710 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4711 4711 Ok(()) 4712 4712 } 4713 4713 } ··· 4745 4745 } 4746 4746 fn validate( 4747 4747 &self, 4748 4748 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4748 4748 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4749 4749 Ok(()) 4750 4750 } 4751 4751 } ··· 4784 4784 } 4785 4785 fn validate( 4786 4786 &self, 4787 4787 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4787 4787 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4788 4788 Ok(()) 4789 4789 } 4790 4790 } ··· 4820 4820 } 4821 4821 fn validate( 4822 4822 &self, 4823 4823 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4823 4823 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4824 4824 Ok(()) 4825 4825 } 4826 4826 } ··· 4864 4864 } 4865 4865 fn validate( 4866 4866 &self, 4867 4867 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4867 4867 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4868 4868 Ok(()) 4869 4869 } 4870 4870 } ··· 4899 4899 } 4900 4900 fn validate( 4901 4901 &self, 4902 4902 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4902 4902 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4903 4903 Ok(()) 4904 4904 } 4905 4905 } ··· 4944 4944 } 4945 4945 fn validate( 4946 4946 &self, 4947 4947 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4947 4947 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4948 4948 Ok(()) 4949 4949 } 4950 4950 } ··· 4983 4983 } 4984 4984 fn validate( 4985 4985 &self, 4986 4986 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4986 4986 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 4987 4987 Ok(()) 4988 4988 } 4989 4989 } ··· 5022 5022 } 5023 5023 fn validate( 5024 5024 &self, 5025 5025 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5025 5025 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5026 5026 Ok(()) 5027 5027 } 5028 5028 } ··· 5060 5060 } 5061 5061 fn validate( 5062 5062 &self, 5063 5063 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5063 5063 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5064 5064 { 5065 5065 let value = &self.score; 5066 5066 if *value > 100i64 { 5067 5067 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 5068 5068 - field: "score", 5067 5067 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 5068 5068 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 5069 5069 + "score", 5070 5070 + ), 5069 5071 max: 100i64, 5070 5072 actual: *value, 5071 5073 }); ··· 5074 5076 { 5075 5077 let value = &self.score; 5076 5078 if *value < 0i64 { 5077 5077 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 5078 5078 - field: "score", 5079 5079 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 5080 5080 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 5081 5081 + "score", 5082 5082 + ), 5079 5083 min: 0i64, 5080 5084 actual: *value, 5081 5085 }); ··· 5123 5127 } 5124 5128 fn validate( 5125 5129 &self, 5126 5126 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5130 5130 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5127 5131 Ok(()) 5128 5132 } 5129 5133 } ··· 5160 5164 } 5161 5165 fn validate( 5162 5166 &self, 5163 5163 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5167 5167 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5164 5168 Ok(()) 5165 5169 } 5166 5170 } ··· 5197 5201 } 5198 5202 fn validate( 5199 5203 &self, 5200 5200 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5204 5204 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5201 5205 Ok(()) 5202 5206 } 5203 5207 } ··· 5241 5245 } 5242 5246 fn validate( 5243 5247 &self, 5244 5244 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5248 5248 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5245 5249 Ok(()) 5246 5250 } 5247 5251 } ··· 5287 5291 } 5288 5292 fn validate( 5289 5293 &self, 5290 5290 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5294 5294 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5291 5295 if let Some(ref value) = self.policies { 5292 5296 #[allow(unused_comparisons)] 5293 5297 if value.len() > 5usize { 5294 5294 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 5295 5295 - field: "policies", 5298 5298 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 5299 5299 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 5300 5300 + "policies", 5301 5301 + ), 5296 5302 max: 5usize, 5297 5303 actual: value.len(), 5298 5304 }); ··· 5334 5340 } 5335 5341 fn validate( 5336 5342 &self, 5337 5337 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5343 5343 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5338 5344 Ok(()) 5339 5345 } 5340 5346 } ··· 5371 5377 } 5372 5378 fn validate( 5373 5379 &self, 5374 5374 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5380 5380 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5375 5381 Ok(()) 5376 5382 } 5377 5383 } ··· 5525 5531 } 5526 5532 fn validate( 5527 5533 &self, 5528 5528 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5534 5534 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5529 5535 Ok(()) 5530 5536 } 5531 5537 } ··· 5673 5679 } 5674 5680 fn validate( 5675 5681 &self, 5676 5676 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5682 5682 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5677 5683 Ok(()) 5678 5684 } 5679 5685 } ··· 5713 5719 } 5714 5720 fn validate( 5715 5721 &self, 5716 5716 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5722 5722 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5717 5723 Ok(()) 5718 5724 } 5719 5725 } ··· 5750 5756 } 5751 5757 fn validate( 5752 5758 &self, 5753 5753 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5759 5759 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5754 5760 Ok(()) 5755 5761 } 5756 5762 } ··· 5787 5793 } 5788 5794 fn validate( 5789 5795 &self, 5790 5790 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5796 5796 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5791 5797 Ok(()) 5792 5798 } 5793 5799 } ··· 5832 5838 } 5833 5839 fn validate( 5834 5840 &self, 5835 5835 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5841 5841 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5836 5842 Ok(()) 5837 5843 } 5838 5844 } ··· 5872 5878 } 5873 5879 fn validate( 5874 5880 &self, 5875 5875 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5881 5881 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5876 5882 Ok(()) 5877 5883 } 5878 5884 } ··· 5917 5923 } 5918 5924 fn validate( 5919 5925 &self, 5920 5920 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5926 5926 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5921 5927 Ok(()) 5922 5928 } 5923 5929 } ··· 5966 5972 } 5967 5973 fn validate( 5968 5974 &self, 5969 5969 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5975 5975 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 5970 5976 Ok(()) 5971 5977 } 5972 5978 } ··· 6000 6006 } 6001 6007 fn validate( 6002 6008 &self, 6003 6003 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 6009 6009 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 6004 6010 Ok(()) 6005 6011 } 6006 6012 } ··· 6057 6063 } 6058 6064 fn validate( 6059 6065 &self, 6060 6060 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 6066 6066 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 6061 6067 Ok(()) 6062 6068 } 6063 6069 } ··· 6120 6126 } 6121 6127 fn validate( 6122 6128 &self, 6123 6123 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 6129 6129 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 6124 6130 Ok(()) 6125 6131 } 6126 6132 } ··· 6194 6200 } 6195 6201 fn validate( 6196 6202 &self, 6197 6197 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 6203 6203 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 6198 6204 Ok(()) 6199 6205 } 6200 6206 } ··· 6228 6234 } 6229 6235 fn validate( 6230 6236 &self, 6231 6231 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 6237 6237 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 6232 6238 Ok(()) 6233 6239 } 6234 6240 } ··· 6278 6284 } 6279 6285 fn validate( 6280 6286 &self, 6281 6281 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 6287 6287 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 6282 6288 Ok(()) 6283 6289 } 6284 6290 } ··· 6387 6393 } 6388 6394 fn validate( 6389 6395 &self, 6390 6390 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 6396 6396 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 6391 6397 Ok(()) 6392 6398 } 6393 6399 } ··· 6429 6435 } 6430 6436 fn validate( 6431 6437 &self, 6432 6432 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 6438 6438 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 6433 6439 Ok(()) 6434 6440 } 6435 6441 } ··· 6518 6524 } 6519 6525 fn validate( 6520 6526 &self, 6521 6521 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 6527 6527 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 6522 6528 Ok(()) 6523 6529 } 6524 6530 } ··· 6760 6766 } 6761 6767 fn validate( 6762 6768 &self, 6763 6763 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 6769 6769 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 6764 6770 if let Some(ref value) = self.priority_score { 6765 6771 if *value > 100i64 { 6766 6766 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 6767 6767 - field: "priority_score", 6772 6772 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 6773 6773 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 6774 6774 + "priority_score", 6775 6775 + ), 6768 6776 max: 100i64, 6769 6777 actual: *value, 6770 6778 }); ··· 6772 6780 } 6773 6781 if let Some(ref value) = self.priority_score { 6774 6782 if *value < 0i64 { 6775 6775 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 6776 6776 - field: "priority_score", 6783 6783 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 6784 6784 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 6785 6785 + "priority_score", 6786 6786 + ), 6777 6787 min: 0i64, 6778 6788 actual: *value, 6779 6789 }); ··· 6832 6842 } 6833 6843 fn validate( 6834 6844 &self, 6835 6835 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 6845 6845 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 6836 6846 Ok(()) 6837 6847 } 6838 6848 } ··· 6921 6931 } 6922 6932 fn validate( 6923 6933 &self, 6924 6924 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 6934 6934 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 6925 6935 Ok(()) 6926 6936 } 6927 6937 }

+2 -2

crates/jacquard-api/src/tools_ozone/moderation/cancel_scheduled_actions.rs

··· 266 266 } 267 267 fn validate( 268 268 &self, 269 269 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 269 269 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 270 270 Ok(()) 271 271 } 272 272 } ··· 307 307 } 308 308 fn validate( 309 309 &self, 310 310 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 310 310 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 311 311 Ok(()) 312 312 } 313 313 }

+2 -2

crates/jacquard-api/src/tools_ozone/moderation/get_account_timeline.rs

··· 300 300 } 301 301 fn validate( 302 302 &self, 303 303 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 303 303 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 304 304 Ok(()) 305 305 } 306 306 } ··· 339 339 } 340 340 fn validate( 341 341 &self, 342 342 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 342 342 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 343 343 Ok(()) 344 344 } 345 345 }

+8 -6

crates/jacquard-api/src/tools_ozone/moderation/schedule_action.rs

··· 459 459 } 460 460 fn validate( 461 461 &self, 462 462 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 462 462 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 463 463 Ok(()) 464 464 } 465 465 } ··· 581 581 } 582 582 fn validate( 583 583 &self, 584 584 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 584 584 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 585 585 Ok(()) 586 586 } 587 587 } ··· 623 623 } 624 624 fn validate( 625 625 &self, 626 626 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 626 626 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 627 627 Ok(()) 628 628 } 629 629 } ··· 669 669 } 670 670 fn validate( 671 671 &self, 672 672 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 672 672 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 673 673 if let Some(ref value) = self.policies { 674 674 #[allow(unused_comparisons)] 675 675 if value.len() > 5usize { 676 676 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 677 677 - field: "policies", 676 676 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 677 677 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 678 678 + "policies", 679 679 + ), 678 680 max: 5usize, 679 681 actual: value.len(), 680 682 });

+2 -2

crates/jacquard-api/src/tools_ozone/safelink.rs

··· 522 522 } 523 523 fn validate( 524 524 &self, 525 525 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 525 525 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 526 526 Ok(()) 527 527 } 528 528 } ··· 820 820 } 821 821 fn validate( 822 822 &self, 823 823 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 823 823 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 824 824 Ok(()) 825 825 } 826 826 }

+2 -2

crates/jacquard-api/src/tools_ozone/server/get_config.rs

··· 189 189 } 190 190 fn validate( 191 191 &self, 192 192 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 192 192 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 193 193 Ok(()) 194 194 } 195 195 } ··· 224 224 } 225 225 fn validate( 226 226 &self, 227 227 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 227 227 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 228 228 Ok(()) 229 229 } 230 230 }

+34 -18

crates/jacquard-api/src/tools_ozone/set.rs

··· 207 207 } 208 208 fn validate( 209 209 &self, 210 210 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 210 210 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 211 211 if let Some(ref value) = self.description { 212 212 #[allow(unused_comparisons)] 213 213 if <str>::len(value.as_ref()) > 10240usize { 214 214 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 215 215 - field: "description", 214 214 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 215 215 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 216 216 + "description", 217 217 + ), 216 218 max: 10240usize, 217 219 actual: <str>::len(value.as_ref()), 218 220 }); ··· 226 228 ) 227 229 .count(); 228 230 if count > 1024usize { 229 229 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 230 230 - field: "description", 231 231 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 232 232 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 233 233 + "description", 234 234 + ), 231 235 max: 1024usize, 232 236 actual: count, 233 237 }); ··· 238 242 let value = &self.name; 239 243 #[allow(unused_comparisons)] 240 244 if <str>::len(value.as_ref()) > 128usize { 241 241 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 242 242 - field: "name", 245 245 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 246 246 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 247 247 + "name", 248 248 + ), 243 249 max: 128usize, 244 250 actual: <str>::len(value.as_ref()), 245 251 }); ··· 249 255 let value = &self.name; 250 256 #[allow(unused_comparisons)] 251 257 if <str>::len(value.as_ref()) < 3usize { 252 252 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 253 253 - field: "name", 258 258 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 259 259 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 260 260 + "name", 261 261 + ), 254 262 min: 3usize, 255 263 actual: <str>::len(value.as_ref()), 256 264 }); ··· 297 305 } 298 306 fn validate( 299 307 &self, 300 300 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 308 308 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 301 309 if let Some(ref value) = self.description { 302 310 #[allow(unused_comparisons)] 303 311 if <str>::len(value.as_ref()) > 10240usize { 304 304 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 305 305 - field: "description", 312 312 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 313 313 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 314 314 + "description", 315 315 + ), 306 316 max: 10240usize, 307 317 actual: <str>::len(value.as_ref()), 308 318 }); ··· 316 326 ) 317 327 .count(); 318 328 if count > 1024usize { 319 319 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 320 320 - field: "description", 329 329 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 330 330 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 331 331 + "description", 332 332 + ), 321 333 max: 1024usize, 322 334 actual: count, 323 335 }); ··· 328 340 let value = &self.name; 329 341 #[allow(unused_comparisons)] 330 342 if <str>::len(value.as_ref()) > 128usize { 331 331 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 332 332 - field: "name", 343 343 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 344 344 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 345 345 + "name", 346 346 + ), 333 347 max: 128usize, 334 348 actual: <str>::len(value.as_ref()), 335 349 }); ··· 339 353 let value = &self.name; 340 354 #[allow(unused_comparisons)] 341 355 if <str>::len(value.as_ref()) < 3usize { 342 342 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 343 343 - field: "name", 356 356 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 357 357 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 358 358 + "name", 359 359 + ), 344 360 min: 3usize, 345 361 actual: <str>::len(value.as_ref()), 346 362 });

+9 -5

crates/jacquard-api/src/tools_ozone/setting.rs

··· 265 265 } 266 266 fn validate( 267 267 &self, 268 268 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 268 268 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 269 269 if let Some(ref value) = self.description { 270 270 #[allow(unused_comparisons)] 271 271 if <str>::len(value.as_ref()) > 10240usize { 272 272 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 273 273 - field: "description", 272 272 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 273 273 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 274 274 + "description", 275 275 + ), 274 276 max: 10240usize, 275 277 actual: <str>::len(value.as_ref()), 276 278 }); ··· 284 286 ) 285 287 .count(); 286 288 if count > 1024usize { 287 287 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 288 288 - field: "description", 289 289 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 290 290 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 291 291 + "description", 292 292 + ), 289 293 max: 1024usize, 290 294 actual: count, 291 295 });

+1 -1

crates/jacquard-api/src/tools_ozone/signature.rs

··· 103 103 } 104 104 fn validate( 105 105 &self, 106 106 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 106 106 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 107 107 Ok(()) 108 108 } 109 109 }

+1 -1

crates/jacquard-api/src/tools_ozone/signature/find_related_accounts.rs

··· 230 230 } 231 231 fn validate( 232 232 &self, 233 233 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 233 233 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 234 234 Ok(()) 235 235 } 236 236 }

+1 -1

crates/jacquard-api/src/tools_ozone/team.rs

··· 220 220 } 221 221 fn validate( 222 222 &self, 223 223 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 223 223 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 224 224 Ok(()) 225 225 } 226 226 }

+1 -1

crates/jacquard-api/src/tools_ozone/verification.rs

··· 405 405 } 406 406 fn validate( 407 407 &self, 408 408 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 408 408 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 409 409 Ok(()) 410 410 } 411 411 }

+2 -2

crates/jacquard-api/src/tools_ozone/verification/grant_verifications.rs

··· 275 275 } 276 276 fn validate( 277 277 &self, 278 278 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 278 278 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 279 279 Ok(()) 280 280 } 281 281 } ··· 395 395 } 396 396 fn validate( 397 397 &self, 398 398 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 398 398 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 399 399 Ok(()) 400 400 } 401 401 }

+1 -1

crates/jacquard-api/src/tools_ozone/verification/revoke_verifications.rs

··· 282 282 } 283 283 fn validate( 284 284 &self, 285 285 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 285 285 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 286 286 Ok(()) 287 287 } 288 288 }

+14 -8

crates/jacquard-api/src/tools_smokesignal/blahg/content/post.rs

··· 199 199 } 200 200 fn validate( 201 201 &self, 202 202 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 202 202 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 203 203 Ok(()) 204 204 } 205 205 } ··· 315 315 } 316 316 fn validate( 317 317 &self, 318 318 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 318 318 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 319 319 if let Some(ref value) = self.langs { 320 320 #[allow(unused_comparisons)] 321 321 if value.len() > 3usize { 322 322 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 323 323 - field: "langs", 322 322 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 323 323 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 324 324 + "langs", 325 325 + ), 324 326 max: 3usize, 325 327 actual: value.len(), 326 328 }); ··· 329 331 if let Some(ref value) = self.title { 330 332 #[allow(unused_comparisons)] 331 333 if <str>::len(value.as_ref()) > 2000usize { 332 332 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 333 333 - field: "title", 334 334 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 335 335 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 336 336 + "title", 337 337 + ), 334 338 max: 2000usize, 335 339 actual: <str>::len(value.as_ref()), 336 340 }); ··· 344 348 ) 345 349 .count(); 346 350 if count > 200usize { 347 347 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 348 348 - field: "title", 351 351 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 352 352 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 353 353 + "title", 354 354 + ), 349 355 max: 200usize, 350 356 actual: count, 351 357 });

+9 -5

crates/jacquard-api/src/uk_ewancroft/now.rs

··· 99 99 } 100 100 fn validate( 101 101 &self, 102 102 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 102 102 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 103 103 { 104 104 let value = &self.text; 105 105 #[allow(unused_comparisons)] 106 106 if <str>::len(value.as_ref()) > 64usize { 107 107 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 108 108 - field: "text", 107 107 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 108 108 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 109 109 + "text", 110 110 + ), 109 111 max: 64usize, 110 112 actual: <str>::len(value.as_ref()), 111 113 }); ··· 115 117 let value = &self.text; 116 118 #[allow(unused_comparisons)] 117 119 if <str>::len(value.as_ref()) < 1usize { 118 118 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 119 119 - field: "text", 120 120 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 121 121 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 122 122 + "text", 123 123 + ), 120 124 min: 1usize, 121 125 actual: <str>::len(value.as_ref()), 122 126 });

+25 -13

crates/jacquard-api/src/uk_skyblur/post.rs

··· 120 120 } 121 121 fn validate( 122 122 &self, 123 123 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 123 123 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 124 124 if let Some(ref value) = self.additional { 125 125 #[allow(unused_comparisons)] 126 126 if <str>::len(value.as_ref()) > 100000usize { 127 127 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 128 128 - field: "additional", 127 127 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 128 128 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 129 129 + "additional", 130 130 + ), 129 131 max: 100000usize, 130 132 actual: <str>::len(value.as_ref()), 131 133 }); ··· 139 141 ) 140 142 .count(); 141 143 if count > 10000usize { 142 142 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 143 143 - field: "additional", 144 144 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 145 145 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 146 146 + "additional", 147 147 + ), 144 148 max: 10000usize, 145 149 actual: count, 146 150 }); ··· 151 155 let value = &self.text; 152 156 #[allow(unused_comparisons)] 153 157 if <str>::len(value.as_ref()) > 3000usize { 154 154 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 155 155 - field: "text", 158 158 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 159 159 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 160 160 + "text", 161 161 + ), 156 162 max: 3000usize, 157 163 actual: <str>::len(value.as_ref()), 158 164 }); ··· 167 173 ) 168 174 .count(); 169 175 if count > 300usize { 170 170 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 171 171 - field: "text", 176 176 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 177 177 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 178 178 + "text", 179 179 + ), 172 180 max: 300usize, 173 181 actual: count, 174 182 }); ··· 179 187 let value = &self.visibility; 180 188 #[allow(unused_comparisons)] 181 189 if <str>::len(value.as_ref()) > 100usize { 182 182 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 183 183 - field: "visibility", 190 190 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 191 191 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 192 192 + "visibility", 193 193 + ), 184 194 max: 100usize, 185 195 actual: <str>::len(value.as_ref()), 186 196 }); ··· 195 205 ) 196 206 .count(); 197 207 if count > 10usize { 198 198 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 199 199 - field: "visibility", 208 208 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 209 209 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 210 210 + "visibility", 211 211 + ), 200 212 max: 10usize, 201 213 actual: count, 202 214 });

+10 -6

crates/jacquard-api/src/uk_skyblur/preference.rs

··· 96 96 } 97 97 fn validate( 98 98 &self, 99 99 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 99 99 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 100 100 Ok(()) 101 101 } 102 102 } ··· 233 233 } 234 234 fn validate( 235 235 &self, 236 236 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 236 236 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 237 237 if let Some(ref value) = self.description { 238 238 #[allow(unused_comparisons)] 239 239 if <str>::len(value.as_ref()) > 10000usize { 240 240 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 241 241 - field: "description", 240 240 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 241 241 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 242 242 + "description", 243 243 + ), 242 244 max: 10000usize, 243 245 actual: <str>::len(value.as_ref()), 244 246 }); ··· 252 254 ) 253 255 .count(); 254 256 if count > 100000usize { 255 255 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 256 256 - field: "description", 257 257 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 258 258 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 259 259 + "description", 260 260 + ), 257 261 max: 100000usize, 258 262 actual: count, 259 263 });

+9 -5

crates/jacquard-api/src/us_polhem/blog.rs

··· 98 98 } 99 99 fn validate( 100 100 &self, 101 101 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 101 101 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 102 102 { 103 103 let value = &self.height; 104 104 if *value < 1i64 { 105 105 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 106 106 - field: "height", 105 105 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 106 106 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 107 107 + "height", 108 108 + ), 107 109 min: 1i64, 108 110 actual: *value, 109 111 }); ··· 112 114 { 113 115 let value = &self.width; 114 116 if *value < 1i64 { 115 115 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 116 116 - field: "width", 117 117 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 118 118 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 119 119 + "width", 120 120 + ), 117 121 min: 1i64, 118 122 actual: *value, 119 123 });

+9 -5

crates/jacquard-api/src/us_polhem/blog/content.rs

··· 105 105 } 106 106 fn validate( 107 107 &self, 108 108 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 108 108 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 109 109 { 110 110 let value = &self.content; 111 111 #[allow(unused_comparisons)] 112 112 if <str>::len(value.as_ref()) > 100000usize { 113 113 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 114 114 - field: "content", 113 113 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 114 114 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 115 115 + "content", 116 116 + ), 115 117 max: 100000usize, 116 118 actual: <str>::len(value.as_ref()), 117 119 }); ··· 121 123 let value = &self.slug; 122 124 #[allow(unused_comparisons)] 123 125 if <str>::len(value.as_ref()) > 100usize { 124 124 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 125 125 - field: "slug", 126 126 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 127 127 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 128 128 + "slug", 129 129 + ), 126 130 max: 100usize, 127 131 actual: <str>::len(value.as_ref()), 128 132 });

+17 -9

crates/jacquard-api/src/us_polhem/blog/post.rs

··· 125 125 } 126 126 fn validate( 127 127 &self, 128 128 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 128 128 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 129 129 { 130 130 let value = &self.content; 131 131 #[allow(unused_comparisons)] 132 132 if <str>::len(value.as_ref()) > 100000usize { 133 133 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 134 134 - field: "content", 133 133 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 134 134 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 135 135 + "content", 136 136 + ), 135 137 max: 100000usize, 136 138 actual: <str>::len(value.as_ref()), 137 139 }); ··· 140 142 if let Some(ref value) = self.excerpt { 141 143 #[allow(unused_comparisons)] 142 144 if <str>::len(value.as_ref()) > 1000usize { 143 143 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 144 144 - field: "excerpt", 145 145 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 146 146 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 147 147 + "excerpt", 148 148 + ), 145 149 max: 1000usize, 146 150 actual: <str>::len(value.as_ref()), 147 151 }); ··· 151 155 let value = &self.slug; 152 156 #[allow(unused_comparisons)] 153 157 if <str>::len(value.as_ref()) > 100usize { 154 154 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 155 155 - field: "slug", 158 158 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 159 159 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 160 160 + "slug", 161 161 + ), 156 162 max: 100usize, 157 163 actual: <str>::len(value.as_ref()), 158 164 }); ··· 162 168 let value = &self.title; 163 169 #[allow(unused_comparisons)] 164 170 if <str>::len(value.as_ref()) > 1000usize { 165 165 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 166 166 - field: "title", 171 171 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 172 172 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 173 173 + "title", 174 174 + ), 167 175 max: 1000usize, 168 176 actual: <str>::len(value.as_ref()), 169 177 });

+13 -7

crates/jacquard-api/src/us_polhem/blog/tag.rs

··· 104 104 } 105 105 fn validate( 106 106 &self, 107 107 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 107 107 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 108 108 { 109 109 let value = &self.description; 110 110 #[allow(unused_comparisons)] 111 111 if <str>::len(value.as_ref()) > 100000usize { 112 112 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 113 113 - field: "description", 112 112 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 113 113 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 114 114 + "description", 115 115 + ), 114 116 max: 100000usize, 115 117 actual: <str>::len(value.as_ref()), 116 118 }); ··· 120 122 let value = &self.name; 121 123 #[allow(unused_comparisons)] 122 124 if <str>::len(value.as_ref()) > 100usize { 123 123 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 124 124 - field: "name", 125 125 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 126 126 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 127 127 + "name", 128 128 + ), 125 129 max: 100usize, 126 130 actual: <str>::len(value.as_ref()), 127 131 }); ··· 131 135 let value = &self.slug; 132 136 #[allow(unused_comparisons)] 133 137 if <str>::len(value.as_ref()) > 100usize { 134 134 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 135 135 - field: "slug", 138 138 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 139 139 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 140 140 + "slug", 141 141 + ), 136 142 max: 100usize, 137 143 actual: <str>::len(value.as_ref()), 138 144 });

+10 -6

crates/jacquard-api/src/win_tomo_x/pushat.rs

··· 225 225 } 226 226 fn validate( 227 227 &self, 228 228 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 228 228 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 229 229 { 230 230 let value = &self.name; 231 231 #[allow(unused_comparisons)] 232 232 if <str>::len(value.as_ref()) > 300usize { 233 233 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 234 234 - field: "name", 233 233 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 234 234 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 235 235 + "name", 236 236 + ), 235 237 max: 300usize, 236 238 actual: <str>::len(value.as_ref()), 237 239 }); ··· 246 248 ) 247 249 .count(); 248 250 if count > 30usize { 249 249 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 250 250 - field: "name", 251 251 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 252 252 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 253 253 + "name", 254 254 + ), 251 255 max: 30usize, 252 256 actual: count, 253 257 }); ··· 299 303 } 300 304 fn validate( 301 305 &self, 302 302 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 306 306 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 303 307 Ok(()) 304 308 } 305 309 }

+1 -1

crates/jacquard-api/src/win_tomo_x/pushat/allow.rs

··· 99 99 } 100 100 fn validate( 101 101 &self, 102 102 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 102 102 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 103 103 Ok(()) 104 104 } 105 105 }

+3 -1

crates/jacquard-lexicon/src/codegen.rs

··· 4 4 use proc_macro2::TokenStream; 5 5 use quote::quote; 6 6 7 7 + pub mod builder_heuristics; 7 8 pub mod lifetime; 8 9 pub mod names; 9 10 pub mod nsid_utils; ··· 11 12 pub mod schema_impl; 12 13 pub mod structs; 13 14 pub mod types; 15 15 + pub mod union_codegen; 14 16 pub mod utils; 15 17 pub mod xrpc; 16 18 ··· 100 102 #shared_fn_ident() 101 103 } 102 104 103 103 - fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 105 105 + fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 104 106 #validation_code 105 107 } 106 108 }

+76

crates/jacquard-lexicon/src/codegen/builder_heuristics.rs

··· 1 1 + use crate::lexicon::{LexObject, LexObjectProperty}; 2 2 + 3 3 + /// Decision about whether to generate builder and/or Default impl for a struct. 4 4 + #[derive(Debug, Clone, Copy)] 5 5 + pub struct BuilderDecision { 6 6 + /// Whether to generate a bon::Builder derive 7 7 + pub has_builder: bool, 8 8 + /// Whether to generate a Default derive 9 9 + pub has_default: bool, 10 10 + } 11 11 + 12 12 + /// Determine whether a struct should have builder and/or Default based on heuristics. 13 13 + /// 14 14 + /// Rules: 15 15 + /// - 0 required fields → Default (no builder) 16 16 + /// - All required fields are bare strings → Default (no builder) 17 17 + /// - 1+ required fields (not all strings) → Builder (no Default) 18 18 + /// - Type name conflicts with bon::Builder → no builder regardless 19 19 + /// 20 20 + /// # Parameters 21 21 + /// - `type_name`: Name of the generated struct (to check for conflicts) 22 22 + /// - `obj`: Lexicon object schema 23 23 + /// 24 24 + /// # Returns 25 25 + /// Decision about builder and Default generation 26 26 + pub fn should_generate_builder(type_name: &str, obj: &LexObject<'static>) -> BuilderDecision { 27 27 + let required_count = count_required_fields(obj); 28 28 + let has_default = required_count == 0 || all_required_are_defaultable_strings(obj); 29 29 + let has_builder = 30 30 + required_count >= 1 && !has_default && !conflicts_with_builder_macro(type_name); 31 31 + 32 32 + BuilderDecision { 33 33 + has_builder, 34 34 + has_default, 35 35 + } 36 36 + } 37 37 + 38 38 + /// Check if a type name conflicts with types referenced by bon::Builder macro. 39 39 + /// bon::Builder generates code that uses unqualified `Option` and `Result`, 40 40 + /// so structs with these names cause compilation errors. 41 41 + /// 42 42 + /// This is public for cases where a struct always wants a builder (like records) 43 43 + /// but needs to check for conflicts. 44 44 + pub fn conflicts_with_builder_macro(type_name: &str) -> bool { 45 45 + matches!(type_name, "Option" | "Result") 46 46 + } 47 47 + 48 48 + /// Count the number of required fields in a lexicon object. 49 49 + /// Used to determine whether to generate builders or Default impls. 50 50 + fn count_required_fields(obj: &LexObject<'static>) -> usize { 51 51 + let required = obj.required.as_ref().map(|r| r.as_slice()).unwrap_or(&[]); 52 52 + required.len() 53 53 + } 54 54 + 55 55 + /// Check if a field property is a plain string that can default to empty. 56 56 + /// Returns true for bare CowStr fields (no format constraints). 57 57 + fn is_defaultable_string(prop: &LexObjectProperty<'static>) -> bool { 58 58 + matches!(prop, LexObjectProperty::String(s) if s.format.is_none()) 59 59 + } 60 60 + 61 61 + /// Check if all required fields in an object are defaultable strings. 62 62 + fn all_required_are_defaultable_strings(obj: &LexObject<'static>) -> bool { 63 63 + let required = obj.required.as_ref().map(|r| r.as_slice()).unwrap_or(&[]); 64 64 + 65 65 + if required.is_empty() { 66 66 + return false; // Handled separately by count check 67 67 + } 68 68 + 69 69 + required.iter().all(|field_name| { 70 70 + let field_name_str: &str = field_name.as_ref(); 71 71 + obj.properties 72 72 + .get(field_name_str) 73 73 + .map(is_defaultable_string) 74 74 + .unwrap_or(false) 75 75 + }) 76 76 + }

-5

crates/jacquard-lexicon/src/codegen/lifetime.rs

··· 132 132 } 133 133 } 134 134 135 135 - /// Check if a lexicon def needs a lifetime parameter 136 136 - pub(super) fn def_needs_lifetime(&self, def: &LexUserType<'_>) -> bool { 137 137 - def.needs_lifetime(self) 138 138 - } 139 139 - 140 135 /// Check if xrpc params need a lifetime parameter 141 136 pub(super) fn params_need_lifetime( 142 137 &self,

+7 -7

crates/jacquard-lexicon/src/codegen/names.rs

··· 1 1 use super::nsid_utils::NsidPath; 2 2 - use super::utils::sanitize_name; 2 2 + use super::utils::{namespace_prefix, sanitize_name, sanitize_name_cow}; 3 3 use super::CodeGenerator; 4 4 use heck::{ToPascalCase, ToSnakeCase}; 5 5 ··· 140 140 141 141 if nsid_path.is_defs() && parts.len() >= 3 { 142 142 // defs go in parent module: com.atproto.label.defs → com_atproto/label.rs 143 143 - let first_two = format!("{}_{}", sanitize_name(parts[0]), sanitize_name(parts[1])); 143 143 + let first_two = namespace_prefix(parts[0], parts[1]); 144 144 if parts.len() == 3 { 145 145 // com.atproto.defs → com_atproto.rs 146 146 format!("{}.rs", first_two).into() ··· 149 149 let middle: Vec<&str> = parts[2..parts.len() - 1].iter().copied().collect(); 150 150 let mut path = std::path::PathBuf::from(first_two); 151 151 for segment in &middle[..middle.len() - 1] { 152 152 - path.push(sanitize_name(segment)); 152 152 + path.push(sanitize_name_cow(segment).as_ref()); 153 153 } 154 154 - path.push(format!("{}.rs", sanitize_name(middle.last().unwrap()))); 154 154 + path.push(format!("{}.rs", sanitize_name_cow(middle.last().unwrap()))); 155 155 path 156 156 } 157 157 } else { 158 158 // Regular path: app.bsky.feed.post → app_bsky/feed/post.rs 159 159 - let first_two = format!("{}_{}", sanitize_name(parts[0]), sanitize_name(parts[1])); 159 159 + let first_two = namespace_prefix(parts[0], parts[1]); 160 160 let mut path = std::path::PathBuf::from(first_two); 161 161 162 162 for segment in &parts[2..parts.len() - 1] { 163 163 - path.push(sanitize_name(segment)); 163 163 + path.push(sanitize_name_cow(segment).as_ref()); 164 164 } 165 165 166 166 - path.push(format!("{}.rs", sanitize_name(&last.to_snake_case()))); 166 166 + path.push(format!("{}.rs", sanitize_name_cow(&last.to_snake_case()))); 167 167 path 168 168 } 169 169 }

+1 -1

crates/jacquard-lexicon/src/codegen/schema_impl.rs

··· 54 54 #doc_literal 55 55 } 56 56 57 57 - fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 57 57 + fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 58 58 #validation_code 59 59 } 60 60 }

+86 -244

crates/jacquard-lexicon/src/codegen/structs.rs

··· 2 2 use crate::lexicon::{ 3 3 LexArrayItem, LexInteger, LexObject, LexObjectProperty, LexRecord, LexString, 4 4 }; 5 5 - use heck::{ToPascalCase, ToSnakeCase}; 5 5 + use heck::ToSnakeCase; 6 6 + use jacquard_common::smol_str::SmolStr; 6 7 use proc_macro2::TokenStream; 7 8 use quote::quote; 9 9 + use std::collections::BTreeMap; 8 10 9 9 - use super::nsid_utils::{NsidPath, RefPath}; 10 11 use super::CodeGenerator; 11 12 use super::utils::{make_ident, value_to_variant_name}; 12 13 ··· 19 20 Struct(Vec<String>), 20 21 } 21 22 22 22 - /// Check if a type name conflicts with types referenced by bon::Builder macro. 23 23 - /// bon::Builder generates code that uses unqualified `Option` and `Result`, 24 24 - /// so structs with these names cause compilation errors. 25 25 - pub(crate) fn conflicts_with_builder_macro(type_name: &str) -> bool { 26 26 - matches!(type_name, "Option" | "Result") 27 27 - } 23 23 + impl<'c> CodeGenerator<'c> { 24 24 + /// Generate all nested type definitions (unions, objects) for an object's properties. 25 25 + /// This consolidates the pattern of iterating properties to find unions and nested objects 26 26 + /// that need their own type definitions. 27 27 + /// 28 28 + /// # Parameters 29 29 + /// - `include_nested_objects`: If false, skips generating nested object types (used by XRPC) 30 30 + pub(super) fn generate_nested_types( 31 31 + &self, 32 32 + nsid: &str, 33 33 + parent_type_name: &str, 34 34 + properties: &BTreeMap<SmolStr, LexObjectProperty<'static>>, 35 35 + include_nested_objects: bool, 36 36 + ) -> Result<Vec<TokenStream>> { 37 37 + let mut nested = Vec::new(); 28 38 29 29 - /// Count the number of required fields in a lexicon object. 30 30 - /// Used to determine whether to generate builders or Default impls. 31 31 - pub(crate) fn count_required_fields(obj: &LexObject<'static>) -> usize { 32 32 - let required = obj.required.as_ref().map(|r| r.as_slice()).unwrap_or(&[]); 33 33 - required.len() 34 34 - } 39 39 + for (field_name, field_type) in properties { 40 40 + match field_type { 41 41 + LexObjectProperty::Union(union) => { 42 42 + // Skip empty, single-variant unions unless they're self-referential 43 43 + if !union.refs.is_empty() 44 44 + && (union.refs.len() > 1 45 45 + || self.is_self_referential_union(nsid, parent_type_name, &union)) 46 46 + { 47 47 + let union_name = 48 48 + self.generate_field_type_name(nsid, parent_type_name, field_name, ""); 49 49 + let refs: Vec<_> = union.refs.iter().cloned().collect(); 50 50 + let union_def = self.generate_union( 51 51 + nsid, 52 52 + &union_name, 53 53 + &refs, 54 54 + None, 55 55 + union.closed, 56 56 + )?; 57 57 + nested.push(union_def); 58 58 + } 59 59 + } 60 60 + LexObjectProperty::Object(nested_obj) if include_nested_objects => { 61 61 + let object_name = 62 62 + self.generate_field_type_name(nsid, parent_type_name, field_name, ""); 63 63 + let obj_def = self.generate_object(nsid, &object_name, &nested_obj)?; 64 64 + nested.push(obj_def); 65 65 + } 66 66 + LexObjectProperty::Array(array) => { 67 67 + if let LexArrayItem::Union(union) = &array.items { 68 68 + // Skip single-variant array unions 69 69 + if union.refs.len() > 1 { 70 70 + let union_name = self.generate_field_type_name( 71 71 + nsid, 72 72 + parent_type_name, 73 73 + field_name, 74 74 + "Item", 75 75 + ); 76 76 + let refs: Vec<_> = union.refs.iter().cloned().collect(); 77 77 + let union_def = self.generate_union( 78 78 + nsid, 79 79 + &union_name, 80 80 + &refs, 81 81 + None, 82 82 + union.closed, 83 83 + )?; 84 84 + nested.push(union_def); 85 85 + } 86 86 + } 87 87 + } 88 88 + _ => {} 89 89 + } 90 90 + } 35 91 36 36 - /// Check if a field property is a plain string that can default to empty. 37 37 - /// Returns true for bare CowStr fields (no format constraints). 38 38 - fn is_defaultable_string(prop: &LexObjectProperty<'static>) -> bool { 39 39 - matches!(prop, LexObjectProperty::String(s) if s.format.is_none()) 40 40 - } 41 41 - 42 42 - /// Check if all required fields in an object are defaultable strings. 43 43 - pub(crate) fn all_required_are_defaultable_strings(obj: &LexObject<'static>) -> bool { 44 44 - let required = obj.required.as_ref().map(|r| r.as_slice()).unwrap_or(&[]); 45 45 - 46 46 - if required.is_empty() { 47 47 - return false; // Handled separately by count check 92 92 + Ok(nested) 48 93 } 49 94 50 50 - required.iter().all(|field_name| { 51 51 - let field_name_str: &str = field_name.as_ref(); 52 52 - obj.properties 53 53 - .get(field_name_str) 54 54 - .map(is_defaultable_string) 55 55 - .unwrap_or(false) 56 56 - }) 57 57 - } 58 58 - 59 59 - impl<'c> CodeGenerator<'c> { 60 95 pub(super) fn generate_record( 61 96 &self, 62 97 nsid: &str, ··· 71 106 // Records always get a lifetime since they have the #[lexicon] attribute 72 107 // which adds extra_data: BTreeMap<..., Data<'a>> 73 108 // Skip bon::Builder for types that conflict with the macro's unqualified type references 74 74 - let has_builder = !conflicts_with_builder_macro(&type_name); 109 109 + let has_builder = 110 110 + !super::builder_heuristics::conflicts_with_builder_macro(&type_name); 75 111 76 112 // Generate main struct fields 77 113 let fields = self.generate_object_fields(nsid, &type_name, obj, has_builder)?; ··· 100 136 }; 101 137 102 138 // Generate union types and nested object types for this record 103 103 - let mut unions = Vec::new(); 104 104 - for (field_name, field_type) in &obj.properties { 105 105 - match field_type { 106 106 - LexObjectProperty::Union(union) => { 107 107 - // Skip empty, single-variant unions unless they're self-referential 108 108 - if !union.refs.is_empty() 109 109 - && (union.refs.len() > 1 110 110 - || self.is_self_referential_union(nsid, &type_name, union)) 111 111 - { 112 112 - let union_name = 113 113 - self.generate_field_type_name(nsid, &type_name, field_name, ""); 114 114 - let refs: Vec<_> = union.refs.iter().cloned().collect(); 115 115 - let union_def = self.generate_union( 116 116 - nsid, 117 117 - &union_name, 118 118 - &refs, 119 119 - None, 120 120 - union.closed, 121 121 - )?; 122 122 - unions.push(union_def); 123 123 - } 124 124 - } 125 125 - LexObjectProperty::Object(nested_obj) => { 126 126 - let object_name = 127 127 - self.generate_field_type_name(nsid, &type_name, field_name, ""); 128 128 - let obj_def = self.generate_object(nsid, &object_name, nested_obj)?; 129 129 - unions.push(obj_def); 130 130 - } 131 131 - LexObjectProperty::Array(array) => { 132 132 - if let LexArrayItem::Union(union) = &array.items { 133 133 - // Skip single-variant array unions 134 134 - if union.refs.len() > 1 { 135 135 - let union_name = self.generate_field_type_name( 136 136 - nsid, &type_name, field_name, "Item", 137 137 - ); 138 138 - let refs: Vec<_> = union.refs.iter().cloned().collect(); 139 139 - let union_def = self.generate_union( 140 140 - nsid, 141 141 - &union_name, 142 142 - &refs, 143 143 - None, 144 144 - union.closed, 145 145 - )?; 146 146 - unions.push(union_def); 147 147 - } 148 148 - } 149 149 - } 150 150 - _ => {} 151 151 - } 152 152 - } 139 139 + let unions = self.generate_nested_types(nsid, &type_name, &obj.properties, true)?; 153 140 154 141 // Generate typed GetRecordOutput wrapper 155 142 let output_type_name = format!("{}GetRecordOutput", type_name); ··· 257 244 // - 0 required fields: Default instead of builder 258 245 // - All required fields are bare strings: Default instead of builder 259 246 // - 1+ required fields (not all strings): bon::Builder (but not if name conflicts) 260 260 - let required_count = count_required_fields(obj); 261 261 - let has_default = required_count == 0 || all_required_are_defaultable_strings(obj); 262 262 - let has_builder = 263 263 - required_count >= 1 && !has_default && !conflicts_with_builder_macro(&type_name); 247 247 + let decision = super::builder_heuristics::should_generate_builder(&type_name, obj); 248 248 + let has_builder = decision.has_builder; 249 249 + let has_default = decision.has_default; 264 250 265 251 let fields = self.generate_object_fields(nsid, &type_name, obj, has_builder)?; 266 252 let doc = self.generate_doc_comment(obj.description.as_ref()); ··· 298 284 }; 299 285 300 286 // Generate union types and nested object types for this object 301 301 - let mut unions = Vec::new(); 302 302 - for (field_name, field_type) in &obj.properties { 303 303 - match field_type { 304 304 - LexObjectProperty::Union(union) => { 305 305 - // Skip empty, single-variant unions unless they're self-referential 306 306 - if !union.refs.is_empty() 307 307 - && (union.refs.len() > 1 308 308 - || self.is_self_referential_union(nsid, &type_name, union)) 309 309 - { 310 310 - let union_name = 311 311 - self.generate_field_type_name(nsid, &type_name, field_name, ""); 312 312 - let refs: Vec<_> = union.refs.iter().cloned().collect(); 313 313 - let union_def = 314 314 - self.generate_union(nsid, &union_name, &refs, None, union.closed)?; 315 315 - unions.push(union_def); 316 316 - } 317 317 - } 318 318 - LexObjectProperty::Object(nested_obj) => { 319 319 - let object_name = 320 320 - self.generate_field_type_name(nsid, &type_name, field_name, ""); 321 321 - let obj_def = self.generate_object(nsid, &object_name, nested_obj)?; 322 322 - unions.push(obj_def); 323 323 - } 324 324 - LexObjectProperty::Array(array) => { 325 325 - if let LexArrayItem::Union(union) = &array.items { 326 326 - // Skip single-variant array unions 327 327 - if union.refs.len() > 1 { 328 328 - let union_name = 329 329 - self.generate_field_type_name(nsid, &type_name, field_name, "Item"); 330 330 - let refs: Vec<_> = union.refs.iter().cloned().collect(); 331 331 - let union_def = 332 332 - self.generate_union(nsid, &union_name, &refs, None, union.closed)?; 333 333 - unions.push(union_def); 334 334 - } 335 335 - } 336 336 - } 337 337 - _ => {} 338 338 - } 339 339 - } 287 287 + let unions = self.generate_nested_types(nsid, &type_name, &obj.properties, true)?; 340 288 341 289 // Generate LexiconSchema impl with shared lexicon_doc function 342 290 let (shared_fn, schema_impl) = ··· 467 415 ) -> Result<TokenStream> { 468 416 let enum_ident = syn::Ident::new(union_name, proc_macro2::Span::call_site()); 469 417 470 470 - // Extract namespace prefix from current NSID (first two segments: "sh.weaver" from "sh.weaver.embed.recordWithMedia") 471 471 - let current_nsid_path = NsidPath::parse(current_nsid); 472 472 - let current_namespace = current_nsid_path.namespace(); 473 473 - 474 474 - // First pass: collect all variant names and detect collisions 475 475 - #[derive(Debug)] 476 476 - struct VariantInfo { 477 477 - ref_str: String, 478 478 - ref_nsid: String, 479 479 - simple_name: String, 480 480 - is_current_namespace: bool, 481 481 - } 482 482 - 483 483 - let mut variant_infos = Vec::new(); 484 484 - for ref_str in refs { 485 485 - // Normalize local refs (starting with #) by prepending current NSID 486 486 - let normalized_ref = RefPath::normalize(ref_str, current_nsid); 487 487 - 488 488 - // Parse ref to get NSID and def name 489 489 - let ref_path = RefPath::parse(&normalized_ref, None); 490 490 - let ref_nsid_str = ref_path.nsid(); 491 491 - let ref_def = ref_path.def(); 492 492 - 493 493 - // Skip unknown refs - they'll be handled by Unknown variant 494 494 - if !self.corpus.ref_exists(&normalized_ref) { 495 495 - continue; 496 496 - } 497 497 - 498 498 - // Check if ref is in current namespace and if it's the same module 499 499 - let is_current_namespace = ref_nsid_str.starts_with(&current_namespace); 500 500 - let is_same_module = ref_nsid_str == current_nsid; 418 418 + // Build variants using the union_codegen module 419 419 + let ctx = super::union_codegen::UnionGenContext { 420 420 + corpus: self.corpus, 421 421 + namespace_deps: &self.namespace_deps, 422 422 + current_nsid, 423 423 + }; 501 424 502 502 - // Generate simple variant name (without namespace prefix) 503 503 - let last_segment = ref_nsid_str.split('.').last().unwrap(); 504 504 - let simple_name = if ref_def == "main" { 505 505 - // For main, use the last NSID segment 506 506 - // e.g. app.bsky.embed.images#main -> Images 507 507 - last_segment.to_pascal_case() 508 508 - } else if last_segment == "defs" { 509 509 - // For defs modules, just use the fragment name without "Defs" prefix 510 510 - // e.g. app.bsky.embed.defs#images -> Images (not DefsImages) 511 511 - ref_def.to_pascal_case() 512 512 - } else if is_same_module { 513 513 - // For same-module refs, just use the fragment name to avoid redundancy 514 514 - // e.g. sh.weaver.embed.records#viewRecord in records.rs -> ViewRecord (not RecordsViewRecord) 515 515 - ref_def.to_pascal_case() 516 516 - } else { 517 517 - // For other fragments, include the last NSID segment to avoid collisions 518 518 - // e.g. app.bsky.embed.images#view -> ImagesView 519 519 - // app.bsky.embed.video#view -> VideoView 520 520 - format!( 521 521 - "{}{}", 522 522 - last_segment.to_pascal_case(), 523 523 - ref_def.to_pascal_case() 524 524 - ) 525 525 - }; 526 526 - 527 527 - variant_infos.push(VariantInfo { 528 528 - ref_str: normalized_ref.clone(), 529 529 - ref_nsid: ref_nsid_str.to_string(), 530 530 - simple_name, 531 531 - is_current_namespace, 532 532 - }); 533 533 - } 534 534 - 535 535 - // Second pass: detect collisions and disambiguate 536 536 - use std::collections::HashMap; 537 537 - let mut name_counts: HashMap<String, usize> = HashMap::new(); 538 538 - for info in &variant_infos { 539 539 - *name_counts.entry(info.simple_name.clone()).or_insert(0) += 1; 540 540 - } 541 541 - 542 542 - let mut variants = Vec::new(); 543 543 - for info in variant_infos { 544 544 - let has_collision = name_counts.get(&info.simple_name).copied().unwrap_or(0) > 1; 545 545 - 546 546 - // Track namespace dependency for foreign refs 547 547 - if !info.is_current_namespace { 548 548 - let ref_nsid_path = NsidPath::parse(&info.ref_nsid); 549 549 - let foreign_namespace = ref_nsid_path.namespace(); 550 550 - self.namespace_deps 551 551 - .borrow_mut() 552 552 - .entry(current_namespace.clone()) 553 553 - .or_default() 554 554 - .insert(foreign_namespace); 555 555 - } 556 556 - 557 557 - // Disambiguate: add second NSID segment prefix only to foreign refs when there's a collision 558 558 - let variant_name = if has_collision && !info.is_current_namespace { 559 559 - // Get second segment (namespace identifier: "bsky" from "app.bsky.embed.images") 560 560 - let ref_nsid_path = NsidPath::parse(&info.ref_nsid); 561 561 - let segments = ref_nsid_path.segments(); 562 562 - let prefix = if segments.len() >= 2 { 563 563 - segments[1].to_pascal_case() 564 564 - } else { 565 565 - // Fallback: use first segment if only one exists 566 566 - segments[0].to_pascal_case() 567 567 - }; 568 568 - format!("{}{}", prefix, info.simple_name) 569 569 - } else { 570 570 - info.simple_name.clone() 571 571 - }; 572 572 - 573 573 - let variant_ident = syn::Ident::new(&variant_name, proc_macro2::Span::call_site()); 574 574 - 575 575 - // Get the Rust type for this ref 576 576 - let rust_type = self.ref_to_rust_type(&info.ref_str)?; 577 577 - 578 578 - // Add serde rename for the full NSID 579 579 - let ref_str_literal = &info.ref_str; 580 580 - variants.push(quote! { 581 581 - #[serde(rename = #ref_str_literal)] 582 582 - #variant_ident(Box<#rust_type>) 583 583 - }); 584 584 - } 425 425 + let union_variants = ctx.build_union_variants(refs, |ref_str| self.ref_to_rust_type(ref_str))?; 426 426 + let variants = super::union_codegen::generate_variant_tokens(&union_variants); 585 427 586 428 let doc = description 587 429 .map(|d| quote! { #[doc = #d] })

+15 -30

crates/jacquard-lexicon/src/codegen/types.rs

··· 4 4 use proc_macro2::TokenStream; 5 5 use quote::quote; 6 6 7 7 + use super::CodeGenerator; 7 8 use super::nsid_utils::{NsidPath, RefPath}; 8 8 - use super::CodeGenerator; 9 9 + use super::utils::{join_module_path, join_path_parts, namespace_prefix, sanitize_name_cow}; 9 10 10 11 impl<'c> CodeGenerator<'c> { 11 12 /// Convert a property type to Rust type ··· 178 179 179 180 /// Convert ref to Rust type path 180 181 pub(super) fn ref_to_rust_type(&self, ref_str: &str) -> Result<TokenStream> { 181 181 - use super::utils::sanitize_name; 182 182 use crate::error::CodegenError; 183 183 184 184 // Parse ref to get NSID and def ··· 205 205 206 206 let path_str = if nsid_path.is_defs() && parts.len() >= 3 { 207 207 // defs types go in parent module 208 208 - let first_two = format!("{}_{}", sanitize_name(parts[0]), sanitize_name(parts[1])); 208 208 + let first_two = namespace_prefix(parts[0], parts[1]); 209 209 if parts.len() == 3 { 210 210 // com.atproto.defs -> com_atproto::TypeName 211 211 - format!("{}::{}::{}", self.root_module, first_two, type_name) 211 211 + join_path_parts(&[&self.root_module, &first_two, &type_name]) 212 212 } else { 213 213 // app.bsky.actor.defs -> app_bsky::actor::TypeName 214 214 - let middle: Vec<_> = parts[2..parts.len() - 1] 215 215 - .iter() 216 216 - .copied() 217 217 - .map(|s| sanitize_name(s)) 218 218 - .collect(); 219 219 - format!( 220 220 - "{}::{}::{}::{}", 221 221 - self.root_module, 222 222 - first_two, 223 223 - middle.join("::"), 224 224 - type_name 225 225 - ) 214 214 + let middle = &parts[2..parts.len() - 1]; 215 215 + let middle_path = join_module_path(middle); 216 216 + join_path_parts(&[&self.root_module, &first_two, &middle_path, &type_name]) 226 217 } 227 218 } else { 228 219 // Regular types go in their own module file 229 220 let (module_path, file_module) = if parts.len() >= 3 { 230 221 // Join first two segments with underscore 231 231 - let first_two = format!("{}_{}", sanitize_name(parts[0]), sanitize_name(parts[1])); 232 232 - let file_name = sanitize_name(last_segment).to_snake_case(); 222 222 + let first_two = namespace_prefix(parts[0], parts[1]); 223 223 + let file_name = sanitize_name_cow(last_segment).to_string().to_snake_case(); 233 224 234 225 if parts.len() > 3 { 235 226 // Middle segments form the module path 236 236 - let middle: Vec<_> = parts[2..parts.len() - 1] 237 237 - .iter() 238 238 - .copied() 239 239 - .map(|s| sanitize_name(s)) 240 240 - .collect(); 241 241 - let base_path = format!("{}::{}", first_two, middle.join("::")); 227 227 + let middle = &parts[2..parts.len() - 1]; 228 228 + let middle_path = join_module_path(middle); 229 229 + let base_path = join_path_parts(&[&first_two, &middle_path]); 242 230 (base_path, file_name) 243 231 } else { 244 232 // Only 3 parts: com.atproto.label -> com_atproto, file: label ··· 246 234 } 247 235 } else if parts.len() == 2 { 248 236 // e.g., "com.example" -> "com_example", file: example 249 249 - let first = sanitize_name(parts[0]); 250 250 - let file_name = sanitize_name(parts[1]).to_snake_case(); 237 237 + let first = sanitize_name_cow(parts[0]).to_string(); 238 238 + let file_name = sanitize_name_cow(parts[1]).to_string().to_snake_case(); 251 239 (first, file_name) 252 240 } else { 253 241 (parts[0].to_string(), "main".to_string()) 254 242 }; 255 243 256 256 - format!( 257 257 - "{}::{}::{}::{}", 258 258 - self.root_module, module_path, file_module, type_name 259 259 - ) 244 244 + join_path_parts(&[&self.root_module, &module_path, &file_module, &type_name]) 260 245 }; 261 246 262 247 let path: syn::Path = syn::parse_str(&path_str).map_err(|e| CodegenError::Other {

+184

crates/jacquard-lexicon/src/codegen/union_codegen.rs

··· 1 1 + use crate::codegen::nsid_utils::{NsidPath, RefPath}; 2 2 + use crate::corpus::LexiconCorpus; 3 3 + use crate::error::Result; 4 4 + use heck::ToPascalCase; 5 5 + use jacquard_common::CowStr; 6 6 + use proc_macro2::TokenStream; 7 7 + use quote::quote; 8 8 + use std::cell::RefCell; 9 9 + use std::collections::{HashMap, HashSet}; 10 10 + 11 11 + /// Information about a union variant 12 12 + #[derive(Debug, Clone)] 13 13 + pub struct UnionVariant { 14 14 + /// The original ref string (normalized) 15 15 + pub ref_str: String, 16 16 + /// The variant name (may be disambiguated) 17 17 + pub variant_name: String, 18 18 + /// The Rust type for this variant 19 19 + pub rust_type: TokenStream, 20 20 + } 21 21 + 22 22 + /// Context for tracking namespace dependencies during union generation 23 23 + pub struct UnionGenContext<'a> { 24 24 + pub corpus: &'a LexiconCorpus, 25 25 + pub namespace_deps: &'a RefCell<HashMap<String, HashSet<String>>>, 26 26 + pub current_nsid: &'a str, 27 27 + } 28 28 + 29 29 + impl<'a> UnionGenContext<'a> { 30 30 + /// Build variants for a union with collision detection and disambiguation 31 31 + pub fn build_union_variants( 32 32 + &self, 33 33 + refs: &[CowStr<'static>], 34 34 + ref_to_rust_type: impl Fn(&str) -> Result<TokenStream>, 35 35 + ) -> Result<Vec<UnionVariant>> { 36 36 + let current_nsid_path = NsidPath::parse(self.current_nsid); 37 37 + let current_namespace = current_nsid_path.namespace(); 38 38 + 39 39 + // First pass: collect all variant names and detect collisions 40 40 + #[derive(Debug)] 41 41 + struct VariantInfo { 42 42 + ref_str: String, 43 43 + ref_nsid: String, 44 44 + simple_name: String, 45 45 + is_current_namespace: bool, 46 46 + } 47 47 + 48 48 + let mut variant_infos = Vec::new(); 49 49 + for ref_str in refs { 50 50 + let normalized_ref = RefPath::normalize(ref_str, self.current_nsid); 51 51 + let ref_path = RefPath::parse(&normalized_ref, None); 52 52 + let ref_nsid_str = ref_path.nsid(); 53 53 + let ref_def = ref_path.def(); 54 54 + 55 55 + // Skip unknown refs 56 56 + if !self.corpus.ref_exists(&normalized_ref) { 57 57 + continue; 58 58 + } 59 59 + 60 60 + let is_current_namespace = ref_nsid_str.starts_with(&current_namespace); 61 61 + let is_same_module = ref_nsid_str == self.current_nsid; 62 62 + 63 63 + // Generate simple variant name 64 64 + let last_segment = ref_nsid_str.split('.').last().unwrap(); 65 65 + let simple_name = if ref_def == "main" { 66 66 + last_segment.to_pascal_case() 67 67 + } else if last_segment == "defs" { 68 68 + ref_def.to_pascal_case() 69 69 + } else if is_same_module { 70 70 + ref_def.to_pascal_case() 71 71 + } else { 72 72 + format!( 73 73 + "{}{}", 74 74 + last_segment.to_pascal_case(), 75 75 + ref_def.to_pascal_case() 76 76 + ) 77 77 + }; 78 78 + 79 79 + variant_infos.push(VariantInfo { 80 80 + ref_str: normalized_ref.clone(), 81 81 + ref_nsid: ref_nsid_str.to_string(), 82 82 + simple_name, 83 83 + is_current_namespace, 84 84 + }); 85 85 + } 86 86 + 87 87 + // Second pass: detect collisions and disambiguate 88 88 + let mut name_counts: HashMap<String, usize> = HashMap::new(); 89 89 + for info in &variant_infos { 90 90 + *name_counts.entry(info.simple_name.clone()).or_insert(0) += 1; 91 91 + } 92 92 + 93 93 + let mut variants = Vec::new(); 94 94 + for info in variant_infos { 95 95 + let has_collision = name_counts.get(&info.simple_name).copied().unwrap_or(0) > 1; 96 96 + 97 97 + // Track namespace dependency for foreign refs 98 98 + if !info.is_current_namespace { 99 99 + let ref_nsid_path = NsidPath::parse(&info.ref_nsid); 100 100 + let foreign_namespace = ref_nsid_path.namespace(); 101 101 + self.namespace_deps 102 102 + .borrow_mut() 103 103 + .entry(current_namespace.clone()) 104 104 + .or_default() 105 105 + .insert(foreign_namespace); 106 106 + } 107 107 + 108 108 + // Disambiguate: add second NSID segment prefix only to foreign refs when there's a collision 109 109 + let variant_name = if has_collision && !info.is_current_namespace { 110 110 + let ref_nsid_path = NsidPath::parse(&info.ref_nsid); 111 111 + let segments = ref_nsid_path.segments(); 112 112 + let prefix = if segments.len() >= 2 { 113 113 + segments[1].to_pascal_case() 114 114 + } else { 115 115 + segments[0].to_pascal_case() 116 116 + }; 117 117 + format!("{}{}", prefix, info.simple_name) 118 118 + } else { 119 119 + info.simple_name.clone() 120 120 + }; 121 121 + 122 122 + let rust_type = ref_to_rust_type(&info.ref_str)?; 123 123 + 124 124 + variants.push(UnionVariant { 125 125 + ref_str: info.ref_str, 126 126 + variant_name, 127 127 + rust_type, 128 128 + }); 129 129 + } 130 130 + 131 131 + Ok(variants) 132 132 + } 133 133 + 134 134 + /// Build variants for a union without collision detection (simple mode) 135 135 + pub fn build_simple_union_variants( 136 136 + &self, 137 137 + refs: &[CowStr<'static>], 138 138 + ref_to_rust_type: impl Fn(&str) -> Result<TokenStream>, 139 139 + ) -> Result<Vec<UnionVariant>> { 140 140 + let mut variants = Vec::new(); 141 141 + 142 142 + for ref_str in refs { 143 143 + let ref_str_s = ref_str.as_ref(); 144 144 + let normalized_ref = RefPath::normalize(ref_str, self.current_nsid); 145 145 + let ref_path = RefPath::parse(&normalized_ref, None); 146 146 + let ref_nsid = ref_path.nsid(); 147 147 + let ref_def = ref_path.def(); 148 148 + 149 149 + let variant_name = if ref_def == "main" { 150 150 + let ref_nsid_path = NsidPath::parse(ref_nsid); 151 151 + ref_nsid_path.last_segment().to_pascal_case() 152 152 + } else { 153 153 + ref_def.to_pascal_case() 154 154 + }; 155 155 + 156 156 + let rust_type = ref_to_rust_type(&normalized_ref)?; 157 157 + 158 158 + variants.push(UnionVariant { 159 159 + ref_str: ref_str_s.to_string(), 160 160 + variant_name, 161 161 + rust_type, 162 162 + }); 163 163 + } 164 164 + 165 165 + Ok(variants) 166 166 + } 167 167 + } 168 168 + 169 169 + /// Generate variant tokens for a union enum 170 170 + pub fn generate_variant_tokens(variants: &[UnionVariant]) -> Vec<TokenStream> { 171 171 + variants 172 172 + .iter() 173 173 + .map(|variant| { 174 174 + let variant_ident = syn::Ident::new(&variant.variant_name, proc_macro2::Span::call_site()); 175 175 + let ref_str_literal = &variant.ref_str; 176 176 + let rust_type = &variant.rust_type; 177 177 + 178 178 + quote! { 179 179 + #[serde(rename = #ref_str_literal)] 180 180 + #variant_ident(Box<#rust_type>) 181 181 + } 182 182 + }) 183 183 + .collect() 184 184 + }

+57 -3

crates/jacquard-lexicon/src/codegen/utils.rs

··· 19 19 } 20 20 } 21 21 22 22 - /// Sanitize a string to be safe for identifiers and filenames 23 23 - pub(super) fn sanitize_name(s: &str) -> String { 22 22 + /// Check if a string is already a valid identifier (alphanumeric + underscore, not starting with digit) 23 23 + #[inline] 24 24 + fn is_valid_identifier(s: &str) -> bool { 24 25 if s.is_empty() { 25 25 - return "unknown".to_string(); 26 26 + return false; 27 27 + } 28 28 + 29 29 + let mut chars = s.chars(); 30 30 + let first = chars.next().unwrap(); 31 31 + 32 32 + // Must start with letter or underscore 33 33 + if !first.is_ascii_alphabetic() && first != '_' { 34 34 + return false; 35 35 + } 36 36 + 37 37 + // Rest must be alphanumeric or underscore 38 38 + chars.all(|c| c.is_ascii_alphanumeric() || c == '_') 39 39 + } 40 40 + 41 41 + /// Sanitize a string to be safe for identifiers and filenames, returning CowStr. 42 42 + /// Borrows if already valid, allocates if modifications needed. 43 43 + pub(super) fn sanitize_name_cow(s: &str) -> CowStr<'_> { 44 44 + if is_valid_identifier(s) { 45 45 + return CowStr::Borrowed(s); 46 46 + } 47 47 + 48 48 + if s.is_empty() { 49 49 + return CowStr::Owned(jacquard_common::smol_str::SmolStr::new_static("unknown")); 26 50 } 27 51 28 52 // Replace invalid characters with underscores ··· 46 70 sanitized = format!("_{}", sanitized); 47 71 } 48 72 73 73 + CowStr::Owned(sanitized.into()) 74 74 + } 75 75 + 76 76 + /// Sanitize a string to be safe for identifiers and filenames, always returning String. 77 77 + /// Convenience wrapper around sanitize_name_cow for existing callsites. 78 78 + pub(super) fn sanitize_name(s: &str) -> String { 79 79 + sanitize_name_cow(s).to_string() 80 80 + } 81 81 + 82 82 + /// Build namespace prefix from first two NSID segments (e.g., "com", "atproto" → "com_atproto") 83 83 + pub(super) fn namespace_prefix(first: &str, second: &str) -> String { 84 84 + format!("{}_{}", sanitize_name_cow(first), sanitize_name_cow(second)) 85 85 + } 86 86 + 87 87 + /// Join NSID segments into a module path (e.g., ["repo", "admin"] → "repo::admin") 88 88 + pub(super) fn join_module_path(segments: &[&str]) -> String { 89 89 + let sanitized: Vec<_> = segments.iter().map(|s| sanitize_name_cow(s)).collect(); 49 90 sanitized 91 91 + .iter() 92 92 + .map(|s| s.as_ref()) 93 93 + .collect::<Vec<_>>() 94 94 + .join("::") 95 95 + } 96 96 + 97 97 + /// Join already-processed strings into a Rust module path (e.g., ["crate", "foo", "Bar"] → "crate::foo::Bar") 98 98 + pub(super) fn join_path_parts(parts: &[impl AsRef<str>]) -> String { 99 99 + parts 100 100 + .iter() 101 101 + .map(|p| p.as_ref()) 102 102 + .collect::<Vec<_>>() 103 103 + .join("::") 50 104 } 51 105 52 106 /// Create an identifier, using raw identifier if necessary for keywords

+38 -185

crates/jacquard-lexicon/src/codegen/xrpc.rs

··· 1 1 use crate::error::Result; 2 2 use crate::lexicon::{ 3 3 - LexArrayItem, LexObjectProperty, LexXrpcBody, LexXrpcBodySchema, LexXrpcError, 4 4 - LexXrpcProcedure, LexXrpcQuery, LexXrpcSubscription, LexXrpcSubscriptionMessageSchema, 3 3 + LexXrpcBody, LexXrpcBodySchema, LexXrpcError, LexXrpcProcedure, LexXrpcQuery, 4 4 + LexXrpcSubscription, LexXrpcSubscriptionMessageSchema, 5 5 }; 6 6 use heck::{ToPascalCase, ToSnakeCase}; 7 7 use proc_macro2::TokenStream; 8 8 use quote::quote; 9 9 10 10 - use super::nsid_utils::{NsidPath, RefPath}; 11 10 use super::CodeGenerator; 12 11 use super::utils::make_ident; 13 12 ··· 224 223 let enum_name = format!("{}Message", type_base); 225 224 let enum_ident = syn::Ident::new(&enum_name, proc_macro2::Span::call_site()); 226 225 227 227 - let mut variants = Vec::new(); 228 228 - let mut decode_arms = Vec::new(); 229 229 - 230 230 - for ref_str in &union.refs { 231 231 - let ref_str_s = ref_str.as_ref(); 232 232 - 233 233 - // Normalize local refs (starting with #) by prepending current NSID 234 234 - let normalized_ref = RefPath::normalize(ref_str, nsid); 235 235 - 236 236 - // Parse ref to get NSID and def name 237 237 - let ref_path = RefPath::parse(&normalized_ref, None); 238 238 - let ref_nsid = ref_path.nsid(); 239 239 - let ref_def = ref_path.def(); 240 240 - 241 241 - let variant_name = if ref_def == "main" { 242 242 - let ref_nsid_path = NsidPath::parse(ref_nsid); 243 243 - ref_nsid_path.last_segment().to_pascal_case() 244 244 - } else { 245 245 - ref_def.to_pascal_case() 246 246 - }; 247 247 - let variant_ident = 248 248 - syn::Ident::new(&variant_name, proc_macro2::Span::call_site()); 249 249 - let type_path = self.ref_to_rust_type(&normalized_ref)?; 226 226 + // Build variants using the union_codegen module (simple mode, no collision detection) 227 227 + let ctx = super::union_codegen::UnionGenContext { 228 228 + corpus: self.corpus, 229 229 + namespace_deps: &self.namespace_deps, 230 230 + current_nsid: nsid, 231 231 + }; 250 232 251 251 - variants.push(quote! { 252 252 - #[serde(rename = #ref_str_s)] 253 253 - #variant_ident(Box<#type_path>) 254 254 - }); 233 233 + let union_variants = ctx.build_simple_union_variants(&union.refs, |ref_str| self.ref_to_rust_type(ref_str))?; 234 234 + let variants = super::union_codegen::generate_variant_tokens(&union_variants); 255 235 256 256 - // Generate decode arm for framed decoding 257 257 - decode_arms.push(quote! { 258 258 - #ref_str_s => { 259 259 - let variant = serde_ipld_dagcbor::from_slice(body)?; 260 260 - Ok(Self::#variant_ident(Box::new(variant))) 236 236 + // Generate decode arms for framed decoding 237 237 + let decode_arms: Vec<_> = union_variants 238 238 + .iter() 239 239 + .map(|variant| { 240 240 + let ref_str_literal = &variant.ref_str; 241 241 + let variant_ident = 242 242 + syn::Ident::new(&variant.variant_name, proc_macro2::Span::call_site()); 243 243 + quote! { 244 244 + #ref_str_literal => { 245 245 + let variant = serde_ipld_dagcbor::from_slice(body)?; 246 246 + Ok(Self::#variant_ident(Box::new(variant))) 247 247 + } 261 248 } 262 262 - }); 263 263 - } 249 249 + }) 250 250 + .collect(); 264 251 265 252 let doc = self.generate_doc_comment(union.description.as_ref()); 266 253 ··· 314 301 }; 315 302 316 303 // Generate union types for this message 317 317 - let mut unions = Vec::new(); 318 318 - for (field_name, field_type) in &obj.properties { 319 319 - match field_type { 320 320 - LexObjectProperty::Union(union) => { 321 321 - // Skip empty, single-variant unions unless they're self-referential 322 322 - if !union.refs.is_empty() 323 323 - && (union.refs.len() > 1 324 324 - || self.is_self_referential_union(nsid, &struct_name, union)) 325 325 - { 326 326 - let union_name = self.generate_field_type_name( 327 327 - nsid, 328 328 - &struct_name, 329 329 - field_name, 330 330 - "", 331 331 - ); 332 332 - let refs: Vec<_> = union.refs.iter().cloned().collect(); 333 333 - let union_def = self.generate_union( 334 334 - nsid, 335 335 - &union_name, 336 336 - &refs, 337 337 - None, 338 338 - union.closed, 339 339 - )?; 340 340 - unions.push(union_def); 341 341 - } 342 342 - } 343 343 - LexObjectProperty::Array(array) => { 344 344 - if let LexArrayItem::Union(union) = &array.items { 345 345 - // Skip single-variant array unions 346 346 - if union.refs.len() > 1 { 347 347 - let union_name = self.generate_field_type_name( 348 348 - nsid, 349 349 - &struct_name, 350 350 - field_name, 351 351 - "Item", 352 352 - ); 353 353 - let refs: Vec<_> = union.refs.iter().cloned().collect(); 354 354 - let union_def = self.generate_union( 355 355 - nsid, 356 356 - &union_name, 357 357 - &refs, 358 358 - None, 359 359 - union.closed, 360 360 - )?; 361 361 - unions.push(union_def); 362 362 - } 363 363 - } 364 364 - } 365 365 - _ => {} 366 366 - } 367 367 - } 304 304 + let unions = self.generate_nested_types(nsid, &struct_name, &obj.properties, false)?; 368 305 369 306 Ok(quote! { 370 307 #struct_def ··· 496 433 let (has_default, has_builder) = if is_binary_body { 497 434 (false, true) 498 435 } else if let Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) = &body.schema { 499 499 - use crate::codegen::structs::{ 500 500 - all_required_are_defaultable_strings, conflicts_with_builder_macro, 501 501 - count_required_fields, 502 502 - }; 503 503 - let required_count = count_required_fields(obj); 504 504 - let can_default = required_count == 0 || all_required_are_defaultable_strings(obj); 505 505 - let can_builder = 506 506 - required_count >= 1 && !can_default && !conflicts_with_builder_macro(type_base); 507 507 - (can_default, can_builder) 436 436 + let decision = super::builder_heuristics::should_generate_builder(type_base, obj); 437 437 + (decision.has_default, decision.has_builder) 508 438 } else { 509 439 (false, false) 510 440 }; ··· 574 504 }; 575 505 576 506 // Generate union types if schema is an Object 577 577 - let mut unions = Vec::new(); 578 578 - if let Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) = &body.schema { 579 579 - for (field_name, field_type) in &obj.properties { 580 580 - match field_type { 581 581 - LexObjectProperty::Union(union) => { 582 582 - // Skip empty, single-variant unions unless they're self-referential 583 583 - if !union.refs.is_empty() 584 584 - && (union.refs.len() > 1 585 585 - || self.is_self_referential_union(nsid, type_base, union)) 586 586 - { 587 587 - let union_name = 588 588 - self.generate_field_type_name(nsid, type_base, field_name, ""); 589 589 - let refs: Vec<_> = union.refs.iter().cloned().collect(); 590 590 - let union_def = 591 591 - self.generate_union(nsid, &union_name, &refs, None, union.closed)?; 592 592 - unions.push(union_def); 593 593 - } 594 594 - } 595 595 - LexObjectProperty::Array(array) => { 596 596 - if let LexArrayItem::Union(union) = &array.items { 597 597 - // Skip single-variant array unions 598 598 - if union.refs.len() > 1 { 599 599 - let union_name = self 600 600 - .generate_field_type_name(nsid, type_base, field_name, "Item"); 601 601 - let refs: Vec<_> = union.refs.iter().cloned().collect(); 602 602 - let union_def = self.generate_union( 603 603 - nsid, 604 604 - &union_name, 605 605 - &refs, 606 606 - None, 607 607 - union.closed, 608 608 - )?; 609 609 - unions.push(union_def); 610 610 - } 611 611 - } 612 612 - } 613 613 - _ => {} 614 614 - } 615 615 - } 616 616 - } 507 507 + let unions = if let Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) = &body.schema { 508 508 + self.generate_nested_types(nsid, type_base, &obj.properties, false)? 509 509 + } else { 510 510 + Vec::new() 511 511 + }; 617 512 618 513 Ok(quote! { 619 514 #struct_def ··· 645 540 // Check if schema is an Object and apply heuristics 646 541 let has_default = if let Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) = &body.schema 647 542 { 648 648 - use crate::codegen::structs::{ 649 649 - all_required_are_defaultable_strings, count_required_fields, 650 650 - }; 651 651 - let required_count = count_required_fields(obj); 652 652 - required_count == 0 || all_required_are_defaultable_strings(obj) 543 543 + super::builder_heuristics::should_generate_builder(&struct_name, obj).has_default 653 544 } else { 654 545 false 655 546 }; ··· 688 579 }; 689 580 690 581 // Generate union types if schema is an Object 691 691 - let mut unions = Vec::new(); 692 692 - if let Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) = &body.schema { 693 693 - for (field_name, field_type) in &obj.properties { 694 694 - match field_type { 695 695 - LexObjectProperty::Union(union) => { 696 696 - // Skip single-variant unions unless they're self-referential 697 697 - if union.refs.len() > 1 698 698 - || self.is_self_referential_union(nsid, &struct_name, union) 699 699 - { 700 700 - let union_name = 701 701 - self.generate_field_type_name(nsid, &struct_name, field_name, ""); 702 702 - let refs: Vec<_> = union.refs.iter().cloned().collect(); 703 703 - let union_def = 704 704 - self.generate_union(nsid, &union_name, &refs, None, union.closed)?; 705 705 - unions.push(union_def); 706 706 - } 707 707 - } 708 708 - LexObjectProperty::Array(array) => { 709 709 - if let LexArrayItem::Union(union) = &array.items { 710 710 - // Skip single-variant array unions 711 711 - if union.refs.len() > 1 { 712 712 - let union_name = self.generate_field_type_name( 713 713 - nsid, 714 714 - &struct_name, 715 715 - field_name, 716 716 - "Item", 717 717 - ); 718 718 - let refs: Vec<_> = union.refs.iter().cloned().collect(); 719 719 - let union_def = self.generate_union( 720 720 - nsid, 721 721 - &union_name, 722 722 - &refs, 723 723 - None, 724 724 - union.closed, 725 725 - )?; 726 726 - unions.push(union_def); 727 727 - } 728 728 - } 729 729 - } 730 730 - _ => {} 731 731 - } 732 732 - } 733 733 - } 582 582 + let unions = if let Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) = &body.schema { 583 583 + self.generate_nested_types(nsid, &struct_name, &obj.properties, false)? 584 584 + } else { 585 585 + Vec::new() 586 586 + }; 734 587 735 588 Ok(quote! { 736 589 #struct_def

+12 -12

crates/jacquard-lexicon/src/derive_impl/doc_to_tokens.rs

··· 795 795 ConstraintCheck::MaxLength { max } => quote! { 796 796 #[allow(unused_comparisons)] 797 797 if #len_expr > #max { 798 798 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 799 799 - field: #field_name_literal, 798 798 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 799 799 + path: ::jacquard_lexicon::validation::ValidationPath::from_field(#field_name_literal), 800 800 max: #max, 801 801 actual: #len_expr, 802 802 }); ··· 805 805 ConstraintCheck::MinLength { min } => quote! { 806 806 #[allow(unused_comparisons)] 807 807 if #len_expr < #min { 808 808 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 809 809 - field: #field_name_literal, 808 808 + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { 809 809 + path: ::jacquard_lexicon::validation::ValidationPath::from_field(#field_name_literal), 810 810 min: #min, 811 811 actual: #len_expr, 812 812 }); ··· 819 819 true 820 820 ).count(); 821 821 if count > #max { 822 822 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 823 823 - field: #field_name_literal, 822 822 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { 823 823 + path: ::jacquard_lexicon::validation::ValidationPath::from_field(#field_name_literal), 824 824 max: #max, 825 825 actual: count, 826 826 }); ··· 834 834 true 835 835 ).count(); 836 836 if count < #min { 837 837 - return Err(::jacquard_lexicon::schema::ValidationError::MinGraphemes { 838 838 - field: #field_name_literal, 837 837 + return Err(::jacquard_lexicon::validation::ConstraintError::MinGraphemes { 838 838 + path: ::jacquard_lexicon::validation::ValidationPath::from_field(#field_name_literal), 839 839 min: #min, 840 840 actual: count, 841 841 }); ··· 844 844 }, 845 845 ConstraintCheck::Maximum { max } => quote! { 846 846 if *value > #max { 847 847 - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 848 848 - field: #field_name_literal, 847 847 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 848 848 + path: ::jacquard_lexicon::validation::ValidationPath::from_field(#field_name_literal), 849 849 max: #max, 850 850 actual: *value, 851 851 }); ··· 853 853 }, 854 854 ConstraintCheck::Minimum { min } => quote! { 855 855 if *value < #min { 856 856 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 857 857 - field: #field_name_literal, 856 856 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 857 857 + path: ::jacquard_lexicon::validation::ValidationPath::from_field(#field_name_literal), 858 858 min: #min, 859 859 actual: *value, 860 860 });

+2 -2

crates/jacquard-lexicon/src/derive_impl/lexicon_schema.rs

··· 96 96 #doc_tokens 97 97 } 98 98 99 99 - fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 99 99 + fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 100 100 #validation_tokens 101 101 } 102 102 } ··· 150 150 #doc_tokens 151 151 } 152 152 153 153 - fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 153 153 + fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 154 154 Ok(()) 155 155 } 156 156 }

+8 -63

crates/jacquard-lexicon/src/schema.rs

··· 122 122 /// 123 123 /// Checks runtime constraints like `max_length`, `max_graphemes`, `minimum`, etc. 124 124 /// Returns `Ok(())` if valid, `Err` with details if invalid. 125 125 - fn validate(&self) -> Result<(), ValidationError> { 125 125 + fn validate(&self) -> Result<(), crate::validation::ConstraintError> { 126 126 // Default impl: no constraints to check 127 127 Ok(()) 128 128 } 129 129 - } 130 130 - 131 131 - /// Error type for validation failures 132 132 - #[derive(Debug, Clone, thiserror::Error, miette::Diagnostic)] 133 133 - pub enum ValidationError { 134 134 - #[error("field `{field}` exceeds maximum length: {actual} > {max}")] 135 135 - MaxLength { 136 136 - field: &'static str, 137 137 - max: usize, 138 138 - actual: usize, 139 139 - }, 140 140 - 141 141 - #[error("field `{field}` exceeds maximum grapheme count: {actual} > {max}")] 142 142 - MaxGraphemes { 143 143 - field: &'static str, 144 144 - max: usize, 145 145 - actual: usize, 146 146 - }, 147 147 - 148 148 - #[error("field `{field}` below minimum length: {actual} < {min}")] 149 149 - MinLength { 150 150 - field: &'static str, 151 151 - min: usize, 152 152 - actual: usize, 153 153 - }, 154 154 - 155 155 - #[error("field `{field}` below minimum grapheme count: {actual} < {min}")] 156 156 - MinGraphemes { 157 157 - field: &'static str, 158 158 - min: usize, 159 159 - actual: usize, 160 160 - }, 161 161 - 162 162 - #[error("field `{field}` value {actual} exceeds maximum: {max}")] 163 163 - Maximum { 164 164 - field: &'static str, 165 165 - max: i64, 166 166 - actual: i64, 167 167 - }, 168 168 - 169 169 - #[error("field `{field}` value {actual} below minimum: {min}")] 170 170 - Minimum { 171 171 - field: &'static str, 172 172 - min: i64, 173 173 - actual: i64, 174 174 - }, 175 175 - 176 176 - #[error("field `{field}` has invalid value: {message}")] 177 177 - InvalidValue { 178 178 - field: &'static str, 179 179 - message: String, 180 180 - }, 181 181 - 182 182 - #[error("multiple validation errors: {0:?}")] 183 183 - Multiple(Vec<ValidationError>), 184 129 } 185 130 186 131 /// Registry entry for schema discovery via inventory ··· 284 229 285 230 #[cfg(test)] 286 231 mod tests { 287 287 - use super::*; 232 232 + use crate::validation::{ConstraintError, ValidationPath}; 288 233 289 234 #[test] 290 235 fn test_validation_max_length() { 291 291 - let err = ValidationError::MaxLength { 292 292 - field: "text", 236 236 + let err = ConstraintError::MaxLength { 237 237 + path: ValidationPath::from_field("text"), 293 238 max: 100, 294 239 actual: 150, 295 240 }; 296 296 - assert!(err.to_string().contains("exceeds maximum length")); 241 241 + assert!(err.to_string().contains("exceeds max length")); 297 242 } 298 243 299 244 #[test] 300 245 fn test_validation_max_graphemes() { 301 301 - let err = ValidationError::MaxGraphemes { 302 302 - field: "text", 246 246 + let err = ConstraintError::MaxGraphemes { 247 247 + path: ValidationPath::from_field("text"), 303 248 max: 50, 304 249 actual: 75, 305 250 }; 306 306 - assert!(err.to_string().contains("exceeds maximum grapheme count")); 251 251 + assert!(err.to_string().contains("exceeds max graphemes")); 307 252 } 308 253 }

+7

crates/jacquard-lexicon/src/validation.rs

··· 47 47 } 48 48 } 49 49 50 50 + /// Create a path with a single field segment 51 51 + pub fn from_field(name: &str) -> Self { 52 52 + let mut path = Self::new(); 53 53 + path.push_field(name); 54 54 + path 55 55 + } 56 56 + 50 57 /// Add a field segment to the path 51 58 pub fn push_field(&mut self, name: &str) { 52 59 self.segments.push(PathSegment::Field(name.into()));

+6 -5

crates/jacquard-lexicon/tests/schema_tests.rs

··· 4 4 LexObject, LexObjectProperty, LexRecord, LexRecordRecord, LexString, LexStringFormat, 5 5 LexUserType, Lexicon, LexiconDoc, 6 6 }; 7 7 - use jacquard_lexicon::schema::{LexiconSchema, ValidationError}; 7 7 + use jacquard_lexicon::schema::LexiconSchema; 8 8 + use jacquard_lexicon::validation::{ConstraintError, ValidationPath}; 8 9 use std::collections::BTreeMap; 9 10 10 11 // Simple test type ··· 80 81 } 81 82 } 82 83 83 83 - fn validate(&self) -> Result<(), ValidationError> { 84 84 + fn validate(&self) -> Result<(), ConstraintError> { 84 85 // Check text length 85 86 if self.text.len() > 1000 { 86 86 - return Err(ValidationError::MaxLength { 87 87 - field: "text", 87 87 + return Err(ConstraintError::MaxLength { 88 88 + path: ValidationPath::from_field("text"), 88 89 max: 1000, 89 90 actual: self.text.len(), 90 91 }); ··· 122 123 assert!(result.is_err()); 123 124 124 125 let err = result.unwrap_err(); 125 125 - assert!(matches!(err, ValidationError::MaxLength { .. })); 126 126 + assert!(matches!(err, ConstraintError::MaxLength { .. })); 126 127 } 127 128 128 129 #[test]

+2 -2

justfile

··· 21 21 cargo run -p jacquard-lexgen --bin lex-fetch -- -v 22 22 23 23 generate-api: 24 24 - cargo run -p jacquard-lexgen --bin jacquard-codegen -- -i crates/jacquard-api/lexicons -o crates/jacquard-api/src -r crate 24 24 + cargo run -p jacquard-lexgen --bin jacquard-codegen -- -i crates/jacquard-api/lexicons -o crates/jacquard-api/src 25 25 26 26 lex-gen *ARGS: 27 27 cargo run -p jacquard-lexgen --bin lex-fetch -- {{ARGS}} ··· 30 30 cargo run -p jacquard-lexgen --bin lex-fetch -- --no-codegen {{ARGS}} 31 31 32 32 codegen *ARGS: 33 33 - cargo run -p jacquard-lexgen --bin jacquard-codegen -- -r crate {{ARGS}} 33 33 + cargo run -p jacquard-lexgen --bin jacquard-codegen -- {{ARGS}} 34 34 35 35 # Package binaries for distribution (creates tar.xz archives) 36 36 package-binaries: