+5 -5

Cargo.lock

reviewed

··· 2290 2290 [[package]] 2291 2291 name = "jacquard-api" 2292 2292 version = "0.8.0" 2293 2293 - source = "git+https://tangled.org/@nonbinary.computer/jacquard#1f831994b95d87fe938d4e7b2213e44bbd18e2bd" 2293 2293 + source = "git+https://tangled.org/@nonbinary.computer/jacquard#ce69232384e5cbb1aedc93b50580c7a4c81dcb8b" 2294 2294 dependencies = [ 2295 2295 "bon", 2296 2296 "bytes", ··· 2382 2382 [[package]] 2383 2383 name = "jacquard-common" 2384 2384 version = "0.8.0" 2385 2385 - source = "git+https://tangled.org/@nonbinary.computer/jacquard#1f831994b95d87fe938d4e7b2213e44bbd18e2bd" 2385 2385 + source = "git+https://tangled.org/@nonbinary.computer/jacquard#ce69232384e5cbb1aedc93b50580c7a4c81dcb8b" 2386 2386 dependencies = [ 2387 2387 "base64 0.22.1", 2388 2388 "bon", ··· 2435 2435 [[package]] 2436 2436 name = "jacquard-derive" 2437 2437 version = "0.8.0" 2438 2438 - source = "git+https://tangled.org/@nonbinary.computer/jacquard#1f831994b95d87fe938d4e7b2213e44bbd18e2bd" 2438 2438 + source = "git+https://tangled.org/@nonbinary.computer/jacquard#ce69232384e5cbb1aedc93b50580c7a4c81dcb8b" 2439 2439 dependencies = [ 2440 2440 "heck 0.5.0", 2441 2441 "jacquard-lexicon 0.8.0 (git+https://tangled.org/@nonbinary.computer/jacquard)", ··· 2472 2472 [[package]] 2473 2473 name = "jacquard-identity" 2474 2474 version = "0.8.0" 2475 2475 - source = "git+https://tangled.org/@nonbinary.computer/jacquard#1f831994b95d87fe938d4e7b2213e44bbd18e2bd" 2475 2475 + source = "git+https://tangled.org/@nonbinary.computer/jacquard#ce69232384e5cbb1aedc93b50580c7a4c81dcb8b" 2476 2476 dependencies = [ 2477 2477 "bon", 2478 2478 "bytes", ··· 2546 2546 [[package]] 2547 2547 name = "jacquard-lexicon" 2548 2548 version = "0.8.0" 2549 2549 - source = "git+https://tangled.org/@nonbinary.computer/jacquard#1f831994b95d87fe938d4e7b2213e44bbd18e2bd" 2549 2549 + source = "git+https://tangled.org/@nonbinary.computer/jacquard#ce69232384e5cbb1aedc93b50580c7a4c81dcb8b" 2550 2550 dependencies = [ 2551 2551 "glob", 2552 2552 "heck 0.5.0",

+263

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

reviewed

··· 3837 3837 fn validate( 3838 3838 &self, 3839 3839 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3840 3840 + { 3841 3841 + let value = &self.guide; 3842 3842 + if value.len() > 100usize { 3843 3843 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3844 3844 + field: "guide", 3845 3845 + max: 100usize, 3846 3846 + actual: value.len(), 3847 3847 + }); 3848 3848 + } 3849 3849 + } 3840 3850 Ok(()) 3841 3851 } 3842 3852 } ··· 5762 5772 fn validate( 5763 5773 &self, 5764 5774 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5775 5775 + if let Some(ref value) = self.nuxs { 5776 5776 + if value.len() > 100usize { 5777 5777 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 5778 5778 + field: "nuxs", 5779 5779 + max: 100usize, 5780 5780 + actual: value.len(), 5781 5781 + }); 5782 5782 + } 5783 5783 + } 5784 5784 + if let Some(ref value) = self.queued_nudges { 5785 5785 + if value.len() > 1000usize { 5786 5786 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 5787 5787 + field: "queued_nudges", 5788 5788 + max: 1000usize, 5789 5789 + actual: value.len(), 5790 5790 + }); 5791 5791 + } 5792 5792 + } 5765 5793 Ok(()) 5766 5794 } 5767 5795 } ··· 13438 13466 fn validate( 13439 13467 &self, 13440 13468 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 13469 13469 + { 13470 13470 + let value = &self.tags; 13471 13471 + if value.len() > 100usize { 13472 13472 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 13473 13473 + field: "tags", 13474 13474 + max: 100usize, 13475 13475 + actual: value.len(), 13476 13476 + }); 13477 13477 + } 13478 13478 + } 13441 13479 Ok(()) 13442 13480 } 13443 13481 } ··· 15353 15391 fn validate( 15354 15392 &self, 15355 15393 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 15394 15394 + { 15395 15395 + let value = &self.followers; 15396 15396 + if value.len() > 5usize { 15397 15397 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 15398 15398 + field: "followers", 15399 15399 + max: 5usize, 15400 15400 + actual: value.len(), 15401 15401 + }); 15402 15402 + } 15403 15403 + } 15404 15404 + { 15405 15405 + let value = &self.followers; 15406 15406 + if value.len() < 0usize { 15407 15407 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 15408 15408 + field: "followers", 15409 15409 + min: 0usize, 15410 15410 + actual: value.len(), 15411 15411 + }); 15412 15412 + } 15413 15413 + } 15356 15414 Ok(()) 15357 15415 } 15358 15416 } ··· 21111 21169 fn validate( 21112 21170 &self, 21113 21171 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 21172 21172 + { 21173 21173 + let value = &self.value; 21174 21174 + if value.len() > 10000usize { 21175 21175 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 21176 21176 + field: "value", 21177 21177 + max: 10000usize, 21178 21178 + actual: value.len(), 21179 21179 + }); 21180 21180 + } 21181 21181 + } 21182 21182 + { 21183 21183 + let value = &self.value; 21184 21184 + { 21185 21185 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 21186 21186 + value.as_ref(), 21187 21187 + true, 21188 21188 + ) 21189 21189 + .count(); 21190 21190 + if count > 1000usize { 21191 21191 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 21192 21192 + field: "value", 21193 21193 + max: 1000usize, 21194 21194 + actual: count, 21195 21195 + }); 21196 21196 + } 21197 21197 + } 21198 21198 + } 21114 21199 Ok(()) 21115 21200 } 21116 21201 } ··· 25026 25111 fn validate( 25027 25112 &self, 25028 25113 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 25114 25114 + if let Some(ref value) = self.data { 25115 25115 + if value.len() > 3000usize { 25116 25116 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 25117 25117 + field: "data", 25118 25118 + max: 3000usize, 25119 25119 + actual: value.len(), 25120 25120 + }); 25121 25121 + } 25122 25122 + } 25123 25123 + if let Some(ref value) = self.data { 25124 25124 + { 25125 25125 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 25126 25126 + value.as_ref(), 25127 25127 + true, 25128 25128 + ) 25129 25129 + .count(); 25130 25130 + if count > 300usize { 25131 25131 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 25132 25132 + field: "data", 25133 25133 + max: 300usize, 25134 25134 + actual: count, 25135 25135 + }); 25136 25136 + } 25137 25137 + } 25138 25138 + } 25139 25139 + { 25140 25140 + let value = &self.id; 25141 25141 + if value.len() > 100usize { 25142 25142 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 25143 25143 + field: "id", 25144 25144 + max: 100usize, 25145 25145 + actual: value.len(), 25146 25146 + }); 25147 25147 + } 25148 25148 + } 25029 25149 Ok(()) 25030 25150 } 25031 25151 } ··· 28887 29007 fn validate( 28888 29008 &self, 28889 29009 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 29010 29010 + if let Some(ref value) = self.postgate_embedding_rules { 29011 29011 + if value.len() > 5usize { 29012 29012 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 29013 29013 + field: "postgate_embedding_rules", 29014 29014 + max: 5usize, 29015 29015 + actual: value.len(), 29016 29016 + }); 29017 29017 + } 29018 29018 + } 29019 29019 + if let Some(ref value) = self.threadgate_allow_rules { 29020 29020 + if value.len() > 5usize { 29021 29021 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 29022 29022 + field: "threadgate_allow_rules", 29023 29023 + max: 5usize, 29024 29024 + actual: value.len(), 29025 29025 + }); 29026 29026 + } 29027 29027 + } 28890 29028 Ok(()) 28891 29029 } 28892 29030 } ··· 36644 36782 fn validate( 36645 36783 &self, 36646 36784 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 36785 36785 + if let Some(ref value) = self.description { 36786 36786 + if value.len() > 2560usize { 36787 36787 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 36788 36788 + field: "description", 36789 36789 + max: 2560usize, 36790 36790 + actual: value.len(), 36791 36791 + }); 36792 36792 + } 36793 36793 + } 36794 36794 + if let Some(ref value) = self.description { 36795 36795 + { 36796 36796 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 36797 36797 + value.as_ref(), 36798 36798 + true, 36799 36799 + ) 36800 36800 + .count(); 36801 36801 + if count > 256usize { 36802 36802 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 36803 36803 + field: "description", 36804 36804 + max: 256usize, 36805 36805 + actual: count, 36806 36806 + }); 36807 36807 + } 36808 36808 + } 36809 36809 + } 36810 36810 + if let Some(ref value) = self.display_name { 36811 36811 + if value.len() > 640usize { 36812 36812 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 36813 36813 + field: "display_name", 36814 36814 + max: 640usize, 36815 36815 + actual: value.len(), 36816 36816 + }); 36817 36817 + } 36818 36818 + } 36819 36819 + if let Some(ref value) = self.display_name { 36820 36820 + { 36821 36821 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 36822 36822 + value.as_ref(), 36823 36823 + true, 36824 36824 + ) 36825 36825 + .count(); 36826 36826 + if count > 64usize { 36827 36827 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 36828 36828 + field: "display_name", 36829 36829 + max: 64usize, 36830 36830 + actual: count, 36831 36831 + }); 36832 36832 + } 36833 36833 + } 36834 36834 + } 36647 36835 Ok(()) 36648 36836 } 36649 36837 } ··· 38594 38782 fn validate( 38595 38783 &self, 38596 38784 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 38785 38785 + if let Some(ref value) = self.display_name { 38786 38786 + if value.len() > 640usize { 38787 38787 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 38788 38788 + field: "display_name", 38789 38789 + max: 640usize, 38790 38790 + actual: value.len(), 38791 38791 + }); 38792 38792 + } 38793 38793 + } 38794 38794 + if let Some(ref value) = self.display_name { 38795 38795 + { 38796 38796 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 38797 38797 + value.as_ref(), 38798 38798 + true, 38799 38799 + ) 38800 38800 + .count(); 38801 38801 + if count > 64usize { 38802 38802 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 38803 38803 + field: "display_name", 38804 38804 + max: 64usize, 38805 38805 + actual: count, 38806 38806 + }); 38807 38807 + } 38808 38808 + } 38809 38809 + } 38597 38810 Ok(()) 38598 38811 } 38599 38812 } ··· 40578 40791 fn validate( 40579 40792 &self, 40580 40793 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 40794 40794 + if let Some(ref value) = self.description { 40795 40795 + if value.len() > 2560usize { 40796 40796 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 40797 40797 + field: "description", 40798 40798 + max: 2560usize, 40799 40799 + actual: value.len(), 40800 40800 + }); 40801 40801 + } 40802 40802 + } 40803 40803 + if let Some(ref value) = self.description { 40804 40804 + { 40805 40805 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 40806 40806 + value.as_ref(), 40807 40807 + true, 40808 40808 + ) 40809 40809 + .count(); 40810 40810 + if count > 256usize { 40811 40811 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 40812 40812 + field: "description", 40813 40813 + max: 256usize, 40814 40814 + actual: count, 40815 40815 + }); 40816 40816 + } 40817 40817 + } 40818 40818 + } 40819 40819 + if let Some(ref value) = self.display_name { 40820 40820 + if value.len() > 640usize { 40821 40821 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 40822 40822 + field: "display_name", 40823 40823 + max: 640usize, 40824 40824 + actual: value.len(), 40825 40825 + }); 40826 40826 + } 40827 40827 + } 40828 40828 + if let Some(ref value) = self.display_name { 40829 40829 + { 40830 40830 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 40831 40831 + value.as_ref(), 40832 40832 + true, 40833 40833 + ) 40834 40834 + .count(); 40835 40835 + if count > 64usize { 40836 40836 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 40837 40837 + field: "display_name", 40838 40838 + max: 64usize, 40839 40839 + actual: count, 40840 40840 + }); 40841 40841 + } 40842 40842 + } 40843 40843 + } 40581 40844 Ok(()) 40582 40845 } 40583 40846 }

+30 -14

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

reviewed

··· 15 15 PartialEq, 16 16 Eq, 17 17 jacquard_derive::IntoStatic, 18 18 - bon::Builder, 18 18 + bon::Builder 19 19 )] 20 20 #[serde(rename_all = "camelCase")] 21 21 pub struct Profile<'a> { ··· 44 44 #[serde(skip_serializing_if = "std::option::Option::is_none")] 45 45 #[builder(into)] 46 46 #[serde(borrow)] 47 47 - pub joined_via_starter_pack: Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>, 47 47 + pub joined_via_starter_pack: Option< 48 48 + crate::com_atproto::repo::strong_ref::StrongRef<'a>, 49 49 + >, 48 50 /// Self-label values, specific to the Bluesky application, on the overall account. 49 51 #[serde(skip_serializing_if = "std::option::Option::is_none")] 50 52 #[builder(into)] ··· 80 82 81 83 /// Typed wrapper for GetRecord response with this collection's record type. 82 84 #[derive( 83 83 - serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic, 85 85 + serde::Serialize, 86 86 + serde::Deserialize, 87 87 + Debug, 88 88 + Clone, 89 89 + PartialEq, 90 90 + Eq, 91 91 + jacquard_derive::IntoStatic 84 92 )] 85 93 #[serde(rename_all = "camelCase")] 86 94 pub struct ProfileGetRecordOutput<'a> { ··· 267 275 }, 268 276 } 269 277 } 270 270 - fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 278 278 + fn validate( 279 279 + &self, 280 280 + ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 271 281 if let Some(ref value) = self.description { 272 282 if value.len() > 2560usize { 273 283 return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { ··· 279 289 } 280 290 if let Some(ref value) = self.description { 281 291 { 282 282 - let count = 283 283 - ::unicode_segmentation::UnicodeSegmentation::graphemes(value.as_ref(), true) 284 284 - .count(); 292 292 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 293 293 + value.as_ref(), 294 294 + true, 295 295 + ) 296 296 + .count(); 285 297 if count > 256usize { 286 298 return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 287 299 field: "description", ··· 302 314 } 303 315 if let Some(ref value) = self.display_name { 304 316 { 305 305 - let count = 306 306 - ::unicode_segmentation::UnicodeSegmentation::graphemes(value.as_ref(), true) 307 307 - .count(); 317 317 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 318 318 + value.as_ref(), 319 319 + true, 320 320 + ) 321 321 + .count(); 308 322 if count > 64usize { 309 323 return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 310 324 field: "display_name", ··· 325 339 } 326 340 if let Some(ref value) = self.pronouns { 327 341 { 328 328 - let count = 329 329 - ::unicode_segmentation::UnicodeSegmentation::graphemes(value.as_ref(), true) 330 330 - .count(); 342 342 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 343 343 + value.as_ref(), 344 344 + true, 345 345 + ) 346 346 + .count(); 331 347 if count > 20usize { 332 348 return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 333 349 field: "pronouns", ··· 339 355 } 340 356 Ok(()) 341 357 } 342 342 - } 358 358 + }

+20

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

reviewed

··· 84 84 fn validate( 85 85 &self, 86 86 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 87 87 + { 88 88 + let value = &self.height; 89 89 + if *value < 1i64 { 90 90 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 91 91 + field: "height", 92 92 + min: 1i64, 93 93 + actual: *value, 94 94 + }); 95 95 + } 96 96 + } 97 97 + { 98 98 + let value = &self.width; 99 99 + if *value < 1i64 { 100 100 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 101 101 + field: "width", 102 102 + min: 1i64, 103 103 + actual: *value, 104 104 + }); 105 105 + } 106 106 + } 87 107 Ok(()) 88 108 } 89 109 }

-20

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

reviewed

··· 211 211 fn validate( 212 212 &self, 213 213 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 214 214 - { 215 215 - let value = &self.images; 216 216 - if value.len() > 4usize { 217 217 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 218 218 - field: "images", 219 219 - max: 4usize, 220 220 - actual: value.len(), 221 221 - }); 222 222 - } 223 223 - } 224 214 Ok(()) 225 215 } 226 216 } ··· 859 849 fn validate( 860 850 &self, 861 851 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 862 862 - { 863 863 - let value = &self.images; 864 864 - if value.len() > 4usize { 865 865 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 866 866 - field: "images", 867 867 - max: 4usize, 868 868 - actual: value.len(), 869 869 - }); 870 870 - } 871 871 - } 872 852 Ok(()) 873 853 } 874 854 }

-43

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

reviewed

··· 220 220 fn validate( 221 221 &self, 222 222 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 223 223 - if let Some(ref value) = self.alt { 224 224 - if value.len() > 10000usize { 225 225 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 226 226 - field: "alt", 227 227 - max: 10000usize, 228 228 - actual: value.len(), 229 229 - }); 230 230 - } 231 231 - } 232 232 - if let Some(ref value) = self.alt { 233 233 - { 234 234 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 235 235 - value.as_ref(), 236 236 - true, 237 237 - ) 238 238 - .count(); 239 239 - if count > 1000usize { 240 240 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 241 241 - field: "alt", 242 242 - max: 1000usize, 243 243 - actual: count, 244 244 - }); 245 245 - } 246 246 - } 247 247 - } 248 248 - if let Some(ref value) = self.captions { 249 249 - if value.len() > 20usize { 250 250 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 251 251 - field: "captions", 252 252 - max: 20usize, 253 253 - actual: value.len(), 254 254 - }); 255 255 - } 256 256 - } 257 223 Ok(()) 258 224 } 259 225 } ··· 775 741 actual: count, 776 742 }); 777 743 } 778 778 - } 779 779 - } 780 780 - if let Some(ref value) = self.captions { 781 781 - if value.len() > 20usize { 782 782 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 783 783 - field: "captions", 784 784 - max: 20usize, 785 785 - actual: value.len(), 786 786 - }); 787 744 } 788 745 } 789 746 Ok(())

+79

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

reviewed

··· 3679 3679 fn validate( 3680 3680 &self, 3681 3681 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3682 3682 + if let Some(ref value) = self.feed_context { 3683 3683 + if value.len() > 2000usize { 3684 3684 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3685 3685 + field: "feed_context", 3686 3686 + max: 2000usize, 3687 3687 + actual: value.len(), 3688 3688 + }); 3689 3689 + } 3690 3690 + } 3691 3691 + if let Some(ref value) = self.req_id { 3692 3692 + if value.len() > 100usize { 3693 3693 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3694 3694 + field: "req_id", 3695 3695 + max: 100usize, 3696 3696 + actual: value.len(), 3697 3697 + }); 3698 3698 + } 3699 3699 + } 3682 3700 Ok(()) 3683 3701 } 3684 3702 } ··· 4886 4904 fn validate( 4887 4905 &self, 4888 4906 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4907 4907 + if let Some(ref value) = self.description { 4908 4908 + if value.len() > 3000usize { 4909 4909 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 4910 4910 + field: "description", 4911 4911 + max: 3000usize, 4912 4912 + actual: value.len(), 4913 4913 + }); 4914 4914 + } 4915 4915 + } 4916 4916 + if let Some(ref value) = self.description { 4917 4917 + { 4918 4918 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 4919 4919 + value.as_ref(), 4920 4920 + true, 4921 4921 + ) 4922 4922 + .count(); 4923 4923 + if count > 300usize { 4924 4924 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 4925 4925 + field: "description", 4926 4926 + max: 300usize, 4927 4927 + actual: count, 4928 4928 + }); 4929 4929 + } 4930 4930 + } 4931 4931 + } 4932 4932 + if let Some(ref value) = self.like_count { 4933 4933 + if *value < 0i64 { 4934 4934 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 4935 4935 + field: "like_count", 4936 4936 + min: 0i64, 4937 4937 + actual: *value, 4938 4938 + }); 4939 4939 + } 4940 4940 + } 4889 4941 Ok(()) 4890 4942 } 4891 4943 } ··· 7233 7285 fn validate( 7234 7286 &self, 7235 7287 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 7288 7288 + if let Some(ref value) = self.feed_context { 7289 7289 + if value.len() > 2000usize { 7290 7290 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 7291 7291 + field: "feed_context", 7292 7292 + max: 2000usize, 7293 7293 + actual: value.len(), 7294 7294 + }); 7295 7295 + } 7296 7296 + } 7297 7297 + if let Some(ref value) = self.req_id { 7298 7298 + if value.len() > 100usize { 7299 7299 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 7300 7300 + field: "req_id", 7301 7301 + max: 100usize, 7302 7302 + actual: value.len(), 7303 7303 + }); 7304 7304 + } 7305 7305 + } 7236 7306 Ok(()) 7237 7307 } 7238 7308 } ··· 14525 14595 fn validate( 14526 14596 &self, 14527 14597 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 14598 14598 + if let Some(ref value) = self.feed_context { 14599 14599 + if value.len() > 2000usize { 14600 14600 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 14601 14601 + field: "feed_context", 14602 14602 + max: 2000usize, 14603 14603 + actual: value.len(), 14604 14604 + }); 14605 14605 + } 14606 14606 + } 14528 14607 Ok(()) 14529 14608 } 14530 14609 }

+13 -128

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

reviewed

··· 291 291 fn validate( 292 292 &self, 293 293 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 294 294 - if let Some(ref value) = self.langs { 295 295 - if value.len() > 3usize { 296 296 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 297 297 - field: "langs", 298 298 - max: 3usize, 299 299 - actual: value.len(), 300 300 - }); 301 301 - } 302 302 - } 303 303 - if let Some(ref value) = self.tags { 304 304 - if value.len() > 8usize { 305 305 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 306 306 - field: "tags", 307 307 - max: 8usize, 308 308 - actual: value.len(), 309 309 - }); 310 310 - } 311 311 - } 312 312 - { 313 313 - let value = &self.text; 314 314 - if value.len() > 3000usize { 315 315 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 316 316 - field: "text", 317 317 - max: 3000usize, 318 318 - actual: value.len(), 319 319 - }); 320 320 - } 321 321 - } 322 322 - { 323 323 - let value = &self.text; 324 324 - { 325 325 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 326 326 - value.as_ref(), 327 327 - true, 328 328 - ) 329 329 - .count(); 330 330 - if count > 300usize { 331 331 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 332 332 - field: "text", 333 333 - max: 300usize, 334 334 - actual: count, 335 335 - }); 336 336 - } 337 337 - } 338 338 - } 339 294 Ok(()) 340 295 } 341 296 } ··· 1070 1025 fn validate( 1071 1026 &self, 1072 1027 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1073 1073 - if let Some(ref value) = self.langs { 1074 1074 - if value.len() > 3usize { 1075 1075 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1076 1076 - field: "langs", 1077 1077 - max: 3usize, 1078 1078 - actual: value.len(), 1079 1079 - }); 1080 1080 - } 1081 1081 - } 1082 1082 - if let Some(ref value) = self.tags { 1083 1083 - if value.len() > 8usize { 1084 1084 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1085 1085 - field: "tags", 1086 1086 - max: 8usize, 1087 1087 - actual: value.len(), 1088 1088 - }); 1089 1089 - } 1090 1090 - } 1091 1091 - { 1092 1092 - let value = &self.text; 1093 1093 - if value.len() > 3000usize { 1094 1094 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1095 1095 - field: "text", 1096 1096 - max: 3000usize, 1097 1097 - actual: value.len(), 1098 1098 - }); 1099 1099 - } 1100 1100 - } 1101 1101 - { 1102 1102 - let value = &self.text; 1103 1103 - { 1104 1104 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 1105 1105 - value.as_ref(), 1106 1106 - true, 1107 1107 - ) 1108 1108 - .count(); 1109 1109 - if count > 300usize { 1110 1110 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1111 1111 - field: "text", 1112 1112 - max: 300usize, 1113 1113 - actual: count, 1114 1114 - }); 1115 1115 - } 1116 1116 - } 1117 1117 - } 1118 1028 Ok(()) 1119 1029 } 1120 1030 } ··· 1398 1308 fn validate( 1399 1309 &self, 1400 1310 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1401 1401 - if let Some(ref value) = self.langs { 1402 1402 - if value.len() > 3usize { 1403 1403 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1404 1404 - field: "langs", 1405 1405 - max: 3usize, 1406 1406 - actual: value.len(), 1407 1407 - }); 1408 1408 - } 1409 1409 - } 1410 1410 - if let Some(ref value) = self.tags { 1411 1411 - if value.len() > 8usize { 1412 1412 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1413 1413 - field: "tags", 1414 1414 - max: 8usize, 1415 1415 - actual: value.len(), 1311 1311 + { 1312 1312 + let value = &self.end; 1313 1313 + if *value < 0i64 { 1314 1314 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1315 1315 + field: "end", 1316 1316 + min: 0i64, 1317 1317 + actual: *value, 1416 1318 }); 1417 1319 } 1418 1320 } 1419 1321 { 1420 1420 - let value = &self.text; 1421 1421 - if value.len() > 3000usize { 1422 1422 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1423 1423 - field: "text", 1424 1424 - max: 3000usize, 1425 1425 - actual: value.len(), 1322 1322 + let value = &self.start; 1323 1323 + if *value < 0i64 { 1324 1324 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1325 1325 + field: "start", 1326 1326 + min: 0i64, 1327 1327 + actual: *value, 1426 1328 }); 1427 1427 - } 1428 1428 - } 1429 1429 - { 1430 1430 - let value = &self.text; 1431 1431 - { 1432 1432 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 1433 1433 - value.as_ref(), 1434 1434 - true, 1435 1435 - ) 1436 1436 - .count(); 1437 1437 - if count > 300usize { 1438 1438 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1439 1439 - field: "text", 1440 1440 - max: 300usize, 1441 1441 - actual: count, 1442 1442 - }); 1443 1443 - } 1444 1329 } 1445 1330 } 1446 1331 Ok(())

-18

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

reviewed

··· 137 137 fn validate( 138 138 &self, 139 139 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 140 140 - if let Some(ref value) = self.detached_embedding_uris { 141 141 - if value.len() > 50usize { 142 142 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 143 143 - field: "detached_embedding_uris", 144 144 - max: 50usize, 145 145 - actual: value.len(), 146 146 - }); 147 147 - } 148 148 - } 149 149 - if let Some(ref value) = self.embedding_rules { 150 150 - if value.len() > 5usize { 151 151 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 152 152 - field: "embedding_rules", 153 153 - max: 5usize, 154 154 - actual: value.len(), 155 155 - }); 156 156 - } 157 157 - } 158 140 Ok(()) 159 141 } 160 142 }

-72

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

reviewed

··· 193 193 fn validate( 194 194 &self, 195 195 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 196 196 - if let Some(ref value) = self.allow { 197 197 - if value.len() > 5usize { 198 198 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 199 199 - field: "allow", 200 200 - max: 5usize, 201 201 - actual: value.len(), 202 202 - }); 203 203 - } 204 204 - } 205 205 - if let Some(ref value) = self.hidden_replies { 206 206 - if value.len() > 300usize { 207 207 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 208 208 - field: "hidden_replies", 209 209 - max: 300usize, 210 210 - actual: value.len(), 211 211 - }); 212 212 - } 213 213 - } 214 196 Ok(()) 215 197 } 216 198 } ··· 403 385 fn validate( 404 386 &self, 405 387 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 406 406 - if let Some(ref value) = self.allow { 407 407 - if value.len() > 5usize { 408 408 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 409 409 - field: "allow", 410 410 - max: 5usize, 411 411 - actual: value.len(), 412 412 - }); 413 413 - } 414 414 - } 415 415 - if let Some(ref value) = self.hidden_replies { 416 416 - if value.len() > 300usize { 417 417 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 418 418 - field: "hidden_replies", 419 419 - max: 300usize, 420 420 - actual: value.len(), 421 421 - }); 422 422 - } 423 423 - } 424 388 Ok(()) 425 389 } 426 390 } ··· 617 581 fn validate( 618 582 &self, 619 583 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 620 620 - if let Some(ref value) = self.allow { 621 621 - if value.len() > 5usize { 622 622 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 623 623 - field: "allow", 624 624 - max: 5usize, 625 625 - actual: value.len(), 626 626 - }); 627 627 - } 628 628 - } 629 629 - if let Some(ref value) = self.hidden_replies { 630 630 - if value.len() > 300usize { 631 631 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 632 632 - field: "hidden_replies", 633 633 - max: 300usize, 634 634 - actual: value.len(), 635 635 - }); 636 636 - } 637 637 - } 638 584 Ok(()) 639 585 } 640 586 } ··· 1137 1083 fn validate( 1138 1084 &self, 1139 1085 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1140 1140 - if let Some(ref value) = self.allow { 1141 1141 - if value.len() > 5usize { 1142 1142 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1143 1143 - field: "allow", 1144 1144 - max: 5usize, 1145 1145 - actual: value.len(), 1146 1146 - }); 1147 1147 - } 1148 1148 - } 1149 1149 - if let Some(ref value) = self.hidden_replies { 1150 1150 - if value.len() > 300usize { 1151 1151 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1152 1152 - field: "hidden_replies", 1153 1153 - max: 300usize, 1154 1154 - actual: value.len(), 1155 1155 - }); 1156 1156 - } 1157 1157 - } 1158 1086 Ok(()) 1159 1087 } 1160 1088 }

+146

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

reviewed

··· 1772 1772 fn validate( 1773 1773 &self, 1774 1774 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1775 1775 + if let Some(ref value) = self.description { 1776 1776 + if value.len() > 3000usize { 1777 1777 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1778 1778 + field: "description", 1779 1779 + max: 3000usize, 1780 1780 + actual: value.len(), 1781 1781 + }); 1782 1782 + } 1783 1783 + } 1784 1784 + if let Some(ref value) = self.description { 1785 1785 + { 1786 1786 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 1787 1787 + value.as_ref(), 1788 1788 + true, 1789 1789 + ) 1790 1790 + .count(); 1791 1791 + if count > 300usize { 1792 1792 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1793 1793 + field: "description", 1794 1794 + max: 300usize, 1795 1795 + actual: count, 1796 1796 + }); 1797 1797 + } 1798 1798 + } 1799 1799 + } 1800 1800 + if let Some(ref value) = self.list_item_count { 1801 1801 + if *value < 0i64 { 1802 1802 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1803 1803 + field: "list_item_count", 1804 1804 + min: 0i64, 1805 1805 + actual: *value, 1806 1806 + }); 1807 1807 + } 1808 1808 + } 1809 1809 + { 1810 1810 + let value = &self.name; 1811 1811 + if value.len() > 64usize { 1812 1812 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1813 1813 + field: "name", 1814 1814 + max: 64usize, 1815 1815 + actual: value.len(), 1816 1816 + }); 1817 1817 + } 1818 1818 + } 1819 1819 + { 1820 1820 + let value = &self.name; 1821 1821 + if value.len() < 1usize { 1822 1822 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 1823 1823 + field: "name", 1824 1824 + min: 1usize, 1825 1825 + actual: value.len(), 1826 1826 + }); 1827 1827 + } 1828 1828 + } 1775 1829 Ok(()) 1776 1830 } 1777 1831 } ··· 2598 2652 fn validate( 2599 2653 &self, 2600 2654 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2655 2655 + if let Some(ref value) = self.list_item_count { 2656 2656 + if *value < 0i64 { 2657 2657 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 2658 2658 + field: "list_item_count", 2659 2659 + min: 0i64, 2660 2660 + actual: *value, 2661 2661 + }); 2662 2662 + } 2663 2663 + } 2664 2664 + { 2665 2665 + let value = &self.name; 2666 2666 + if value.len() > 64usize { 2667 2667 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2668 2668 + field: "name", 2669 2669 + max: 64usize, 2670 2670 + actual: value.len(), 2671 2671 + }); 2672 2672 + } 2673 2673 + } 2674 2674 + { 2675 2675 + let value = &self.name; 2676 2676 + if value.len() < 1usize { 2677 2677 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 2678 2678 + field: "name", 2679 2679 + min: 1usize, 2680 2680 + actual: value.len(), 2681 2681 + }); 2682 2682 + } 2683 2683 + } 2601 2684 Ok(()) 2602 2685 } 2603 2686 } ··· 5883 5966 fn validate( 5884 5967 &self, 5885 5968 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5969 5969 + if let Some(ref value) = self.feeds { 5970 5970 + if value.len() > 3usize { 5971 5971 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 5972 5972 + field: "feeds", 5973 5973 + max: 3usize, 5974 5974 + actual: value.len(), 5975 5975 + }); 5976 5976 + } 5977 5977 + } 5978 5978 + if let Some(ref value) = self.joined_all_time_count { 5979 5979 + if *value < 0i64 { 5980 5980 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 5981 5981 + field: "joined_all_time_count", 5982 5982 + min: 0i64, 5983 5983 + actual: *value, 5984 5984 + }); 5985 5985 + } 5986 5986 + } 5987 5987 + if let Some(ref value) = self.joined_week_count { 5988 5988 + if *value < 0i64 { 5989 5989 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 5990 5990 + field: "joined_week_count", 5991 5991 + min: 0i64, 5992 5992 + actual: *value, 5993 5993 + }); 5994 5994 + } 5995 5995 + } 5996 5996 + if let Some(ref value) = self.list_items_sample { 5997 5997 + if value.len() > 12usize { 5998 5998 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 5999 5999 + field: "list_items_sample", 6000 6000 + max: 12usize, 6001 6001 + actual: value.len(), 6002 6002 + }); 6003 6003 + } 6004 6004 + } 5886 6005 Ok(()) 5887 6006 } 5888 6007 } ··· 6704 6823 fn validate( 6705 6824 &self, 6706 6825 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 6826 6826 + if let Some(ref value) = self.joined_all_time_count { 6827 6827 + if *value < 0i64 { 6828 6828 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 6829 6829 + field: "joined_all_time_count", 6830 6830 + min: 0i64, 6831 6831 + actual: *value, 6832 6832 + }); 6833 6833 + } 6834 6834 + } 6835 6835 + if let Some(ref value) = self.joined_week_count { 6836 6836 + if *value < 0i64 { 6837 6837 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 6838 6838 + field: "joined_week_count", 6839 6839 + min: 0i64, 6840 6840 + actual: *value, 6841 6841 + }); 6842 6842 + } 6843 6843 + } 6844 6844 + if let Some(ref value) = self.list_item_count { 6845 6845 + if *value < 0i64 { 6846 6846 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 6847 6847 + field: "list_item_count", 6848 6848 + min: 0i64, 6849 6849 + actual: *value, 6850 6850 + }); 6851 6851 + } 6852 6852 + } 6707 6853 Ok(()) 6708 6854 } 6709 6855 }

-71

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

reviewed

··· 178 178 fn validate( 179 179 &self, 180 180 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 181 181 - if let Some(ref value) = self.description { 182 182 - if value.len() > 3000usize { 183 183 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 184 184 - field: "description", 185 185 - max: 3000usize, 186 186 - actual: value.len(), 187 187 - }); 188 188 - } 189 189 - } 190 190 - if let Some(ref value) = self.description { 191 191 - { 192 192 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 193 193 - value.as_ref(), 194 194 - true, 195 195 - ) 196 196 - .count(); 197 197 - if count > 300usize { 198 198 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 199 199 - field: "description", 200 200 - max: 300usize, 201 201 - actual: count, 202 202 - }); 203 203 - } 204 204 - } 205 205 - } 206 206 - if let Some(ref value) = self.feeds { 207 207 - if value.len() > 3usize { 208 208 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 209 209 - field: "feeds", 210 210 - max: 3usize, 211 211 - actual: value.len(), 212 212 - }); 213 213 - } 214 214 - } 215 215 - { 216 216 - let value = &self.name; 217 217 - if value.len() > 500usize { 218 218 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 219 219 - field: "name", 220 220 - max: 500usize, 221 221 - actual: value.len(), 222 222 - }); 223 223 - } 224 224 - } 225 225 - { 226 226 - let value = &self.name; 227 227 - if value.len() < 1usize { 228 228 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 229 229 - field: "name", 230 230 - min: 1usize, 231 231 - actual: value.len(), 232 232 - }); 233 233 - } 234 234 - } 235 235 - { 236 236 - let value = &self.name; 237 237 - { 238 238 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 239 239 - value.as_ref(), 240 240 - true, 241 241 - ) 242 242 - .count(); 243 243 - if count > 50usize { 244 244 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 245 245 - field: "name", 246 246 - max: 50usize, 247 247 - actual: count, 248 248 - }); 249 249 - } 250 250 - } 251 251 - } 252 181 Ok(()) 253 182 } 254 183 }

+18

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

reviewed

··· 768 768 fn validate( 769 769 &self, 770 770 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 771 771 + if let Some(ref value) = self.like_count { 772 772 + if *value < 0i64 { 773 773 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 774 774 + field: "like_count", 775 775 + min: 0i64, 776 776 + actual: *value, 777 777 + }); 778 778 + } 779 779 + } 771 780 Ok(()) 772 781 } 773 782 } ··· 1171 1180 fn validate( 1172 1181 &self, 1173 1182 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1183 1183 + if let Some(ref value) = self.like_count { 1184 1184 + if *value < 0i64 { 1185 1185 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1186 1186 + field: "like_count", 1187 1187 + min: 0i64, 1188 1188 + actual: *value, 1189 1189 + }); 1190 1190 + } 1191 1191 + } 1174 1192 Ok(()) 1175 1193 } 1176 1194 }

+47

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

reviewed

··· 197 197 fn validate( 198 198 &self, 199 199 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 200 200 + { 201 201 + let value = &self.byte_end; 202 202 + if *value < 0i64 { 203 203 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 204 204 + field: "byte_end", 205 205 + min: 0i64, 206 206 + actual: *value, 207 207 + }); 208 208 + } 209 209 + } 210 210 + { 211 211 + let value = &self.byte_start; 212 212 + if *value < 0i64 { 213 213 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 214 214 + field: "byte_start", 215 215 + min: 0i64, 216 216 + actual: *value, 217 217 + }); 218 218 + } 219 219 + } 200 220 Ok(()) 201 221 } 202 222 } ··· 1004 1024 fn validate( 1005 1025 &self, 1006 1026 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1027 1027 + { 1028 1028 + let value = &self.tag; 1029 1029 + if value.len() > 640usize { 1030 1030 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1031 1031 + field: "tag", 1032 1032 + max: 640usize, 1033 1033 + actual: value.len(), 1034 1034 + }); 1035 1035 + } 1036 1036 + } 1037 1037 + { 1038 1038 + let value = &self.tag; 1039 1039 + { 1040 1040 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 1041 1041 + value.as_ref(), 1042 1042 + true, 1043 1043 + ) 1044 1044 + .count(); 1045 1045 + if count > 64usize { 1046 1046 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1047 1047 + field: "tag", 1048 1048 + max: 64usize, 1049 1049 + actual: count, 1050 1050 + }); 1051 1051 + } 1052 1052 + } 1053 1053 + } 1007 1054 Ok(()) 1008 1055 } 1009 1056 }

+18

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

reviewed

··· 180 180 fn validate( 181 181 &self, 182 182 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 183 183 + if let Some(ref value) = self.progress { 184 184 + if *value > 100i64 { 185 185 + return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 186 186 + field: "progress", 187 187 + max: 100i64, 188 188 + actual: *value, 189 189 + }); 190 190 + } 191 191 + } 192 192 + if let Some(ref value) = self.progress { 193 193 + if *value < 0i64 { 194 194 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 195 195 + field: "progress", 196 196 + min: 0i64, 197 197 + actual: *value, 198 198 + }); 199 199 + } 200 200 + } 183 201 Ok(()) 184 202 } 185 203 }

+36

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

reviewed

··· 863 863 fn validate( 864 864 &self, 865 865 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 866 866 + if let Some(ref value) = self.play_count { 867 867 + if *value < 0i64 { 868 868 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 869 869 + field: "play_count", 870 870 + min: 0i64, 871 871 + actual: *value, 872 872 + }); 873 873 + } 874 874 + } 875 875 + if let Some(ref value) = self.unique_listeners { 876 876 + if *value < 0i64 { 877 877 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 878 878 + field: "unique_listeners", 879 879 + min: 0i64, 880 880 + actual: *value, 881 881 + }); 882 882 + } 883 883 + } 866 884 Ok(()) 867 885 } 868 886 } ··· 1301 1319 fn validate( 1302 1320 &self, 1303 1321 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1322 1322 + if let Some(ref value) = self.play_count { 1323 1323 + if *value < 0i64 { 1324 1324 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1325 1325 + field: "play_count", 1326 1326 + min: 0i64, 1327 1327 + actual: *value, 1328 1328 + }); 1329 1329 + } 1330 1330 + } 1331 1331 + if let Some(ref value) = self.unique_listeners { 1332 1332 + if *value < 0i64 { 1333 1333 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1334 1334 + field: "unique_listeners", 1335 1335 + min: 0i64, 1336 1336 + actual: *value, 1337 1337 + }); 1338 1338 + } 1339 1339 + } 1304 1340 Ok(()) 1305 1341 } 1306 1342 }

+36

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

reviewed

··· 608 608 fn validate( 609 609 &self, 610 610 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 611 611 + if let Some(ref value) = self.play_count { 612 612 + if *value < 0i64 { 613 613 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 614 614 + field: "play_count", 615 615 + min: 0i64, 616 616 + actual: *value, 617 617 + }); 618 618 + } 619 619 + } 620 620 + if let Some(ref value) = self.unique_listeners { 621 621 + if *value < 0i64 { 622 622 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 623 623 + field: "unique_listeners", 624 624 + min: 0i64, 625 625 + actual: *value, 626 626 + }); 627 627 + } 628 628 + } 611 629 Ok(()) 612 630 } 613 631 } ··· 896 914 fn validate( 897 915 &self, 898 916 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 917 917 + if let Some(ref value) = self.play_count { 918 918 + if *value < 0i64 { 919 919 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 920 920 + field: "play_count", 921 921 + min: 0i64, 922 922 + actual: *value, 923 923 + }); 924 924 + } 925 925 + } 926 926 + if let Some(ref value) = self.unique_listeners { 927 927 + if *value < 0i64 { 928 928 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 929 929 + field: "unique_listeners", 930 930 + min: 0i64, 931 931 + actual: *value, 932 932 + }); 933 933 + } 934 934 + } 899 935 Ok(()) 900 936 } 901 937 }

+9

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

reviewed

··· 786 786 fn validate( 787 787 &self, 788 788 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 789 789 + if let Some(ref value) = self.track_count { 790 790 + if *value < 0i64 { 791 791 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 792 792 + field: "track_count", 793 793 + min: 0i64, 794 794 + actual: *value, 795 795 + }); 796 796 + } 797 797 + } 789 798 Ok(()) 790 799 } 791 800 }

+36

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

reviewed

··· 1321 1321 fn validate( 1322 1322 &self, 1323 1323 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1324 1324 + if let Some(ref value) = self.play_count { 1325 1325 + if *value < 0i64 { 1326 1326 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1327 1327 + field: "play_count", 1328 1328 + min: 0i64, 1329 1329 + actual: *value, 1330 1330 + }); 1331 1331 + } 1332 1332 + } 1333 1333 + if let Some(ref value) = self.unique_listeners { 1334 1334 + if *value < 0i64 { 1335 1335 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1336 1336 + field: "unique_listeners", 1337 1337 + min: 0i64, 1338 1338 + actual: *value, 1339 1339 + }); 1340 1340 + } 1341 1341 + } 1324 1342 Ok(()) 1325 1343 } 1326 1344 } ··· 1903 1921 fn validate( 1904 1922 &self, 1905 1923 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1924 1924 + if let Some(ref value) = self.play_count { 1925 1925 + if *value < 0i64 { 1926 1926 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1927 1927 + field: "play_count", 1928 1928 + min: 0i64, 1929 1929 + actual: *value, 1930 1930 + }); 1931 1931 + } 1932 1932 + } 1933 1933 + if let Some(ref value) = self.unique_listeners { 1934 1934 + if *value < 0i64 { 1935 1935 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1936 1936 + field: "unique_listeners", 1937 1937 + min: 0i64, 1938 1938 + actual: *value, 1939 1939 + }); 1940 1940 + } 1941 1941 + } 1906 1942 Ok(()) 1907 1943 } 1908 1944 }

+45 -4

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

reviewed

··· 453 453 fn validate( 454 454 &self, 455 455 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 456 456 - if let Some(ref value) = self.font { 457 457 - if value.len() > 100usize { 456 456 + { 457 457 + let value = &self.accent; 458 458 + if value.len() > 7usize { 459 459 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 460 460 + field: "accent", 461 461 + max: 7usize, 462 462 + actual: value.len(), 463 463 + }); 464 464 + } 465 465 + } 466 466 + { 467 467 + let value = &self.background; 468 468 + if value.len() > 7usize { 469 469 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 470 470 + field: "background", 471 471 + max: 7usize, 472 472 + actual: value.len(), 473 473 + }); 474 474 + } 475 475 + } 476 476 + { 477 477 + let value = &self.link; 478 478 + if value.len() > 7usize { 479 479 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 480 480 + field: "link", 481 481 + max: 7usize, 482 482 + actual: value.len(), 483 483 + }); 484 484 + } 485 485 + } 486 486 + { 487 487 + let value = &self.surface_hover; 488 488 + if value.len() > 7usize { 458 489 return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 459 459 - field: "font", 460 460 - max: 100usize, 490 490 + field: "surface_hover", 491 491 + max: 7usize, 492 492 + actual: value.len(), 493 493 + }); 494 494 + } 495 495 + } 496 496 + { 497 497 + let value = &self.text; 498 498 + if value.len() > 7usize { 499 499 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 500 500 + field: "text", 501 501 + max: 7usize, 461 502 actual: value.len(), 462 503 }); 463 504 }

+52 -9

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

reviewed

··· 241 241 fn validate( 242 242 &self, 243 243 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 244 244 + if let Some(ref value) = self.comment { 245 245 + if value.len() > 100000usize { 246 246 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 247 247 + field: "comment", 248 248 + max: 100000usize, 249 249 + actual: value.len(), 250 250 + }); 251 251 + } 252 252 + } 253 253 + if let Some(ref value) = self.comment { 254 254 + { 255 255 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 256 256 + value.as_ref(), 257 257 + true, 258 258 + ) 259 259 + .count(); 260 260 + if count > 10000usize { 261 261 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 262 262 + field: "comment", 263 263 + max: 10000usize, 264 264 + actual: count, 265 265 + }); 266 266 + } 267 267 + } 268 268 + } 244 269 { 245 245 - let value = &self.comments; 246 246 - if value.len() < 1usize { 247 247 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 248 248 - field: "comments", 249 249 - min: 1usize, 270 270 + let value = &self.lang; 271 271 + if value.len() > 6usize { 272 272 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 273 273 + field: "lang", 274 274 + max: 6usize, 250 275 actual: value.len(), 251 276 }); 252 277 } 253 278 } 254 254 - if let Some(ref value) = self.tags { 255 255 - if value.len() > 10usize { 279 279 + { 280 280 + let value = &self.title; 281 281 + if value.len() > 500usize { 256 282 return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 257 257 - field: "tags", 258 258 - max: 10usize, 283 283 + field: "title", 284 284 + max: 500usize, 259 285 actual: value.len(), 260 286 }); 287 287 + } 288 288 + } 289 289 + { 290 290 + let value = &self.title; 291 291 + { 292 292 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 293 293 + value.as_ref(), 294 294 + true, 295 295 + ) 296 296 + .count(); 297 297 + if count > 50usize { 298 298 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 299 299 + field: "title", 300 300 + max: 50usize, 301 301 + actual: count, 302 302 + }); 303 303 + } 261 304 } 262 305 } 263 306 Ok(())

+148

crates/jacquard-api/src/buzz_bookhive.rs

reviewed

··· 1288 1288 fn validate( 1289 1289 &self, 1290 1290 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1291 1291 + { 1292 1292 + let value = &self.comment; 1293 1293 + if value.len() > 100000usize { 1294 1294 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1295 1295 + field: "comment", 1296 1296 + max: 100000usize, 1297 1297 + actual: value.len(), 1298 1298 + }); 1299 1299 + } 1300 1300 + } 1301 1301 + { 1302 1302 + let value = &self.comment; 1303 1303 + { 1304 1304 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 1305 1305 + value.as_ref(), 1306 1306 + true, 1307 1307 + ) 1308 1308 + .count(); 1309 1309 + if count > 10000usize { 1310 1310 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1311 1311 + field: "comment", 1312 1312 + max: 10000usize, 1313 1313 + actual: count, 1314 1314 + }); 1315 1315 + } 1316 1316 + } 1317 1317 + } 1291 1318 Ok(()) 1292 1319 } 1293 1320 } ··· 1956 1983 fn validate( 1957 1984 &self, 1958 1985 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1986 1986 + { 1987 1987 + let value = &self.books_read; 1988 1988 + if *value < 0i64 { 1989 1989 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1990 1990 + field: "books_read", 1991 1991 + min: 0i64, 1992 1992 + actual: *value, 1993 1993 + }); 1994 1994 + } 1995 1995 + } 1996 1996 + { 1997 1997 + let value = &self.reviews; 1998 1998 + if *value < 0i64 { 1999 1999 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 2000 2000 + field: "reviews", 2001 2001 + min: 0i64, 2002 2002 + actual: *value, 2003 2003 + }); 2004 2004 + } 2005 2005 + } 1959 2006 Ok(()) 1960 2007 } 1961 2008 } ··· 3276 3323 fn validate( 3277 3324 &self, 3278 3325 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3326 3326 + { 3327 3327 + let value = &self.authors; 3328 3328 + if value.len() > 2048usize { 3329 3329 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3330 3330 + field: "authors", 3331 3331 + max: 2048usize, 3332 3332 + actual: value.len(), 3333 3333 + }); 3334 3334 + } 3335 3335 + } 3336 3336 + { 3337 3337 + let value = &self.authors; 3338 3338 + if value.len() < 1usize { 3339 3339 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 3340 3340 + field: "authors", 3341 3341 + min: 1usize, 3342 3342 + actual: value.len(), 3343 3343 + }); 3344 3344 + } 3345 3345 + } 3346 3346 + if let Some(ref value) = self.description { 3347 3347 + if value.len() > 5000usize { 3348 3348 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3349 3349 + field: "description", 3350 3350 + max: 5000usize, 3351 3351 + actual: value.len(), 3352 3352 + }); 3353 3353 + } 3354 3354 + } 3355 3355 + if let Some(ref value) = self.rating { 3356 3356 + if *value > 1000i64 { 3357 3357 + return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 3358 3358 + field: "rating", 3359 3359 + max: 1000i64, 3360 3360 + actual: *value, 3361 3361 + }); 3362 3362 + } 3363 3363 + } 3364 3364 + if let Some(ref value) = self.rating { 3365 3365 + if *value < 0i64 { 3366 3366 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 3367 3367 + field: "rating", 3368 3368 + min: 0i64, 3369 3369 + actual: *value, 3370 3370 + }); 3371 3371 + } 3372 3372 + } 3373 3373 + if let Some(ref value) = self.review { 3374 3374 + { 3375 3375 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 3376 3376 + value.as_ref(), 3377 3377 + true, 3378 3378 + ) 3379 3379 + .count(); 3380 3380 + if count > 15000usize { 3381 3381 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 3382 3382 + field: "review", 3383 3383 + max: 15000usize, 3384 3384 + actual: count, 3385 3385 + }); 3386 3386 + } 3387 3387 + } 3388 3388 + } 3389 3389 + if let Some(ref value) = self.stars { 3390 3390 + if *value > 10i64 { 3391 3391 + return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 3392 3392 + field: "stars", 3393 3393 + max: 10i64, 3394 3394 + actual: *value, 3395 3395 + }); 3396 3396 + } 3397 3397 + } 3398 3398 + if let Some(ref value) = self.stars { 3399 3399 + if *value < 1i64 { 3400 3400 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 3401 3401 + field: "stars", 3402 3402 + min: 1i64, 3403 3403 + actual: *value, 3404 3404 + }); 3405 3405 + } 3406 3406 + } 3407 3407 + { 3408 3408 + let value = &self.title; 3409 3409 + if value.len() > 512usize { 3410 3410 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3411 3411 + field: "title", 3412 3412 + max: 512usize, 3413 3413 + actual: value.len(), 3414 3414 + }); 3415 3415 + } 3416 3416 + } 3417 3417 + { 3418 3418 + let value = &self.title; 3419 3419 + if value.len() < 1usize { 3420 3420 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 3421 3421 + field: "title", 3422 3422 + min: 1usize, 3423 3423 + actual: value.len(), 3424 3424 + }); 3425 3425 + } 3426 3426 + } 3279 3427 Ok(()) 3280 3428 } 3281 3429 }

+17 -7

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

reviewed

··· 15 15 PartialEq, 16 16 Eq, 17 17 jacquard_derive::IntoStatic, 18 18 - bon::Builder, 18 18 + bon::Builder 19 19 )] 20 20 #[serde(rename_all = "camelCase")] 21 21 pub struct Book<'a> { ··· 75 75 76 76 /// Typed wrapper for GetRecord response with this collection's record type. 77 77 #[derive( 78 78 - serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic, 78 78 + serde::Serialize, 79 79 + serde::Deserialize, 80 80 + Debug, 81 81 + Clone, 82 82 + PartialEq, 83 83 + Eq, 84 84 + jacquard_derive::IntoStatic 79 85 )] 80 86 #[serde(rename_all = "camelCase")] 81 87 pub struct BookGetRecordOutput<'a> { ··· 299 305 }, 300 306 } 301 307 } 302 302 - fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 308 308 + fn validate( 309 309 + &self, 310 310 + ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 303 311 { 304 312 let value = &self.authors; 305 313 if value.len() > 2048usize { ··· 322 330 } 323 331 if let Some(ref value) = self.review { 324 332 { 325 325 - let count = 326 326 - ::unicode_segmentation::UnicodeSegmentation::graphemes(value.as_ref(), true) 327 327 - .count(); 333 333 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 334 334 + value.as_ref(), 335 335 + true, 336 336 + ) 337 337 + .count(); 328 338 if count > 15000usize { 329 339 return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 330 340 field: "review", ··· 374 384 } 375 385 Ok(()) 376 386 } 377 377 - } 387 387 + }

+25

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

reviewed

··· 196 196 fn validate( 197 197 &self, 198 198 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 199 199 + if let Some(ref value) = self.display_name { 200 200 + if value.len() > 640usize { 201 201 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 202 202 + field: "display_name", 203 203 + max: 640usize, 204 204 + actual: value.len(), 205 205 + }); 206 206 + } 207 207 + } 208 208 + if let Some(ref value) = self.display_name { 209 209 + { 210 210 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 211 211 + value.as_ref(), 212 212 + true, 213 213 + ) 214 214 + .count(); 215 215 + if count > 64usize { 216 216 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 217 217 + field: "display_name", 218 218 + max: 64usize, 219 219 + actual: count, 220 220 + }); 221 221 + } 222 222 + } 223 223 + } 199 224 Ok(()) 200 225 } 201 226 }

+54

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

reviewed

··· 14745 14745 fn validate( 14746 14746 &self, 14747 14747 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 14748 14748 + { 14749 14749 + let value = &self.text; 14750 14750 + if value.len() > 10000usize { 14751 14751 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 14752 14752 + field: "text", 14753 14753 + max: 10000usize, 14754 14754 + actual: value.len(), 14755 14755 + }); 14756 14756 + } 14757 14757 + } 14758 14758 + { 14759 14759 + let value = &self.text; 14760 14760 + { 14761 14761 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 14762 14762 + value.as_ref(), 14763 14763 + true, 14764 14764 + ) 14765 14765 + .count(); 14766 14766 + if count > 1000usize { 14767 14767 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 14768 14768 + field: "text", 14769 14769 + max: 1000usize, 14770 14770 + actual: count, 14771 14771 + }); 14772 14772 + } 14773 14773 + } 14774 14774 + } 14748 14775 Ok(()) 14749 14776 } 14750 14777 } ··· 16851 16878 fn validate( 16852 16879 &self, 16853 16880 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 16881 16881 + { 16882 16882 + let value = &self.text; 16883 16883 + if value.len() > 10000usize { 16884 16884 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 16885 16885 + field: "text", 16886 16886 + max: 10000usize, 16887 16887 + actual: value.len(), 16888 16888 + }); 16889 16889 + } 16890 16890 + } 16891 16891 + { 16892 16892 + let value = &self.text; 16893 16893 + { 16894 16894 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 16895 16895 + value.as_ref(), 16896 16896 + true, 16897 16897 + ) 16898 16898 + .count(); 16899 16899 + if count > 1000usize { 16900 16900 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 16901 16901 + field: "text", 16902 16902 + max: 1000usize, 16903 16903 + actual: count, 16904 16904 + }); 16905 16905 + } 16906 16906 + } 16907 16907 + } 16854 16908 Ok(()) 16855 16909 } 16856 16910 }

+50

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

reviewed

··· 500 500 fn validate( 501 501 &self, 502 502 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 503 503 + { 504 504 + let value = &self.address; 505 505 + if value.len() > 42usize { 506 506 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 507 507 + field: "address", 508 508 + max: 42usize, 509 509 + actual: value.len(), 510 510 + }); 511 511 + } 512 512 + } 513 513 + { 514 514 + let value = &self.address; 515 515 + if value.len() < 42usize { 516 516 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 517 517 + field: "address", 518 518 + min: 42usize, 519 519 + actual: value.len(), 520 520 + }); 521 521 + } 522 522 + } 523 523 + { 524 524 + let value = &self.nonce; 525 525 + if value.len() > 256usize { 526 526 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 527 527 + field: "nonce", 528 528 + max: 256usize, 529 529 + actual: value.len(), 530 530 + }); 531 531 + } 532 532 + } 533 533 + { 534 534 + let value = &self.nonce; 535 535 + if value.len() < 8usize { 536 536 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 537 537 + field: "nonce", 538 538 + min: 8usize, 539 539 + actual: value.len(), 540 540 + }); 541 541 + } 542 542 + } 543 543 + { 544 544 + let value = &self.statement; 545 545 + if value.len() < 78usize { 546 546 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 547 547 + field: "statement", 548 548 + min: 78usize, 549 549 + actual: value.len(), 550 550 + }); 551 551 + } 552 552 + } 503 553 Ok(()) 504 554 } 505 555 }

+111

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

reviewed

··· 431 431 fn validate( 432 432 &self, 433 433 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 434 434 + { 435 435 + let value = &self.val; 436 436 + if value.len() > 128usize { 437 437 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 438 438 + field: "val", 439 439 + max: 128usize, 440 440 + actual: value.len(), 441 441 + }); 442 442 + } 443 443 + } 434 444 Ok(()) 435 445 } 436 446 } ··· 967 977 fn validate( 968 978 &self, 969 979 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 980 980 + { 981 981 + let value = &self.identifier; 982 982 + if value.len() > 100usize { 983 983 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 984 984 + field: "identifier", 985 985 + max: 100usize, 986 986 + actual: value.len(), 987 987 + }); 988 988 + } 989 989 + } 990 990 + { 991 991 + let value = &self.identifier; 992 992 + { 993 993 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 994 994 + value.as_ref(), 995 995 + true, 996 996 + ) 997 997 + .count(); 998 998 + if count > 100usize { 999 999 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1000 1000 + field: "identifier", 1001 1001 + max: 100usize, 1002 1002 + actual: count, 1003 1003 + }); 1004 1004 + } 1005 1005 + } 1006 1006 + } 970 1007 Ok(()) 971 1008 } 972 1009 } ··· 1369 1406 fn validate( 1370 1407 &self, 1371 1408 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1409 1409 + { 1410 1410 + let value = &self.description; 1411 1411 + if value.len() > 100000usize { 1412 1412 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1413 1413 + field: "description", 1414 1414 + max: 100000usize, 1415 1415 + actual: value.len(), 1416 1416 + }); 1417 1417 + } 1418 1418 + } 1419 1419 + { 1420 1420 + let value = &self.description; 1421 1421 + { 1422 1422 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 1423 1423 + value.as_ref(), 1424 1424 + true, 1425 1425 + ) 1426 1426 + .count(); 1427 1427 + if count > 10000usize { 1428 1428 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1429 1429 + field: "description", 1430 1430 + max: 10000usize, 1431 1431 + actual: count, 1432 1432 + }); 1433 1433 + } 1434 1434 + } 1435 1435 + } 1436 1436 + { 1437 1437 + let value = &self.name; 1438 1438 + if value.len() > 640usize { 1439 1439 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1440 1440 + field: "name", 1441 1441 + max: 640usize, 1442 1442 + actual: value.len(), 1443 1443 + }); 1444 1444 + } 1445 1445 + } 1446 1446 + { 1447 1447 + let value = &self.name; 1448 1448 + { 1449 1449 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 1450 1450 + value.as_ref(), 1451 1451 + true, 1452 1452 + ) 1453 1453 + .count(); 1454 1454 + if count > 64usize { 1455 1455 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1456 1456 + field: "name", 1457 1457 + max: 64usize, 1458 1458 + actual: count, 1459 1459 + }); 1460 1460 + } 1461 1461 + } 1462 1462 + } 1372 1463 Ok(()) 1373 1464 } 1374 1465 } ··· 1764 1855 fn validate( 1765 1856 &self, 1766 1857 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1858 1858 + { 1859 1859 + let value = &self.val; 1860 1860 + if value.len() > 128usize { 1861 1861 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1862 1862 + field: "val", 1863 1863 + max: 128usize, 1864 1864 + actual: value.len(), 1865 1865 + }); 1866 1866 + } 1867 1867 + } 1767 1868 Ok(()) 1768 1869 } 1769 1870 } ··· 2158 2259 fn validate( 2159 2260 &self, 2160 2261 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2262 2262 + { 2263 2263 + let value = &self.values; 2264 2264 + if value.len() > 10usize { 2265 2265 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2266 2266 + field: "values", 2267 2267 + max: 10usize, 2268 2268 + actual: value.len(), 2269 2269 + }); 2270 2270 + } 2271 2271 + } 2161 2272 Ok(()) 2162 2273 } 2163 2274 }

+851 -767

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

reviewed

··· 15 15 PartialEq, 16 16 Eq, 17 17 jacquard_derive::IntoStatic, 18 18 - bon::Builder 18 18 + bon::Builder, 19 19 )] 20 20 #[serde(rename_all = "camelCase")] 21 21 pub struct Create<'a> { ··· 25 25 #[serde(skip_serializing_if = "std::option::Option::is_none")] 26 26 #[builder(into)] 27 27 #[serde(borrow)] 28 28 - pub rkey: Option< 29 29 - jacquard_common::types::string::RecordKey< 30 30 - jacquard_common::types::string::Rkey<'a>, 31 31 - >, 32 32 - >, 28 28 + pub rkey: 29 29 + Option<jacquard_common::types::string::RecordKey<jacquard_common::types::string::Rkey<'a>>>, 33 30 #[serde(borrow)] 34 31 pub value: jacquard_common::types::value::Data<'a>, 35 32 } ··· 102 99 ); 103 100 map.insert( 104 101 "createResult".into(), 105 105 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 106 106 - description: None, 107 107 - required: Some(vec!["uri".into(), "cid".into()]), 108 108 - nullable: None, 109 109 - properties: { 110 110 - let mut map = ::std::collections::BTreeMap::new(); 111 111 - map.insert( 112 112 - "cid".into(), 113 113 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 114 114 - description: None, 115 115 - format: Some( 116 116 - ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 102 102 + ::jacquard_lexicon::lexicon::LexUserType::Object( 103 103 + ::jacquard_lexicon::lexicon::LexObject { 104 104 + description: None, 105 105 + required: Some(vec!["uri".into(), "cid".into()]), 106 106 + nullable: None, 107 107 + properties: { 108 108 + let mut map = ::std::collections::BTreeMap::new(); 109 109 + map.insert( 110 110 + "cid".into(), 111 111 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 112 112 + ::jacquard_lexicon::lexicon::LexString { 113 113 + description: None, 114 114 + format: Some( 115 115 + ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 116 116 + ), 117 117 + default: None, 118 118 + min_length: None, 119 119 + max_length: None, 120 120 + min_graphemes: None, 121 121 + max_graphemes: None, 122 122 + r#enum: None, 123 123 + r#const: None, 124 124 + known_values: None, 125 125 + }, 117 126 ), 118 118 - default: None, 119 119 - min_length: None, 120 120 - max_length: None, 121 121 - min_graphemes: None, 122 122 - max_graphemes: None, 123 123 - r#enum: None, 124 124 - r#const: None, 125 125 - known_values: None, 126 126 - }), 127 127 - ); 128 128 - map.insert( 129 129 - "uri".into(), 130 130 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 131 131 - description: None, 132 132 - format: Some( 133 133 - ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 127 127 + ); 128 128 + map.insert( 129 129 + "uri".into(), 130 130 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 131 131 + ::jacquard_lexicon::lexicon::LexString { 132 132 + description: None, 133 133 + format: Some( 134 134 + ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 135 135 + ), 136 136 + default: None, 137 137 + min_length: None, 138 138 + max_length: None, 139 139 + min_graphemes: None, 140 140 + max_graphemes: None, 141 141 + r#enum: None, 142 142 + r#const: None, 143 143 + known_values: None, 144 144 + }, 145 145 + ), 146 146 + ); 147 147 + map.insert( 148 148 + "validationStatus".into(), 149 149 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 150 150 + ::jacquard_lexicon::lexicon::LexString { 151 151 + description: None, 152 152 + format: None, 153 153 + default: None, 154 154 + min_length: None, 155 155 + max_length: None, 156 156 + min_graphemes: None, 157 157 + max_graphemes: None, 158 158 + r#enum: None, 159 159 + r#const: None, 160 160 + known_values: None, 161 161 + }, 134 162 ), 135 135 - default: None, 136 136 - min_length: None, 137 137 - max_length: None, 138 138 - min_graphemes: None, 139 139 - max_graphemes: None, 140 140 - r#enum: None, 141 141 - r#const: None, 142 142 - known_values: None, 143 143 - }), 144 144 - ); 145 145 - map.insert( 146 146 - "validationStatus".into(), 147 147 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 148 148 - description: None, 149 149 - format: None, 150 150 - default: None, 151 151 - min_length: None, 152 152 - max_length: None, 153 153 - min_graphemes: None, 154 154 - max_graphemes: None, 155 155 - r#enum: None, 156 156 - r#const: None, 157 157 - known_values: None, 158 158 - }), 159 159 - ); 160 160 - map 163 163 + ); 164 164 + map 165 165 + }, 161 166 }, 162 162 - }), 167 167 + ), 163 168 ); 164 169 map.insert( 165 170 "delete".into(), ··· 209 214 ); 210 215 map.insert( 211 216 "deleteResult".into(), 212 212 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 213 213 - description: None, 214 214 - required: Some(vec![]), 215 215 - nullable: None, 216 216 - properties: { 217 217 - let mut map = ::std::collections::BTreeMap::new(); 218 218 - map 217 217 + ::jacquard_lexicon::lexicon::LexUserType::Object( 218 218 + ::jacquard_lexicon::lexicon::LexObject { 219 219 + description: None, 220 220 + required: Some(vec![]), 221 221 + nullable: None, 222 222 + properties: { 223 223 + let mut map = ::std::collections::BTreeMap::new(); 224 224 + map 225 225 + }, 219 226 }, 220 220 - }), 227 227 + ), 221 228 ); 222 229 map.insert( 223 230 "main".into(), ··· 356 363 ); 357 364 map.insert( 358 365 "updateResult".into(), 359 359 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 360 360 - description: None, 361 361 - required: Some(vec!["uri".into(), "cid".into()]), 362 362 - nullable: None, 363 363 - properties: { 364 364 - let mut map = ::std::collections::BTreeMap::new(); 365 365 - map.insert( 366 366 - "cid".into(), 367 367 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 368 368 - description: None, 369 369 - format: Some( 370 370 - ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 366 366 + ::jacquard_lexicon::lexicon::LexUserType::Object( 367 367 + ::jacquard_lexicon::lexicon::LexObject { 368 368 + description: None, 369 369 + required: Some(vec!["uri".into(), "cid".into()]), 370 370 + nullable: None, 371 371 + properties: { 372 372 + let mut map = ::std::collections::BTreeMap::new(); 373 373 + map.insert( 374 374 + "cid".into(), 375 375 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 376 376 + ::jacquard_lexicon::lexicon::LexString { 377 377 + description: None, 378 378 + format: Some( 379 379 + ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 380 380 + ), 381 381 + default: None, 382 382 + min_length: None, 383 383 + max_length: None, 384 384 + min_graphemes: None, 385 385 + max_graphemes: None, 386 386 + r#enum: None, 387 387 + r#const: None, 388 388 + known_values: None, 389 389 + }, 371 390 ), 372 372 - default: None, 373 373 - min_length: None, 374 374 - max_length: None, 375 375 - min_graphemes: None, 376 376 - max_graphemes: None, 377 377 - r#enum: None, 378 378 - r#const: None, 379 379 - known_values: None, 380 380 - }), 381 381 - ); 382 382 - map.insert( 383 383 - "uri".into(), 384 384 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 385 385 - description: None, 386 386 - format: Some( 387 387 - ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 391 391 + ); 392 392 + map.insert( 393 393 + "uri".into(), 394 394 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 395 395 + ::jacquard_lexicon::lexicon::LexString { 396 396 + description: None, 397 397 + format: Some( 398 398 + ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 399 399 + ), 400 400 + default: None, 401 401 + min_length: None, 402 402 + max_length: None, 403 403 + min_graphemes: None, 404 404 + max_graphemes: None, 405 405 + r#enum: None, 406 406 + r#const: None, 407 407 + known_values: None, 408 408 + }, 409 409 + ), 410 410 + ); 411 411 + map.insert( 412 412 + "validationStatus".into(), 413 413 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 414 414 + ::jacquard_lexicon::lexicon::LexString { 415 415 + description: None, 416 416 + format: None, 417 417 + default: None, 418 418 + min_length: None, 419 419 + max_length: None, 420 420 + min_graphemes: None, 421 421 + max_graphemes: None, 422 422 + r#enum: None, 423 423 + r#const: None, 424 424 + known_values: None, 425 425 + }, 388 426 ), 389 389 - default: None, 390 390 - min_length: None, 391 391 - max_length: None, 392 392 - min_graphemes: None, 393 393 - max_graphemes: None, 394 394 - r#enum: None, 395 395 - r#const: None, 396 396 - known_values: None, 397 397 - }), 398 398 - ); 399 399 - map.insert( 400 400 - "validationStatus".into(), 401 401 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 402 402 - description: None, 403 403 - format: None, 404 404 - default: None, 405 405 - min_length: None, 406 406 - max_length: None, 407 407 - min_graphemes: None, 408 408 - max_graphemes: None, 409 409 - r#enum: None, 410 410 - r#const: None, 411 411 - known_values: None, 412 412 - }), 413 413 - ); 414 414 - map 427 427 + ); 428 428 + map 429 429 + }, 415 430 }, 416 416 - }), 431 431 + ), 417 432 ); 418 433 map 419 434 }, 420 435 } 421 436 } 422 422 - fn validate( 423 423 - &self, 424 424 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 437 437 + fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 438 438 + if let Some(ref value) = self.rkey { 439 439 + if value.len() > 512usize { 440 440 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 441 441 + field: "rkey", 442 442 + max: 512usize, 443 443 + actual: value.len(), 444 444 + }); 445 445 + } 446 446 + } 425 447 Ok(()) 426 448 } 427 449 } ··· 435 457 PartialEq, 436 458 Eq, 437 459 jacquard_derive::IntoStatic, 438 438 - bon::Builder 460 460 + bon::Builder, 439 461 )] 440 462 #[serde(rename_all = "camelCase")] 441 463 pub struct CreateResult<'a> { ··· 517 539 ); 518 540 map.insert( 519 541 "createResult".into(), 520 520 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 521 521 - description: None, 522 522 - required: Some(vec!["uri".into(), "cid".into()]), 523 523 - nullable: None, 524 524 - properties: { 525 525 - let mut map = ::std::collections::BTreeMap::new(); 526 526 - map.insert( 527 527 - "cid".into(), 528 528 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 529 529 - description: None, 530 530 - format: Some( 531 531 - ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 542 542 + ::jacquard_lexicon::lexicon::LexUserType::Object( 543 543 + ::jacquard_lexicon::lexicon::LexObject { 544 544 + description: None, 545 545 + required: Some(vec!["uri".into(), "cid".into()]), 546 546 + nullable: None, 547 547 + properties: { 548 548 + let mut map = ::std::collections::BTreeMap::new(); 549 549 + map.insert( 550 550 + "cid".into(), 551 551 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 552 552 + ::jacquard_lexicon::lexicon::LexString { 553 553 + description: None, 554 554 + format: Some( 555 555 + ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 556 556 + ), 557 557 + default: None, 558 558 + min_length: None, 559 559 + max_length: None, 560 560 + min_graphemes: None, 561 561 + max_graphemes: None, 562 562 + r#enum: None, 563 563 + r#const: None, 564 564 + known_values: None, 565 565 + }, 532 566 ), 533 533 - default: None, 534 534 - min_length: None, 535 535 - max_length: None, 536 536 - min_graphemes: None, 537 537 - max_graphemes: None, 538 538 - r#enum: None, 539 539 - r#const: None, 540 540 - known_values: None, 541 541 - }), 542 542 - ); 543 543 - map.insert( 544 544 - "uri".into(), 545 545 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 546 546 - description: None, 547 547 - format: Some( 548 548 - ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 567 567 + ); 568 568 + map.insert( 569 569 + "uri".into(), 570 570 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 571 571 + ::jacquard_lexicon::lexicon::LexString { 572 572 + description: None, 573 573 + format: Some( 574 574 + ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 575 575 + ), 576 576 + default: None, 577 577 + min_length: None, 578 578 + max_length: None, 579 579 + min_graphemes: None, 580 580 + max_graphemes: None, 581 581 + r#enum: None, 582 582 + r#const: None, 583 583 + known_values: None, 584 584 + }, 585 585 + ), 586 586 + ); 587 587 + map.insert( 588 588 + "validationStatus".into(), 589 589 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 590 590 + ::jacquard_lexicon::lexicon::LexString { 591 591 + description: None, 592 592 + format: None, 593 593 + default: None, 594 594 + min_length: None, 595 595 + max_length: None, 596 596 + min_graphemes: None, 597 597 + max_graphemes: None, 598 598 + r#enum: None, 599 599 + r#const: None, 600 600 + known_values: None, 601 601 + }, 549 602 ), 550 550 - default: None, 551 551 - min_length: None, 552 552 - max_length: None, 553 553 - min_graphemes: None, 554 554 - max_graphemes: None, 555 555 - r#enum: None, 556 556 - r#const: None, 557 557 - known_values: None, 558 558 - }), 559 559 - ); 560 560 - map.insert( 561 561 - "validationStatus".into(), 562 562 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 563 563 - description: None, 564 564 - format: None, 565 565 - default: None, 566 566 - min_length: None, 567 567 - max_length: None, 568 568 - min_graphemes: None, 569 569 - max_graphemes: None, 570 570 - r#enum: None, 571 571 - r#const: None, 572 572 - known_values: None, 573 573 - }), 574 574 - ); 575 575 - map 603 603 + ); 604 604 + map 605 605 + }, 576 606 }, 577 577 - }), 607 607 + ), 578 608 ); 579 609 map.insert( 580 610 "delete".into(), ··· 624 654 ); 625 655 map.insert( 626 656 "deleteResult".into(), 627 627 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 628 628 - description: None, 629 629 - required: Some(vec![]), 630 630 - nullable: None, 631 631 - properties: { 632 632 - let mut map = ::std::collections::BTreeMap::new(); 633 633 - map 657 657 + ::jacquard_lexicon::lexicon::LexUserType::Object( 658 658 + ::jacquard_lexicon::lexicon::LexObject { 659 659 + description: None, 660 660 + required: Some(vec![]), 661 661 + nullable: None, 662 662 + properties: { 663 663 + let mut map = ::std::collections::BTreeMap::new(); 664 664 + map 665 665 + }, 634 666 }, 635 635 - }), 667 667 + ), 636 668 ); 637 669 map.insert( 638 670 "main".into(), ··· 771 803 ); 772 804 map.insert( 773 805 "updateResult".into(), 774 774 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 775 775 - description: None, 776 776 - required: Some(vec!["uri".into(), "cid".into()]), 777 777 - nullable: None, 778 778 - properties: { 779 779 - let mut map = ::std::collections::BTreeMap::new(); 780 780 - map.insert( 781 781 - "cid".into(), 782 782 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 783 783 - description: None, 784 784 - format: Some( 785 785 - ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 806 806 + ::jacquard_lexicon::lexicon::LexUserType::Object( 807 807 + ::jacquard_lexicon::lexicon::LexObject { 808 808 + description: None, 809 809 + required: Some(vec!["uri".into(), "cid".into()]), 810 810 + nullable: None, 811 811 + properties: { 812 812 + let mut map = ::std::collections::BTreeMap::new(); 813 813 + map.insert( 814 814 + "cid".into(), 815 815 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 816 816 + ::jacquard_lexicon::lexicon::LexString { 817 817 + description: None, 818 818 + format: Some( 819 819 + ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 820 820 + ), 821 821 + default: None, 822 822 + min_length: None, 823 823 + max_length: None, 824 824 + min_graphemes: None, 825 825 + max_graphemes: None, 826 826 + r#enum: None, 827 827 + r#const: None, 828 828 + known_values: None, 829 829 + }, 786 830 ), 787 787 - default: None, 788 788 - min_length: None, 789 789 - max_length: None, 790 790 - min_graphemes: None, 791 791 - max_graphemes: None, 792 792 - r#enum: None, 793 793 - r#const: None, 794 794 - known_values: None, 795 795 - }), 796 796 - ); 797 797 - map.insert( 798 798 - "uri".into(), 799 799 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 800 800 - description: None, 801 801 - format: Some( 802 802 - ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 831 831 + ); 832 832 + map.insert( 833 833 + "uri".into(), 834 834 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 835 835 + ::jacquard_lexicon::lexicon::LexString { 836 836 + description: None, 837 837 + format: Some( 838 838 + ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 839 839 + ), 840 840 + default: None, 841 841 + min_length: None, 842 842 + max_length: None, 843 843 + min_graphemes: None, 844 844 + max_graphemes: None, 845 845 + r#enum: None, 846 846 + r#const: None, 847 847 + known_values: None, 848 848 + }, 803 849 ), 804 804 - default: None, 805 805 - min_length: None, 806 806 - max_length: None, 807 807 - min_graphemes: None, 808 808 - max_graphemes: None, 809 809 - r#enum: None, 810 810 - r#const: None, 811 811 - known_values: None, 812 812 - }), 813 813 - ); 814 814 - map.insert( 815 815 - "validationStatus".into(), 816 816 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 817 817 - description: None, 818 818 - format: None, 819 819 - default: None, 820 820 - min_length: None, 821 821 - max_length: None, 822 822 - min_graphemes: None, 823 823 - max_graphemes: None, 824 824 - r#enum: None, 825 825 - r#const: None, 826 826 - known_values: None, 827 827 - }), 828 828 - ); 829 829 - map 850 850 + ); 851 851 + map.insert( 852 852 + "validationStatus".into(), 853 853 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 854 854 + ::jacquard_lexicon::lexicon::LexString { 855 855 + description: None, 856 856 + format: None, 857 857 + default: None, 858 858 + min_length: None, 859 859 + max_length: None, 860 860 + min_graphemes: None, 861 861 + max_graphemes: None, 862 862 + r#enum: None, 863 863 + r#const: None, 864 864 + known_values: None, 865 865 + }, 866 866 + ), 867 867 + ); 868 868 + map 869 869 + }, 830 870 }, 831 831 - }), 871 871 + ), 832 872 ); 833 873 map 834 874 }, 835 875 } 836 876 } 837 837 - fn validate( 838 838 - &self, 839 839 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 877 877 + fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 840 878 Ok(()) 841 879 } 842 880 } ··· 851 889 PartialEq, 852 890 Eq, 853 891 jacquard_derive::IntoStatic, 854 854 - bon::Builder 892 892 + bon::Builder, 855 893 )] 856 894 #[serde(rename_all = "camelCase")] 857 895 pub struct Delete<'a> { 858 896 #[serde(borrow)] 859 897 pub collection: jacquard_common::types::string::Nsid<'a>, 860 898 #[serde(borrow)] 861 861 - pub rkey: jacquard_common::types::string::RecordKey< 862 862 - jacquard_common::types::string::Rkey<'a>, 863 863 - >, 899 899 + pub rkey: jacquard_common::types::string::RecordKey<jacquard_common::types::string::Rkey<'a>>, 864 900 } 865 901 866 902 impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Delete<'a> { ··· 931 967 ); 932 968 map.insert( 933 969 "createResult".into(), 934 934 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 935 935 - description: None, 936 936 - required: Some(vec!["uri".into(), "cid".into()]), 937 937 - nullable: None, 938 938 - properties: { 939 939 - let mut map = ::std::collections::BTreeMap::new(); 940 940 - map.insert( 941 941 - "cid".into(), 942 942 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 943 943 - description: None, 944 944 - format: Some( 945 945 - ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 970 970 + ::jacquard_lexicon::lexicon::LexUserType::Object( 971 971 + ::jacquard_lexicon::lexicon::LexObject { 972 972 + description: None, 973 973 + required: Some(vec!["uri".into(), "cid".into()]), 974 974 + nullable: None, 975 975 + properties: { 976 976 + let mut map = ::std::collections::BTreeMap::new(); 977 977 + map.insert( 978 978 + "cid".into(), 979 979 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 980 980 + ::jacquard_lexicon::lexicon::LexString { 981 981 + description: None, 982 982 + format: Some( 983 983 + ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 984 984 + ), 985 985 + default: None, 986 986 + min_length: None, 987 987 + max_length: None, 988 988 + min_graphemes: None, 989 989 + max_graphemes: None, 990 990 + r#enum: None, 991 991 + r#const: None, 992 992 + known_values: None, 993 993 + }, 946 994 ), 947 947 - default: None, 948 948 - min_length: None, 949 949 - max_length: None, 950 950 - min_graphemes: None, 951 951 - max_graphemes: None, 952 952 - r#enum: None, 953 953 - r#const: None, 954 954 - known_values: None, 955 955 - }), 956 956 - ); 957 957 - map.insert( 958 958 - "uri".into(), 959 959 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 960 960 - description: None, 961 961 - format: Some( 962 962 - ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 995 995 + ); 996 996 + map.insert( 997 997 + "uri".into(), 998 998 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 999 999 + ::jacquard_lexicon::lexicon::LexString { 1000 1000 + description: None, 1001 1001 + format: Some( 1002 1002 + ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 1003 1003 + ), 1004 1004 + default: None, 1005 1005 + min_length: None, 1006 1006 + max_length: None, 1007 1007 + min_graphemes: None, 1008 1008 + max_graphemes: None, 1009 1009 + r#enum: None, 1010 1010 + r#const: None, 1011 1011 + known_values: None, 1012 1012 + }, 963 1013 ), 964 964 - default: None, 965 965 - min_length: None, 966 966 - max_length: None, 967 967 - min_graphemes: None, 968 968 - max_graphemes: None, 969 969 - r#enum: None, 970 970 - r#const: None, 971 971 - known_values: None, 972 972 - }), 973 973 - ); 974 974 - map.insert( 975 975 - "validationStatus".into(), 976 976 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 977 977 - description: None, 978 978 - format: None, 979 979 - default: None, 980 980 - min_length: None, 981 981 - max_length: None, 982 982 - min_graphemes: None, 983 983 - max_graphemes: None, 984 984 - r#enum: None, 985 985 - r#const: None, 986 986 - known_values: None, 987 987 - }), 988 988 - ); 989 989 - map 1014 1014 + ); 1015 1015 + map.insert( 1016 1016 + "validationStatus".into(), 1017 1017 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 1018 1018 + ::jacquard_lexicon::lexicon::LexString { 1019 1019 + description: None, 1020 1020 + format: None, 1021 1021 + default: None, 1022 1022 + min_length: None, 1023 1023 + max_length: None, 1024 1024 + min_graphemes: None, 1025 1025 + max_graphemes: None, 1026 1026 + r#enum: None, 1027 1027 + r#const: None, 1028 1028 + known_values: None, 1029 1029 + }, 1030 1030 + ), 1031 1031 + ); 1032 1032 + map 1033 1033 + }, 990 1034 }, 991 991 - }), 1035 1035 + ), 992 1036 ); 993 1037 map.insert( 994 1038 "delete".into(), ··· 1038 1082 ); 1039 1083 map.insert( 1040 1084 "deleteResult".into(), 1041 1041 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 1042 1042 - description: None, 1043 1043 - required: Some(vec![]), 1044 1044 - nullable: None, 1045 1045 - properties: { 1046 1046 - let mut map = ::std::collections::BTreeMap::new(); 1047 1047 - map 1085 1085 + ::jacquard_lexicon::lexicon::LexUserType::Object( 1086 1086 + ::jacquard_lexicon::lexicon::LexObject { 1087 1087 + description: None, 1088 1088 + required: Some(vec![]), 1089 1089 + nullable: None, 1090 1090 + properties: { 1091 1091 + let mut map = ::std::collections::BTreeMap::new(); 1092 1092 + map 1093 1093 + }, 1048 1094 }, 1049 1049 - }), 1095 1095 + ), 1050 1096 ); 1051 1097 map.insert( 1052 1098 "main".into(), ··· 1185 1231 ); 1186 1232 map.insert( 1187 1233 "updateResult".into(), 1188 1188 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 1189 1189 - description: None, 1190 1190 - required: Some(vec!["uri".into(), "cid".into()]), 1191 1191 - nullable: None, 1192 1192 - properties: { 1193 1193 - let mut map = ::std::collections::BTreeMap::new(); 1194 1194 - map.insert( 1195 1195 - "cid".into(), 1196 1196 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 1197 1197 - description: None, 1198 1198 - format: Some( 1199 1199 - ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 1234 1234 + ::jacquard_lexicon::lexicon::LexUserType::Object( 1235 1235 + ::jacquard_lexicon::lexicon::LexObject { 1236 1236 + description: None, 1237 1237 + required: Some(vec!["uri".into(), "cid".into()]), 1238 1238 + nullable: None, 1239 1239 + properties: { 1240 1240 + let mut map = ::std::collections::BTreeMap::new(); 1241 1241 + map.insert( 1242 1242 + "cid".into(), 1243 1243 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 1244 1244 + ::jacquard_lexicon::lexicon::LexString { 1245 1245 + description: None, 1246 1246 + format: Some( 1247 1247 + ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 1248 1248 + ), 1249 1249 + default: None, 1250 1250 + min_length: None, 1251 1251 + max_length: None, 1252 1252 + min_graphemes: None, 1253 1253 + max_graphemes: None, 1254 1254 + r#enum: None, 1255 1255 + r#const: None, 1256 1256 + known_values: None, 1257 1257 + }, 1200 1258 ), 1201 1201 - default: None, 1202 1202 - min_length: None, 1203 1203 - max_length: None, 1204 1204 - min_graphemes: None, 1205 1205 - max_graphemes: None, 1206 1206 - r#enum: None, 1207 1207 - r#const: None, 1208 1208 - known_values: None, 1209 1209 - }), 1210 1210 - ); 1211 1211 - map.insert( 1212 1212 - "uri".into(), 1213 1213 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 1214 1214 - description: None, 1215 1215 - format: Some( 1216 1216 - ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 1259 1259 + ); 1260 1260 + map.insert( 1261 1261 + "uri".into(), 1262 1262 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 1263 1263 + ::jacquard_lexicon::lexicon::LexString { 1264 1264 + description: None, 1265 1265 + format: Some( 1266 1266 + ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 1267 1267 + ), 1268 1268 + default: None, 1269 1269 + min_length: None, 1270 1270 + max_length: None, 1271 1271 + min_graphemes: None, 1272 1272 + max_graphemes: None, 1273 1273 + r#enum: None, 1274 1274 + r#const: None, 1275 1275 + known_values: None, 1276 1276 + }, 1277 1277 + ), 1278 1278 + ); 1279 1279 + map.insert( 1280 1280 + "validationStatus".into(), 1281 1281 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 1282 1282 + ::jacquard_lexicon::lexicon::LexString { 1283 1283 + description: None, 1284 1284 + format: None, 1285 1285 + default: None, 1286 1286 + min_length: None, 1287 1287 + max_length: None, 1288 1288 + min_graphemes: None, 1289 1289 + max_graphemes: None, 1290 1290 + r#enum: None, 1291 1291 + r#const: None, 1292 1292 + known_values: None, 1293 1293 + }, 1217 1294 ), 1218 1218 - default: None, 1219 1219 - min_length: None, 1220 1220 - max_length: None, 1221 1221 - min_graphemes: None, 1222 1222 - max_graphemes: None, 1223 1223 - r#enum: None, 1224 1224 - r#const: None, 1225 1225 - known_values: None, 1226 1226 - }), 1227 1227 - ); 1228 1228 - map.insert( 1229 1229 - "validationStatus".into(), 1230 1230 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 1231 1231 - description: None, 1232 1232 - format: None, 1233 1233 - default: None, 1234 1234 - min_length: None, 1235 1235 - max_length: None, 1236 1236 - min_graphemes: None, 1237 1237 - max_graphemes: None, 1238 1238 - r#enum: None, 1239 1239 - r#const: None, 1240 1240 - known_values: None, 1241 1241 - }), 1242 1242 - ); 1243 1243 - map 1295 1295 + ); 1296 1296 + map 1297 1297 + }, 1244 1298 }, 1245 1245 - }), 1299 1299 + ), 1246 1300 ); 1247 1301 map 1248 1302 }, 1249 1303 } 1250 1304 } 1251 1251 - fn validate( 1252 1252 - &self, 1253 1253 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1305 1305 + fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1254 1306 Ok(()) 1255 1307 } 1256 1308 } ··· 1264 1316 PartialEq, 1265 1317 Eq, 1266 1318 jacquard_derive::IntoStatic, 1267 1267 - Default 1319 1319 + Default, 1268 1320 )] 1269 1321 #[serde(rename_all = "camelCase")] 1270 1322 pub struct DeleteResult<'a> {} ··· 1336 1388 ); 1337 1389 map.insert( 1338 1390 "createResult".into(), 1339 1339 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 1340 1340 - description: None, 1341 1341 - required: Some(vec!["uri".into(), "cid".into()]), 1342 1342 - nullable: None, 1343 1343 - properties: { 1344 1344 - let mut map = ::std::collections::BTreeMap::new(); 1345 1345 - map.insert( 1346 1346 - "cid".into(), 1347 1347 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 1348 1348 - description: None, 1349 1349 - format: Some( 1350 1350 - ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 1391 1391 + ::jacquard_lexicon::lexicon::LexUserType::Object( 1392 1392 + ::jacquard_lexicon::lexicon::LexObject { 1393 1393 + description: None, 1394 1394 + required: Some(vec!["uri".into(), "cid".into()]), 1395 1395 + nullable: None, 1396 1396 + properties: { 1397 1397 + let mut map = ::std::collections::BTreeMap::new(); 1398 1398 + map.insert( 1399 1399 + "cid".into(), 1400 1400 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 1401 1401 + ::jacquard_lexicon::lexicon::LexString { 1402 1402 + description: None, 1403 1403 + format: Some( 1404 1404 + ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 1405 1405 + ), 1406 1406 + default: None, 1407 1407 + min_length: None, 1408 1408 + max_length: None, 1409 1409 + min_graphemes: None, 1410 1410 + max_graphemes: None, 1411 1411 + r#enum: None, 1412 1412 + r#const: None, 1413 1413 + known_values: None, 1414 1414 + }, 1351 1415 ), 1352 1352 - default: None, 1353 1353 - min_length: None, 1354 1354 - max_length: None, 1355 1355 - min_graphemes: None, 1356 1356 - max_graphemes: None, 1357 1357 - r#enum: None, 1358 1358 - r#const: None, 1359 1359 - known_values: None, 1360 1360 - }), 1361 1361 - ); 1362 1362 - map.insert( 1363 1363 - "uri".into(), 1364 1364 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 1365 1365 - description: None, 1366 1366 - format: Some( 1367 1367 - ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 1416 1416 + ); 1417 1417 + map.insert( 1418 1418 + "uri".into(), 1419 1419 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 1420 1420 + ::jacquard_lexicon::lexicon::LexString { 1421 1421 + description: None, 1422 1422 + format: Some( 1423 1423 + ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 1424 1424 + ), 1425 1425 + default: None, 1426 1426 + min_length: None, 1427 1427 + max_length: None, 1428 1428 + min_graphemes: None, 1429 1429 + max_graphemes: None, 1430 1430 + r#enum: None, 1431 1431 + r#const: None, 1432 1432 + known_values: None, 1433 1433 + }, 1368 1434 ), 1369 1369 - default: None, 1370 1370 - min_length: None, 1371 1371 - max_length: None, 1372 1372 - min_graphemes: None, 1373 1373 - max_graphemes: None, 1374 1374 - r#enum: None, 1375 1375 - r#const: None, 1376 1376 - known_values: None, 1377 1377 - }), 1378 1378 - ); 1379 1379 - map.insert( 1380 1380 - "validationStatus".into(), 1381 1381 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 1382 1382 - description: None, 1383 1383 - format: None, 1384 1384 - default: None, 1385 1385 - min_length: None, 1386 1386 - max_length: None, 1387 1387 - min_graphemes: None, 1388 1388 - max_graphemes: None, 1389 1389 - r#enum: None, 1390 1390 - r#const: None, 1391 1391 - known_values: None, 1392 1392 - }), 1393 1393 - ); 1394 1394 - map 1435 1435 + ); 1436 1436 + map.insert( 1437 1437 + "validationStatus".into(), 1438 1438 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 1439 1439 + ::jacquard_lexicon::lexicon::LexString { 1440 1440 + description: None, 1441 1441 + format: None, 1442 1442 + default: None, 1443 1443 + min_length: None, 1444 1444 + max_length: None, 1445 1445 + min_graphemes: None, 1446 1446 + max_graphemes: None, 1447 1447 + r#enum: None, 1448 1448 + r#const: None, 1449 1449 + known_values: None, 1450 1450 + }, 1451 1451 + ), 1452 1452 + ); 1453 1453 + map 1454 1454 + }, 1395 1455 }, 1396 1396 - }), 1456 1456 + ), 1397 1457 ); 1398 1458 map.insert( 1399 1459 "delete".into(), ··· 1443 1503 ); 1444 1504 map.insert( 1445 1505 "deleteResult".into(), 1446 1446 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 1447 1447 - description: None, 1448 1448 - required: Some(vec![]), 1449 1449 - nullable: None, 1450 1450 - properties: { 1451 1451 - let mut map = ::std::collections::BTreeMap::new(); 1452 1452 - map 1506 1506 + ::jacquard_lexicon::lexicon::LexUserType::Object( 1507 1507 + ::jacquard_lexicon::lexicon::LexObject { 1508 1508 + description: None, 1509 1509 + required: Some(vec![]), 1510 1510 + nullable: None, 1511 1511 + properties: { 1512 1512 + let mut map = ::std::collections::BTreeMap::new(); 1513 1513 + map 1514 1514 + }, 1453 1515 }, 1454 1454 - }), 1516 1516 + ), 1455 1517 ); 1456 1518 map.insert( 1457 1519 "main".into(), ··· 1590 1652 ); 1591 1653 map.insert( 1592 1654 "updateResult".into(), 1593 1593 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 1594 1594 - description: None, 1595 1595 - required: Some(vec!["uri".into(), "cid".into()]), 1596 1596 - nullable: None, 1597 1597 - properties: { 1598 1598 - let mut map = ::std::collections::BTreeMap::new(); 1599 1599 - map.insert( 1600 1600 - "cid".into(), 1601 1601 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 1602 1602 - description: None, 1603 1603 - format: Some( 1604 1604 - ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 1655 1655 + ::jacquard_lexicon::lexicon::LexUserType::Object( 1656 1656 + ::jacquard_lexicon::lexicon::LexObject { 1657 1657 + description: None, 1658 1658 + required: Some(vec!["uri".into(), "cid".into()]), 1659 1659 + nullable: None, 1660 1660 + properties: { 1661 1661 + let mut map = ::std::collections::BTreeMap::new(); 1662 1662 + map.insert( 1663 1663 + "cid".into(), 1664 1664 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 1665 1665 + ::jacquard_lexicon::lexicon::LexString { 1666 1666 + description: None, 1667 1667 + format: Some( 1668 1668 + ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 1669 1669 + ), 1670 1670 + default: None, 1671 1671 + min_length: None, 1672 1672 + max_length: None, 1673 1673 + min_graphemes: None, 1674 1674 + max_graphemes: None, 1675 1675 + r#enum: None, 1676 1676 + r#const: None, 1677 1677 + known_values: None, 1678 1678 + }, 1605 1679 ), 1606 1606 - default: None, 1607 1607 - min_length: None, 1608 1608 - max_length: None, 1609 1609 - min_graphemes: None, 1610 1610 - max_graphemes: None, 1611 1611 - r#enum: None, 1612 1612 - r#const: None, 1613 1613 - known_values: None, 1614 1614 - }), 1615 1615 - ); 1616 1616 - map.insert( 1617 1617 - "uri".into(), 1618 1618 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 1619 1619 - description: None, 1620 1620 - format: Some( 1621 1621 - ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 1680 1680 + ); 1681 1681 + map.insert( 1682 1682 + "uri".into(), 1683 1683 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 1684 1684 + ::jacquard_lexicon::lexicon::LexString { 1685 1685 + description: None, 1686 1686 + format: Some( 1687 1687 + ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 1688 1688 + ), 1689 1689 + default: None, 1690 1690 + min_length: None, 1691 1691 + max_length: None, 1692 1692 + min_graphemes: None, 1693 1693 + max_graphemes: None, 1694 1694 + r#enum: None, 1695 1695 + r#const: None, 1696 1696 + known_values: None, 1697 1697 + }, 1698 1698 + ), 1699 1699 + ); 1700 1700 + map.insert( 1701 1701 + "validationStatus".into(), 1702 1702 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 1703 1703 + ::jacquard_lexicon::lexicon::LexString { 1704 1704 + description: None, 1705 1705 + format: None, 1706 1706 + default: None, 1707 1707 + min_length: None, 1708 1708 + max_length: None, 1709 1709 + min_graphemes: None, 1710 1710 + max_graphemes: None, 1711 1711 + r#enum: None, 1712 1712 + r#const: None, 1713 1713 + known_values: None, 1714 1714 + }, 1622 1715 ), 1623 1623 - default: None, 1624 1624 - min_length: None, 1625 1625 - max_length: None, 1626 1626 - min_graphemes: None, 1627 1627 - max_graphemes: None, 1628 1628 - r#enum: None, 1629 1629 - r#const: None, 1630 1630 - known_values: None, 1631 1631 - }), 1632 1632 - ); 1633 1633 - map.insert( 1634 1634 - "validationStatus".into(), 1635 1635 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 1636 1636 - description: None, 1637 1637 - format: None, 1638 1638 - default: None, 1639 1639 - min_length: None, 1640 1640 - max_length: None, 1641 1641 - min_graphemes: None, 1642 1642 - max_graphemes: None, 1643 1643 - r#enum: None, 1644 1644 - r#const: None, 1645 1645 - known_values: None, 1646 1646 - }), 1647 1647 - ); 1648 1648 - map 1716 1716 + ); 1717 1717 + map 1718 1718 + }, 1649 1719 }, 1650 1650 - }), 1720 1720 + ), 1651 1721 ); 1652 1722 map 1653 1723 }, 1654 1724 } 1655 1725 } 1656 1656 - fn validate( 1657 1657 - &self, 1658 1658 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1726 1726 + fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1659 1727 Ok(()) 1660 1728 } 1661 1729 } ··· 1669 1737 PartialEq, 1670 1738 Eq, 1671 1739 bon::Builder, 1672 1672 - jacquard_derive::IntoStatic 1740 1740 + jacquard_derive::IntoStatic, 1673 1741 )] 1674 1742 #[serde(rename_all = "camelCase")] 1675 1743 #[builder(start_fn = new)] ··· 1698 1766 } 1699 1767 1700 1768 #[derive( 1701 1701 - serde::Serialize, 1702 1702 - serde::Deserialize, 1703 1703 - Debug, 1704 1704 - Clone, 1705 1705 - PartialEq, 1706 1706 - Eq, 1707 1707 - jacquard_derive::IntoStatic 1769 1769 + serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic, 1708 1770 )] 1709 1771 #[serde(tag = "$type")] 1710 1772 #[serde(bound(deserialize = "'de: 'a"))] ··· 1726 1788 PartialEq, 1727 1789 Eq, 1728 1790 jacquard_derive::IntoStatic, 1729 1729 - Default 1791 1791 + Default, 1730 1792 )] 1731 1793 #[serde(rename_all = "camelCase")] 1732 1794 pub struct ApplyWritesOutput<'a> { ··· 1739 1801 } 1740 1802 1741 1803 #[derive( 1742 1742 - serde::Serialize, 1743 1743 - serde::Deserialize, 1744 1744 - Debug, 1745 1745 - Clone, 1746 1746 - PartialEq, 1747 1747 - Eq, 1748 1748 - jacquard_derive::IntoStatic 1804 1804 + serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic, 1749 1805 )] 1750 1806 #[serde(tag = "$type")] 1751 1807 #[serde(bound(deserialize = "'de: 'a"))] ··· 1768 1824 Eq, 1769 1825 thiserror::Error, 1770 1826 miette::Diagnostic, 1771 1771 - jacquard_derive::IntoStatic 1827 1827 + jacquard_derive::IntoStatic, 1772 1828 )] 1773 1829 #[serde(tag = "error", content = "message")] 1774 1830 #[serde(bound(deserialize = "'de: 'a"))] ··· 1805 1861 1806 1862 impl<'a> jacquard_common::xrpc::XrpcRequest for ApplyWrites<'a> { 1807 1863 const NSID: &'static str = "com.atproto.repo.applyWrites"; 1808 1808 - const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure( 1809 1809 - "application/json", 1810 1810 - ); 1864 1864 + const METHOD: jacquard_common::xrpc::XrpcMethod = 1865 1865 + jacquard_common::xrpc::XrpcMethod::Procedure("application/json"); 1811 1866 type Response = ApplyWritesResponse; 1812 1867 } 1813 1868 ··· 1816 1871 pub struct ApplyWritesRequest; 1817 1872 impl jacquard_common::xrpc::XrpcEndpoint for ApplyWritesRequest { 1818 1873 const PATH: &'static str = "/xrpc/com.atproto.repo.applyWrites"; 1819 1819 - const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure( 1820 1820 - "application/json", 1821 1821 - ); 1874 1874 + const METHOD: jacquard_common::xrpc::XrpcMethod = 1875 1875 + jacquard_common::xrpc::XrpcMethod::Procedure("application/json"); 1822 1876 type Request<'de> = ApplyWrites<'de>; 1823 1877 type Response = ApplyWritesResponse; 1824 1878 } ··· 1833 1887 PartialEq, 1834 1888 Eq, 1835 1889 jacquard_derive::IntoStatic, 1836 1836 - bon::Builder 1890 1890 + bon::Builder, 1837 1891 )] 1838 1892 #[serde(rename_all = "camelCase")] 1839 1893 pub struct Update<'a> { 1840 1894 #[serde(borrow)] 1841 1895 pub collection: jacquard_common::types::string::Nsid<'a>, 1842 1896 #[serde(borrow)] 1843 1843 - pub rkey: jacquard_common::types::string::RecordKey< 1844 1844 - jacquard_common::types::string::Rkey<'a>, 1845 1845 - >, 1897 1897 + pub rkey: jacquard_common::types::string::RecordKey<jacquard_common::types::string::Rkey<'a>>, 1846 1898 #[serde(borrow)] 1847 1899 pub value: jacquard_common::types::value::Data<'a>, 1848 1900 } ··· 1915 1967 ); 1916 1968 map.insert( 1917 1969 "createResult".into(), 1918 1918 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 1919 1919 - description: None, 1920 1920 - required: Some(vec!["uri".into(), "cid".into()]), 1921 1921 - nullable: None, 1922 1922 - properties: { 1923 1923 - let mut map = ::std::collections::BTreeMap::new(); 1924 1924 - map.insert( 1925 1925 - "cid".into(), 1926 1926 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 1927 1927 - description: None, 1928 1928 - format: Some( 1929 1929 - ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 1970 1970 + ::jacquard_lexicon::lexicon::LexUserType::Object( 1971 1971 + ::jacquard_lexicon::lexicon::LexObject { 1972 1972 + description: None, 1973 1973 + required: Some(vec!["uri".into(), "cid".into()]), 1974 1974 + nullable: None, 1975 1975 + properties: { 1976 1976 + let mut map = ::std::collections::BTreeMap::new(); 1977 1977 + map.insert( 1978 1978 + "cid".into(), 1979 1979 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 1980 1980 + ::jacquard_lexicon::lexicon::LexString { 1981 1981 + description: None, 1982 1982 + format: Some( 1983 1983 + ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 1984 1984 + ), 1985 1985 + default: None, 1986 1986 + min_length: None, 1987 1987 + max_length: None, 1988 1988 + min_graphemes: None, 1989 1989 + max_graphemes: None, 1990 1990 + r#enum: None, 1991 1991 + r#const: None, 1992 1992 + known_values: None, 1993 1993 + }, 1930 1994 ), 1931 1931 - default: None, 1932 1932 - min_length: None, 1933 1933 - max_length: None, 1934 1934 - min_graphemes: None, 1935 1935 - max_graphemes: None, 1936 1936 - r#enum: None, 1937 1937 - r#const: None, 1938 1938 - known_values: None, 1939 1939 - }), 1940 1940 - ); 1941 1941 - map.insert( 1942 1942 - "uri".into(), 1943 1943 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 1944 1944 - description: None, 1945 1945 - format: Some( 1946 1946 - ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 1995 1995 + ); 1996 1996 + map.insert( 1997 1997 + "uri".into(), 1998 1998 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 1999 1999 + ::jacquard_lexicon::lexicon::LexString { 2000 2000 + description: None, 2001 2001 + format: Some( 2002 2002 + ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 2003 2003 + ), 2004 2004 + default: None, 2005 2005 + min_length: None, 2006 2006 + max_length: None, 2007 2007 + min_graphemes: None, 2008 2008 + max_graphemes: None, 2009 2009 + r#enum: None, 2010 2010 + r#const: None, 2011 2011 + known_values: None, 2012 2012 + }, 2013 2013 + ), 2014 2014 + ); 2015 2015 + map.insert( 2016 2016 + "validationStatus".into(), 2017 2017 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 2018 2018 + ::jacquard_lexicon::lexicon::LexString { 2019 2019 + description: None, 2020 2020 + format: None, 2021 2021 + default: None, 2022 2022 + min_length: None, 2023 2023 + max_length: None, 2024 2024 + min_graphemes: None, 2025 2025 + max_graphemes: None, 2026 2026 + r#enum: None, 2027 2027 + r#const: None, 2028 2028 + known_values: None, 2029 2029 + }, 1947 2030 ), 1948 1948 - default: None, 1949 1949 - min_length: None, 1950 1950 - max_length: None, 1951 1951 - min_graphemes: None, 1952 1952 - max_graphemes: None, 1953 1953 - r#enum: None, 1954 1954 - r#const: None, 1955 1955 - known_values: None, 1956 1956 - }), 1957 1957 - ); 1958 1958 - map.insert( 1959 1959 - "validationStatus".into(), 1960 1960 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 1961 1961 - description: None, 1962 1962 - format: None, 1963 1963 - default: None, 1964 1964 - min_length: None, 1965 1965 - max_length: None, 1966 1966 - min_graphemes: None, 1967 1967 - max_graphemes: None, 1968 1968 - r#enum: None, 1969 1969 - r#const: None, 1970 1970 - known_values: None, 1971 1971 - }), 1972 1972 - ); 1973 1973 - map 2031 2031 + ); 2032 2032 + map 2033 2033 + }, 1974 2034 }, 1975 1975 - }), 2035 2035 + ), 1976 2036 ); 1977 2037 map.insert( 1978 2038 "delete".into(), ··· 2022 2082 ); 2023 2083 map.insert( 2024 2084 "deleteResult".into(), 2025 2025 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 2026 2026 - description: None, 2027 2027 - required: Some(vec![]), 2028 2028 - nullable: None, 2029 2029 - properties: { 2030 2030 - let mut map = ::std::collections::BTreeMap::new(); 2031 2031 - map 2085 2085 + ::jacquard_lexicon::lexicon::LexUserType::Object( 2086 2086 + ::jacquard_lexicon::lexicon::LexObject { 2087 2087 + description: None, 2088 2088 + required: Some(vec![]), 2089 2089 + nullable: None, 2090 2090 + properties: { 2091 2091 + let mut map = ::std::collections::BTreeMap::new(); 2092 2092 + map 2093 2093 + }, 2032 2094 }, 2033 2033 - }), 2095 2095 + ), 2034 2096 ); 2035 2097 map.insert( 2036 2098 "main".into(), ··· 2169 2231 ); 2170 2232 map.insert( 2171 2233 "updateResult".into(), 2172 2172 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 2173 2173 - description: None, 2174 2174 - required: Some(vec!["uri".into(), "cid".into()]), 2175 2175 - nullable: None, 2176 2176 - properties: { 2177 2177 - let mut map = ::std::collections::BTreeMap::new(); 2178 2178 - map.insert( 2179 2179 - "cid".into(), 2180 2180 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 2181 2181 - description: None, 2182 2182 - format: Some( 2183 2183 - ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 2234 2234 + ::jacquard_lexicon::lexicon::LexUserType::Object( 2235 2235 + ::jacquard_lexicon::lexicon::LexObject { 2236 2236 + description: None, 2237 2237 + required: Some(vec!["uri".into(), "cid".into()]), 2238 2238 + nullable: None, 2239 2239 + properties: { 2240 2240 + let mut map = ::std::collections::BTreeMap::new(); 2241 2241 + map.insert( 2242 2242 + "cid".into(), 2243 2243 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 2244 2244 + ::jacquard_lexicon::lexicon::LexString { 2245 2245 + description: None, 2246 2246 + format: Some( 2247 2247 + ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 2248 2248 + ), 2249 2249 + default: None, 2250 2250 + min_length: None, 2251 2251 + max_length: None, 2252 2252 + min_graphemes: None, 2253 2253 + max_graphemes: None, 2254 2254 + r#enum: None, 2255 2255 + r#const: None, 2256 2256 + known_values: None, 2257 2257 + }, 2184 2258 ), 2185 2185 - default: None, 2186 2186 - min_length: None, 2187 2187 - max_length: None, 2188 2188 - min_graphemes: None, 2189 2189 - max_graphemes: None, 2190 2190 - r#enum: None, 2191 2191 - r#const: None, 2192 2192 - known_values: None, 2193 2193 - }), 2194 2194 - ); 2195 2195 - map.insert( 2196 2196 - "uri".into(), 2197 2197 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 2198 2198 - description: None, 2199 2199 - format: Some( 2200 2200 - ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 2259 2259 + ); 2260 2260 + map.insert( 2261 2261 + "uri".into(), 2262 2262 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 2263 2263 + ::jacquard_lexicon::lexicon::LexString { 2264 2264 + description: None, 2265 2265 + format: Some( 2266 2266 + ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 2267 2267 + ), 2268 2268 + default: None, 2269 2269 + min_length: None, 2270 2270 + max_length: None, 2271 2271 + min_graphemes: None, 2272 2272 + max_graphemes: None, 2273 2273 + r#enum: None, 2274 2274 + r#const: None, 2275 2275 + known_values: None, 2276 2276 + }, 2201 2277 ), 2202 2202 - default: None, 2203 2203 - min_length: None, 2204 2204 - max_length: None, 2205 2205 - min_graphemes: None, 2206 2206 - max_graphemes: None, 2207 2207 - r#enum: None, 2208 2208 - r#const: None, 2209 2209 - known_values: None, 2210 2210 - }), 2211 2211 - ); 2212 2212 - map.insert( 2213 2213 - "validationStatus".into(), 2214 2214 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 2215 2215 - description: None, 2216 2216 - format: None, 2217 2217 - default: None, 2218 2218 - min_length: None, 2219 2219 - max_length: None, 2220 2220 - min_graphemes: None, 2221 2221 - max_graphemes: None, 2222 2222 - r#enum: None, 2223 2223 - r#const: None, 2224 2224 - known_values: None, 2225 2225 - }), 2226 2226 - ); 2227 2227 - map 2278 2278 + ); 2279 2279 + map.insert( 2280 2280 + "validationStatus".into(), 2281 2281 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 2282 2282 + ::jacquard_lexicon::lexicon::LexString { 2283 2283 + description: None, 2284 2284 + format: None, 2285 2285 + default: None, 2286 2286 + min_length: None, 2287 2287 + max_length: None, 2288 2288 + min_graphemes: None, 2289 2289 + max_graphemes: None, 2290 2290 + r#enum: None, 2291 2291 + r#const: None, 2292 2292 + known_values: None, 2293 2293 + }, 2294 2294 + ), 2295 2295 + ); 2296 2296 + map 2297 2297 + }, 2228 2298 }, 2229 2229 - }), 2299 2299 + ), 2230 2300 ); 2231 2301 map 2232 2302 }, 2233 2303 } 2234 2304 } 2235 2235 - fn validate( 2236 2236 - &self, 2237 2237 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2305 2305 + fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2238 2306 Ok(()) 2239 2307 } 2240 2308 } ··· 2248 2316 PartialEq, 2249 2317 Eq, 2250 2318 jacquard_derive::IntoStatic, 2251 2251 - bon::Builder 2319 2319 + bon::Builder, 2252 2320 )] 2253 2321 #[serde(rename_all = "camelCase")] 2254 2322 pub struct UpdateResult<'a> { ··· 2330 2398 ); 2331 2399 map.insert( 2332 2400 "createResult".into(), 2333 2333 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 2334 2334 - description: None, 2335 2335 - required: Some(vec!["uri".into(), "cid".into()]), 2336 2336 - nullable: None, 2337 2337 - properties: { 2338 2338 - let mut map = ::std::collections::BTreeMap::new(); 2339 2339 - map.insert( 2340 2340 - "cid".into(), 2341 2341 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 2342 2342 - description: None, 2343 2343 - format: Some( 2344 2344 - ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 2401 2401 + ::jacquard_lexicon::lexicon::LexUserType::Object( 2402 2402 + ::jacquard_lexicon::lexicon::LexObject { 2403 2403 + description: None, 2404 2404 + required: Some(vec!["uri".into(), "cid".into()]), 2405 2405 + nullable: None, 2406 2406 + properties: { 2407 2407 + let mut map = ::std::collections::BTreeMap::new(); 2408 2408 + map.insert( 2409 2409 + "cid".into(), 2410 2410 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 2411 2411 + ::jacquard_lexicon::lexicon::LexString { 2412 2412 + description: None, 2413 2413 + format: Some( 2414 2414 + ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 2415 2415 + ), 2416 2416 + default: None, 2417 2417 + min_length: None, 2418 2418 + max_length: None, 2419 2419 + min_graphemes: None, 2420 2420 + max_graphemes: None, 2421 2421 + r#enum: None, 2422 2422 + r#const: None, 2423 2423 + known_values: None, 2424 2424 + }, 2345 2425 ), 2346 2346 - default: None, 2347 2347 - min_length: None, 2348 2348 - max_length: None, 2349 2349 - min_graphemes: None, 2350 2350 - max_graphemes: None, 2351 2351 - r#enum: None, 2352 2352 - r#const: None, 2353 2353 - known_values: None, 2354 2354 - }), 2355 2355 - ); 2356 2356 - map.insert( 2357 2357 - "uri".into(), 2358 2358 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 2359 2359 - description: None, 2360 2360 - format: Some( 2361 2361 - ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 2426 2426 + ); 2427 2427 + map.insert( 2428 2428 + "uri".into(), 2429 2429 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 2430 2430 + ::jacquard_lexicon::lexicon::LexString { 2431 2431 + description: None, 2432 2432 + format: Some( 2433 2433 + ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 2434 2434 + ), 2435 2435 + default: None, 2436 2436 + min_length: None, 2437 2437 + max_length: None, 2438 2438 + min_graphemes: None, 2439 2439 + max_graphemes: None, 2440 2440 + r#enum: None, 2441 2441 + r#const: None, 2442 2442 + known_values: None, 2443 2443 + }, 2362 2444 ), 2363 2363 - default: None, 2364 2364 - min_length: None, 2365 2365 - max_length: None, 2366 2366 - min_graphemes: None, 2367 2367 - max_graphemes: None, 2368 2368 - r#enum: None, 2369 2369 - r#const: None, 2370 2370 - known_values: None, 2371 2371 - }), 2372 2372 - ); 2373 2373 - map.insert( 2374 2374 - "validationStatus".into(), 2375 2375 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 2376 2376 - description: None, 2377 2377 - format: None, 2378 2378 - default: None, 2379 2379 - min_length: None, 2380 2380 - max_length: None, 2381 2381 - min_graphemes: None, 2382 2382 - max_graphemes: None, 2383 2383 - r#enum: None, 2384 2384 - r#const: None, 2385 2385 - known_values: None, 2386 2386 - }), 2387 2387 - ); 2388 2388 - map 2445 2445 + ); 2446 2446 + map.insert( 2447 2447 + "validationStatus".into(), 2448 2448 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 2449 2449 + ::jacquard_lexicon::lexicon::LexString { 2450 2450 + description: None, 2451 2451 + format: None, 2452 2452 + default: None, 2453 2453 + min_length: None, 2454 2454 + max_length: None, 2455 2455 + min_graphemes: None, 2456 2456 + max_graphemes: None, 2457 2457 + r#enum: None, 2458 2458 + r#const: None, 2459 2459 + known_values: None, 2460 2460 + }, 2461 2461 + ), 2462 2462 + ); 2463 2463 + map 2464 2464 + }, 2389 2465 }, 2390 2390 - }), 2466 2466 + ), 2391 2467 ); 2392 2468 map.insert( 2393 2469 "delete".into(), ··· 2437 2513 ); 2438 2514 map.insert( 2439 2515 "deleteResult".into(), 2440 2440 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 2441 2441 - description: None, 2442 2442 - required: Some(vec![]), 2443 2443 - nullable: None, 2444 2444 - properties: { 2445 2445 - let mut map = ::std::collections::BTreeMap::new(); 2446 2446 - map 2516 2516 + ::jacquard_lexicon::lexicon::LexUserType::Object( 2517 2517 + ::jacquard_lexicon::lexicon::LexObject { 2518 2518 + description: None, 2519 2519 + required: Some(vec![]), 2520 2520 + nullable: None, 2521 2521 + properties: { 2522 2522 + let mut map = ::std::collections::BTreeMap::new(); 2523 2523 + map 2524 2524 + }, 2447 2525 }, 2448 2448 - }), 2526 2526 + ), 2449 2527 ); 2450 2528 map.insert( 2451 2529 "main".into(), ··· 2584 2662 ); 2585 2663 map.insert( 2586 2664 "updateResult".into(), 2587 2587 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 2588 2588 - description: None, 2589 2589 - required: Some(vec!["uri".into(), "cid".into()]), 2590 2590 - nullable: None, 2591 2591 - properties: { 2592 2592 - let mut map = ::std::collections::BTreeMap::new(); 2593 2593 - map.insert( 2594 2594 - "cid".into(), 2595 2595 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 2596 2596 - description: None, 2597 2597 - format: Some( 2598 2598 - ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 2665 2665 + ::jacquard_lexicon::lexicon::LexUserType::Object( 2666 2666 + ::jacquard_lexicon::lexicon::LexObject { 2667 2667 + description: None, 2668 2668 + required: Some(vec!["uri".into(), "cid".into()]), 2669 2669 + nullable: None, 2670 2670 + properties: { 2671 2671 + let mut map = ::std::collections::BTreeMap::new(); 2672 2672 + map.insert( 2673 2673 + "cid".into(), 2674 2674 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 2675 2675 + ::jacquard_lexicon::lexicon::LexString { 2676 2676 + description: None, 2677 2677 + format: Some( 2678 2678 + ::jacquard_lexicon::lexicon::LexStringFormat::Cid, 2679 2679 + ), 2680 2680 + default: None, 2681 2681 + min_length: None, 2682 2682 + max_length: None, 2683 2683 + min_graphemes: None, 2684 2684 + max_graphemes: None, 2685 2685 + r#enum: None, 2686 2686 + r#const: None, 2687 2687 + known_values: None, 2688 2688 + }, 2599 2689 ), 2600 2600 - default: None, 2601 2601 - min_length: None, 2602 2602 - max_length: None, 2603 2603 - min_graphemes: None, 2604 2604 - max_graphemes: None, 2605 2605 - r#enum: None, 2606 2606 - r#const: None, 2607 2607 - known_values: None, 2608 2608 - }), 2609 2609 - ); 2610 2610 - map.insert( 2611 2611 - "uri".into(), 2612 2612 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 2613 2613 - description: None, 2614 2614 - format: Some( 2615 2615 - ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 2690 2690 + ); 2691 2691 + map.insert( 2692 2692 + "uri".into(), 2693 2693 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 2694 2694 + ::jacquard_lexicon::lexicon::LexString { 2695 2695 + description: None, 2696 2696 + format: Some( 2697 2697 + ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 2698 2698 + ), 2699 2699 + default: None, 2700 2700 + min_length: None, 2701 2701 + max_length: None, 2702 2702 + min_graphemes: None, 2703 2703 + max_graphemes: None, 2704 2704 + r#enum: None, 2705 2705 + r#const: None, 2706 2706 + known_values: None, 2707 2707 + }, 2708 2708 + ), 2709 2709 + ); 2710 2710 + map.insert( 2711 2711 + "validationStatus".into(), 2712 2712 + ::jacquard_lexicon::lexicon::LexObjectProperty::String( 2713 2713 + ::jacquard_lexicon::lexicon::LexString { 2714 2714 + description: None, 2715 2715 + format: None, 2716 2716 + default: None, 2717 2717 + min_length: None, 2718 2718 + max_length: None, 2719 2719 + min_graphemes: None, 2720 2720 + max_graphemes: None, 2721 2721 + r#enum: None, 2722 2722 + r#const: None, 2723 2723 + known_values: None, 2724 2724 + }, 2616 2725 ), 2617 2617 - default: None, 2618 2618 - min_length: None, 2619 2619 - max_length: None, 2620 2620 - min_graphemes: None, 2621 2621 - max_graphemes: None, 2622 2622 - r#enum: None, 2623 2623 - r#const: None, 2624 2624 - known_values: None, 2625 2625 - }), 2626 2626 - ); 2627 2627 - map.insert( 2628 2628 - "validationStatus".into(), 2629 2629 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 2630 2630 - description: None, 2631 2631 - format: None, 2632 2632 - default: None, 2633 2633 - min_length: None, 2634 2634 - max_length: None, 2635 2635 - min_graphemes: None, 2636 2636 - max_graphemes: None, 2637 2637 - r#enum: None, 2638 2638 - r#const: None, 2639 2639 - known_values: None, 2640 2640 - }), 2641 2641 - ); 2642 2642 - map 2726 2726 + ); 2727 2727 + map 2728 2728 + }, 2643 2729 }, 2644 2644 - }), 2730 2730 + ), 2645 2731 ); 2646 2732 map 2647 2733 }, 2648 2734 } 2649 2735 } 2650 2650 - fn validate( 2651 2651 - &self, 2652 2652 - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2736 2736 + fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2653 2737 Ok(()) 2654 2738 } 2655 2655 - } 2739 2739 + }

+10

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

reviewed

··· 1177 1177 fn validate( 1178 1178 &self, 1179 1179 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1180 1180 + { 1181 1181 + let value = &self.ops; 1182 1182 + if value.len() > 200usize { 1183 1183 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1184 1184 + field: "ops", 1185 1185 + max: 200usize, 1186 1186 + actual: value.len(), 1187 1187 + }); 1188 1188 + } 1189 1189 + } 1180 1190 Ok(()) 1181 1191 } 1182 1192 }

+9

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

reviewed

··· 534 534 fn validate( 535 535 &self, 536 536 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 537 537 + if let Some(ref value) = self.tags { 538 538 + if value.len() > 10usize { 539 539 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 540 540 + field: "tags", 541 541 + max: 10usize, 542 542 + actual: value.len(), 543 543 + }); 544 544 + } 545 545 + } 537 546 Ok(()) 538 547 } 539 548 }

-18

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

reviewed

··· 175 175 fn validate( 176 176 &self, 177 177 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 178 178 - if let Some(ref value) = self.tags { 179 179 - if value.len() > 10usize { 180 180 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 181 181 - field: "tags", 182 182 - max: 10usize, 183 183 - actual: value.len(), 184 184 - }); 185 185 - } 186 186 - } 187 178 Ok(()) 188 179 } 189 180 } ··· 358 349 fn validate( 359 350 &self, 360 351 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 361 361 - if let Some(ref value) = self.tags { 362 362 - if value.len() > 10usize { 363 363 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 364 364 - field: "tags", 365 365 - max: 10usize, 366 366 - actual: value.len(), 367 367 - }); 368 368 - } 369 369 - } 370 352 Ok(()) 371 353 } 372 354 }

+10 -42

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

reviewed

··· 447 447 fn validate( 448 448 &self, 449 449 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 450 450 - if let Some(ref value) = self.bio { 451 451 - if value.len() > 2400usize { 452 452 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 453 453 - field: "bio", 454 454 - max: 2400usize, 455 455 - actual: value.len(), 456 456 - }); 457 457 - } 458 458 - } 459 459 - if let Some(ref value) = self.bio { 460 460 - { 461 461 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 462 462 - value.as_ref(), 463 463 - true, 464 464 - ) 465 465 - .count(); 466 466 - if count > 240usize { 467 467 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 468 468 - field: "bio", 469 469 - max: 240usize, 470 470 - actual: count, 471 471 - }); 472 472 - } 473 473 - } 474 474 - } 475 475 - if let Some(ref value) = self.links { 476 476 - if value.len() > 5usize { 477 477 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 478 478 - field: "links", 479 479 - max: 5usize, 480 480 - actual: value.len(), 481 481 - }); 482 482 - } 483 483 - } 484 484 - if let Some(ref value) = self.nickname { 485 485 - if value.len() > 640usize { 450 450 + { 451 451 + let value = &self.name; 452 452 + if value.len() > 500usize { 486 453 return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 487 487 - field: "nickname", 488 488 - max: 640usize, 454 454 + field: "name", 455 455 + max: 500usize, 489 456 actual: value.len(), 490 457 }); 491 458 } 492 459 } 493 493 - if let Some(ref value) = self.nickname { 460 460 + { 461 461 + let value = &self.name; 494 462 { 495 463 let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 496 464 value.as_ref(), 497 465 true, 498 466 ) 499 467 .count(); 500 500 - if count > 64usize { 468 468 + if count > 50usize { 501 469 return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 502 502 - field: "nickname", 503 503 - max: 64usize, 470 470 + field: "name", 471 471 + max: 50usize, 504 472 actual: count, 505 473 }); 506 474 }

+20

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

reviewed

··· 445 445 fn validate( 446 446 &self, 447 447 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 448 448 + { 449 449 + let value = &self.content; 450 450 + if value.len() > 100000usize { 451 451 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 452 452 + field: "content", 453 453 + max: 100000usize, 454 454 + actual: value.len(), 455 455 + }); 456 456 + } 457 457 + } 448 458 Ok(()) 449 459 } 450 460 } ··· 664 674 fn validate( 665 675 &self, 666 676 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 677 677 + { 678 678 + let value = &self.content; 679 679 + if value.len() > 1000usize { 680 680 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 681 681 + field: "content", 682 682 + max: 1000usize, 683 683 + actual: value.len(), 684 684 + }); 685 685 + } 686 686 + } 667 687 Ok(()) 668 688 } 669 689 }

-50

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

reviewed

··· 187 187 fn validate( 188 188 &self, 189 189 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 190 190 - if let Some(ref value) = self.description { 191 191 - if value.len() > 2560usize { 192 192 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 193 193 - field: "description", 194 194 - max: 2560usize, 195 195 - actual: value.len(), 196 196 - }); 197 197 - } 198 198 - } 199 199 - if let Some(ref value) = self.description { 200 200 - { 201 201 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 202 202 - value.as_ref(), 203 203 - true, 204 204 - ) 205 205 - .count(); 206 206 - if count > 256usize { 207 207 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 208 208 - field: "description", 209 209 - max: 256usize, 210 210 - actual: count, 211 211 - }); 212 212 - } 213 213 - } 214 214 - } 215 215 - if let Some(ref value) = self.display_name { 216 216 - if value.len() > 640usize { 217 217 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 218 218 - field: "display_name", 219 219 - max: 640usize, 220 220 - actual: value.len(), 221 221 - }); 222 222 - } 223 223 - } 224 224 - if let Some(ref value) = self.display_name { 225 225 - { 226 226 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 227 227 - value.as_ref(), 228 228 - true, 229 229 - ) 230 230 - .count(); 231 231 - if count > 64usize { 232 232 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 233 233 - field: "display_name", 234 234 - max: 64usize, 235 235 - actual: count, 236 236 - }); 237 237 - } 238 238 - } 239 239 - } 240 190 Ok(()) 241 191 } 242 192 }

+124

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

reviewed

··· 281 281 fn validate( 282 282 &self, 283 283 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 284 284 + { 285 285 + let value = &self.artist_name; 286 286 + if value.len() > 256usize { 287 287 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 288 288 + field: "artist_name", 289 289 + max: 256usize, 290 290 + actual: value.len(), 291 291 + }); 292 292 + } 293 293 + } 294 294 + { 295 295 + let value = &self.artist_name; 296 296 + if value.len() < 1usize { 297 297 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 298 298 + field: "artist_name", 299 299 + min: 1usize, 300 300 + actual: value.len(), 301 301 + }); 302 302 + } 303 303 + } 304 304 + { 305 305 + let value = &self.artist_name; 306 306 + { 307 307 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 308 308 + value.as_ref(), 309 309 + true, 310 310 + ) 311 311 + .count(); 312 312 + if count > 2560usize { 313 313 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 314 314 + field: "artist_name", 315 315 + max: 2560usize, 316 316 + actual: count, 317 317 + }); 318 318 + } 319 319 + } 320 320 + } 284 321 Ok(()) 285 322 } 286 323 } ··· 605 642 fn validate( 606 643 &self, 607 644 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 645 645 + if let Some(ref value) = self.release_name { 646 646 + if value.len() > 256usize { 647 647 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 648 648 + field: "release_name", 649 649 + max: 256usize, 650 650 + actual: value.len(), 651 651 + }); 652 652 + } 653 653 + } 654 654 + if let Some(ref value) = self.release_name { 655 655 + { 656 656 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 657 657 + value.as_ref(), 658 658 + true, 659 659 + ) 660 660 + .count(); 661 661 + if count > 2560usize { 662 662 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 663 663 + field: "release_name", 664 664 + max: 2560usize, 665 665 + actual: count, 666 666 + }); 667 667 + } 668 668 + } 669 669 + } 670 670 + if let Some(ref value) = self.submission_client_agent { 671 671 + if value.len() > 256usize { 672 672 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 673 673 + field: "submission_client_agent", 674 674 + max: 256usize, 675 675 + actual: value.len(), 676 676 + }); 677 677 + } 678 678 + } 679 679 + if let Some(ref value) = self.submission_client_agent { 680 680 + { 681 681 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 682 682 + value.as_ref(), 683 683 + true, 684 684 + ) 685 685 + .count(); 686 686 + if count > 2560usize { 687 687 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 688 688 + field: "submission_client_agent", 689 689 + max: 2560usize, 690 690 + actual: count, 691 691 + }); 692 692 + } 693 693 + } 694 694 + } 695 695 + { 696 696 + let value = &self.track_name; 697 697 + if value.len() > 256usize { 698 698 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 699 699 + field: "track_name", 700 700 + max: 256usize, 701 701 + actual: value.len(), 702 702 + }); 703 703 + } 704 704 + } 705 705 + { 706 706 + let value = &self.track_name; 707 707 + if value.len() < 1usize { 708 708 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 709 709 + field: "track_name", 710 710 + min: 1usize, 711 711 + actual: value.len(), 712 712 + }); 713 713 + } 714 714 + } 715 715 + { 716 716 + let value = &self.track_name; 717 717 + { 718 718 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 719 719 + value.as_ref(), 720 720 + true, 721 721 + ) 722 722 + .count(); 723 723 + if count > 2560usize { 724 724 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 725 725 + field: "track_name", 726 726 + max: 2560usize, 727 727 + actual: count, 728 728 + }); 729 729 + } 730 730 + } 731 731 + } 608 732 Ok(()) 609 733 } 610 734 }

-27

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

reviewed

··· 345 345 fn validate( 346 346 &self, 347 347 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 348 348 - { 349 349 - let value = &self.title; 350 350 - if value.len() > 3000usize { 351 351 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 352 352 - field: "title", 353 353 - max: 3000usize, 354 354 - actual: value.len(), 355 355 - }); 356 356 - } 357 357 - } 358 358 - { 359 359 - let value = &self.title; 360 360 - { 361 361 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 362 362 - value.as_ref(), 363 363 - true, 364 364 - ) 365 365 - .count(); 366 366 - if count > 300usize { 367 367 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 368 368 - field: "title", 369 369 - max: 300usize, 370 370 - actual: count, 371 371 - }); 372 372 - } 373 373 - } 374 374 - } 375 348 Ok(()) 376 349 } 377 350 }

+27

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

reviewed

··· 171 171 fn validate( 172 172 &self, 173 173 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 174 174 + { 175 175 + let value = &self.text; 176 176 + if value.len() > 100000usize { 177 177 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 178 178 + field: "text", 179 179 + max: 100000usize, 180 180 + actual: value.len(), 181 181 + }); 182 182 + } 183 183 + } 184 184 + { 185 185 + let value = &self.text; 186 186 + { 187 187 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 188 188 + value.as_ref(), 189 189 + true, 190 190 + ) 191 191 + .count(); 192 192 + if count > 10000usize { 193 193 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 194 194 + field: "text", 195 195 + max: 10000usize, 196 196 + actual: count, 197 197 + }); 198 198 + } 199 199 + } 200 200 + } 174 201 Ok(()) 175 202 } 176 203 }

+20

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

reviewed

··· 688 688 fn validate( 689 689 &self, 690 690 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 691 691 + { 692 692 + let value = &self.value; 693 693 + if *value > 10i64 { 694 694 + return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 695 695 + field: "value", 696 696 + max: 10i64, 697 697 + actual: *value, 698 698 + }); 699 699 + } 700 700 + } 701 701 + { 702 702 + let value = &self.value; 703 703 + if *value < 1i64 { 704 704 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 705 705 + field: "value", 706 706 + min: 1i64, 707 707 + actual: *value, 708 708 + }); 709 709 + } 710 710 + } 691 711 Ok(()) 692 712 } 693 713 }

+59

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

reviewed

··· 234 234 fn validate( 235 235 &self, 236 236 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 237 237 + { 238 238 + let value = &self.algo; 239 239 + if value.len() > 32usize { 240 240 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 241 241 + field: "algo", 242 242 + max: 32usize, 243 243 + actual: value.len(), 244 244 + }); 245 245 + } 246 246 + } 247 247 + { 248 248 + let value = &self.hash; 249 249 + if value.len() > 128usize { 250 250 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 251 251 + field: "hash", 252 252 + max: 128usize, 253 253 + actual: value.len(), 254 254 + }); 255 255 + } 256 256 + } 237 257 Ok(()) 238 258 } 239 259 } ··· 476 496 fn validate( 477 497 &self, 478 498 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 499 499 + if let Some(ref value) = self.mime_type { 500 500 + if value.len() > 255usize { 501 501 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 502 502 + field: "mime_type", 503 503 + max: 255usize, 504 504 + actual: value.len(), 505 505 + }); 506 506 + } 507 507 + } 508 508 + { 509 509 + let value = &self.name; 510 510 + if value.len() > 512usize { 511 511 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 512 512 + field: "name", 513 513 + max: 512usize, 514 514 + actual: value.len(), 515 515 + }); 516 516 + } 517 517 + } 518 518 + { 519 519 + let value = &self.size; 520 520 + if *value > 1000000000i64 { 521 521 + return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 522 522 + field: "size", 523 523 + max: 1000000000i64, 524 524 + actual: *value, 525 525 + }); 526 526 + } 527 527 + } 528 528 + { 529 529 + let value = &self.size; 530 530 + if *value < 0i64 { 531 531 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 532 532 + field: "size", 533 533 + min: 0i64, 534 534 + actual: *value, 535 535 + }); 536 536 + } 537 537 + } 479 538 Ok(()) 480 539 } 481 540 }

-130

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

reviewed

··· 1047 1047 fn validate( 1048 1048 &self, 1049 1049 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1050 1050 - if let Some(ref value) = self.common_name { 1051 1051 - if value.len() > 200usize { 1052 1052 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1053 1053 - field: "common_name", 1054 1054 - max: 200usize, 1055 1055 - actual: value.len(), 1056 1056 - }); 1057 1057 - } 1058 1058 - } 1059 1059 - if let Some(ref value) = self.family { 1060 1060 - if value.len() > 100usize { 1061 1061 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1062 1062 - field: "family", 1063 1063 - max: 100usize, 1064 1064 - actual: value.len(), 1065 1065 - }); 1066 1066 - } 1067 1067 - } 1068 1068 - if let Some(ref value) = self.genus { 1069 1069 - if value.len() > 100usize { 1070 1070 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1071 1071 - field: "genus", 1072 1072 - max: 100usize, 1073 1073 - actual: value.len(), 1074 1074 - }); 1075 1075 - } 1076 1076 - } 1077 1077 - { 1078 1078 - let value = &self.quantity; 1079 1079 - if *value < 1i64 { 1080 1080 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1081 1081 - field: "quantity", 1082 1082 - min: 1i64, 1083 1083 - actual: *value, 1084 1084 - }); 1085 1085 - } 1086 1086 - } 1087 1087 - if let Some(ref value) = self.scientific_name { 1088 1088 - if value.len() > 200usize { 1089 1089 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1090 1090 - field: "scientific_name", 1091 1091 - max: 200usize, 1092 1092 - actual: value.len(), 1093 1093 - }); 1094 1094 - } 1095 1095 - } 1096 1096 - if let Some(ref value) = self.species { 1097 1097 - if value.len() > 100usize { 1098 1098 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1099 1099 - field: "species", 1100 1100 - max: 100usize, 1101 1101 - actual: value.len(), 1102 1102 - }); 1103 1103 - } 1104 1104 - } 1105 1105 - { 1106 1106 - let value = &self.specimen_id; 1107 1107 - if value.len() > 100usize { 1108 1108 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1109 1109 - field: "specimen_id", 1110 1110 - max: 100usize, 1111 1111 - actual: value.len(), 1112 1112 - }); 1113 1113 - } 1114 1114 - } 1115 1050 Ok(()) 1116 1051 } 1117 1052 } ··· 1535 1470 fn validate( 1536 1471 &self, 1537 1472 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1538 1538 - if let Some(ref value) = self.common_name { 1539 1539 - if value.len() > 200usize { 1540 1540 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1541 1541 - field: "common_name", 1542 1542 - max: 200usize, 1543 1543 - actual: value.len(), 1544 1544 - }); 1545 1545 - } 1546 1546 - } 1547 1547 - if let Some(ref value) = self.family { 1548 1548 - if value.len() > 100usize { 1549 1549 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1550 1550 - field: "family", 1551 1551 - max: 100usize, 1552 1552 - actual: value.len(), 1553 1553 - }); 1554 1554 - } 1555 1555 - } 1556 1556 - if let Some(ref value) = self.genus { 1557 1557 - if value.len() > 100usize { 1558 1558 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1559 1559 - field: "genus", 1560 1560 - max: 100usize, 1561 1561 - actual: value.len(), 1562 1562 - }); 1563 1563 - } 1564 1564 - } 1565 1565 - { 1566 1566 - let value = &self.quantity; 1567 1567 - if *value < 1i64 { 1568 1568 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1569 1569 - field: "quantity", 1570 1570 - min: 1i64, 1571 1571 - actual: *value, 1572 1572 - }); 1573 1573 - } 1574 1574 - } 1575 1575 - if let Some(ref value) = self.scientific_name { 1576 1576 - if value.len() > 200usize { 1577 1577 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1578 1578 - field: "scientific_name", 1579 1579 - max: 200usize, 1580 1580 - actual: value.len(), 1581 1581 - }); 1582 1582 - } 1583 1583 - } 1584 1584 - if let Some(ref value) = self.species { 1585 1585 - if value.len() > 100usize { 1586 1586 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1587 1587 - field: "species", 1588 1588 - max: 100usize, 1589 1589 - actual: value.len(), 1590 1590 - }); 1591 1591 - } 1592 1592 - } 1593 1593 - { 1594 1594 - let value = &self.specimen_id; 1595 1595 - if value.len() > 100usize { 1596 1596 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1597 1597 - field: "specimen_id", 1598 1598 - max: 100usize, 1599 1599 - actual: value.len(), 1600 1600 - }); 1601 1601 - } 1602 1602 - } 1603 1473 Ok(()) 1604 1474 } 1605 1475 }

-56

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

reviewed

··· 811 811 fn validate( 812 812 &self, 813 813 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 814 814 - { 815 815 - let value = &self.item_id; 816 816 - if value.len() > 100usize { 817 817 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 818 818 - field: "item_id", 819 819 - max: 100usize, 820 820 - actual: value.len(), 821 821 - }); 822 822 - } 823 823 - } 824 824 - if let Some(ref value) = self.item_name { 825 825 - if value.len() > 200usize { 826 826 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 827 827 - field: "item_name", 828 828 - max: 200usize, 829 829 - actual: value.len(), 830 830 - }); 831 831 - } 832 832 - } 833 833 - if let Some(ref value) = self.item_type { 834 834 - if value.len() > 50usize { 835 835 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 836 836 - field: "item_type", 837 837 - max: 50usize, 838 838 - actual: value.len(), 839 839 - }); 840 840 - } 841 841 - } 842 842 - if let Some(ref value) = self.item_value { 843 843 - if *value < 0i64 { 844 844 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 845 845 - field: "item_value", 846 846 - min: 0i64, 847 847 - actual: *value, 848 848 - }); 849 849 - } 850 850 - } 851 851 - if let Some(ref value) = self.max_stack { 852 852 - if *value < 1i64 { 853 853 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 854 854 - field: "max_stack", 855 855 - min: 1i64, 856 856 - actual: *value, 857 857 - }); 858 858 - } 859 859 - } 860 860 - { 861 861 - let value = &self.quantity; 862 862 - if *value < 1i64 { 863 863 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 864 864 - field: "quantity", 865 865 - min: 1i64, 866 866 - actual: *value, 867 867 - }); 868 868 - } 869 869 - } 870 814 Ok(()) 871 815 } 872 816 }

+105 -49

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

reviewed

··· 772 772 fn validate( 773 773 &self, 774 774 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 775 775 - { 776 776 - let value = &self.session_id; 777 777 - if value.len() > 64usize { 778 778 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 779 779 - field: "session_id", 780 780 - max: 64usize, 781 781 - actual: value.len(), 775 775 + if let Some(ref value) = self.time_since_generation { 776 776 + if *value < 0i64 { 777 777 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 778 778 + field: "time_since_generation", 779 779 + min: 0i64, 780 780 + actual: *value, 781 781 + }); 782 782 + } 783 783 + } 784 784 + if let Some(ref value) = self.time_since_viewed { 785 785 + if *value < 0i64 { 786 786 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 787 787 + field: "time_since_viewed", 788 788 + min: 0i64, 789 789 + actual: *value, 782 790 }); 783 791 } 784 792 } ··· 1542 1550 fn validate( 1543 1551 &self, 1544 1552 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1545 1545 - { 1546 1546 - let value = &self.session_id; 1547 1547 - if value.len() > 64usize { 1548 1548 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1549 1549 - field: "session_id", 1550 1550 - max: 64usize, 1551 1551 - actual: value.len(), 1553 1553 + if let Some(ref value) = self.rewards_count { 1554 1554 + if *value < 1i64 { 1555 1555 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1556 1556 + field: "rewards_count", 1557 1557 + min: 1i64, 1558 1558 + actual: *value, 1559 1559 + }); 1560 1560 + } 1561 1561 + } 1562 1562 + if let Some(ref value) = self.streak { 1563 1563 + if *value < 1i64 { 1564 1564 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1565 1565 + field: "streak", 1566 1566 + min: 1i64, 1567 1567 + actual: *value, 1568 1568 + }); 1569 1569 + } 1570 1570 + } 1571 1571 + if let Some(ref value) = self.time_since_last_claim { 1572 1572 + if *value < 0i64 { 1573 1573 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1574 1574 + field: "time_since_last_claim", 1575 1575 + min: 0i64, 1576 1576 + actual: *value, 1552 1577 }); 1553 1578 } 1554 1579 } ··· 2311 2336 fn validate( 2312 2337 &self, 2313 2338 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2314 2314 - { 2315 2315 - let value = &self.session_id; 2316 2316 - if value.len() > 64usize { 2317 2317 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2318 2318 - field: "session_id", 2319 2319 - max: 64usize, 2320 2320 - actual: value.len(), 2339 2339 + if let Some(ref value) = self.game_card_count { 2340 2340 + if *value < 0i64 { 2341 2341 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 2342 2342 + field: "game_card_count", 2343 2343 + min: 0i64, 2344 2344 + actual: *value, 2345 2345 + }); 2346 2346 + } 2347 2347 + } 2348 2348 + if let Some(ref value) = self.post_count { 2349 2349 + if *value < 0i64 { 2350 2350 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 2351 2351 + field: "post_count", 2352 2352 + min: 0i64, 2353 2353 + actual: *value, 2354 2354 + }); 2355 2355 + } 2356 2356 + } 2357 2357 + if let Some(ref value) = self.scroll_position { 2358 2358 + if *value < 0i64 { 2359 2359 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 2360 2360 + field: "scroll_position", 2361 2361 + min: 0i64, 2362 2362 + actual: *value, 2321 2363 }); 2322 2364 } 2323 2365 } ··· 3093 3135 fn validate( 3094 3136 &self, 3095 3137 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3096 3096 - { 3097 3097 - let value = &self.session_id; 3098 3098 - if value.len() > 64usize { 3099 3099 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3100 3100 - field: "session_id", 3101 3101 - max: 64usize, 3102 3102 - actual: value.len(), 3138 3138 + if let Some(ref value) = self.injection_position { 3139 3139 + if *value < 0i64 { 3140 3140 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 3141 3141 + field: "injection_position", 3142 3142 + min: 0i64, 3143 3143 + actual: *value, 3144 3144 + }); 3145 3145 + } 3146 3146 + } 3147 3147 + if let Some(ref value) = self.quantity { 3148 3148 + if *value < 1i64 { 3149 3149 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 3150 3150 + field: "quantity", 3151 3151 + min: 1i64, 3152 3152 + actual: *value, 3103 3153 }); 3104 3154 } 3105 3155 } ··· 3867 3917 fn validate( 3868 3918 &self, 3869 3919 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3870 3870 - { 3871 3871 - let value = &self.session_id; 3872 3872 - if value.len() > 64usize { 3873 3873 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3874 3874 - field: "session_id", 3875 3875 - max: 64usize, 3876 3876 - actual: value.len(), 3920 3920 + if let Some(ref value) = self.quantity_used { 3921 3921 + if *value < 1i64 { 3922 3922 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 3923 3923 + field: "quantity_used", 3924 3924 + min: 1i64, 3925 3925 + actual: *value, 3926 3926 + }); 3927 3927 + } 3928 3928 + } 3929 3929 + if let Some(ref value) = self.remaining_quantity { 3930 3930 + if *value < 0i64 { 3931 3931 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 3932 3932 + field: "remaining_quantity", 3933 3933 + min: 0i64, 3934 3934 + actual: *value, 3877 3935 }); 3878 3936 } 3879 3937 } ··· 5517 5575 fn validate( 5518 5576 &self, 5519 5577 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 5520 5520 - { 5521 5521 - let value = &self.session_id; 5522 5522 - if value.len() > 64usize { 5523 5523 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 5524 5524 - field: "session_id", 5525 5525 - max: 64usize, 5526 5526 - actual: value.len(), 5578 5578 + if let Some(ref value) = self.network_latency { 5579 5579 + if *value < 0i64 { 5580 5580 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 5581 5581 + field: "network_latency", 5582 5582 + min: 0i64, 5583 5583 + actual: *value, 5527 5584 }); 5528 5585 } 5529 5586 } ··· 6281 6338 fn validate( 6282 6339 &self, 6283 6340 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 6284 6284 - { 6285 6285 - let value = &self.session_id; 6286 6286 - if value.len() > 64usize { 6287 6287 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 6288 6288 - field: "session_id", 6289 6289 - max: 64usize, 6290 6290 - actual: value.len(), 6341 6341 + if let Some(ref value) = self.quantity { 6342 6342 + if *value < 1i64 { 6343 6343 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 6344 6344 + field: "quantity", 6345 6345 + min: 1i64, 6346 6346 + actual: *value, 6291 6347 }); 6292 6348 } 6293 6349 }

-76

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

reviewed

··· 661 661 fn validate( 662 662 &self, 663 663 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 664 664 - if let Some(ref value) = self.longest_streak { 665 665 - if *value < 0i64 { 666 666 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 667 667 - field: "longest_streak", 668 668 - min: 0i64, 669 669 - actual: *value, 670 670 - }); 671 671 - } 672 672 - } 673 673 - if let Some(ref value) = self.pack_history { 674 674 - if value.len() > 30usize { 675 675 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 676 676 - field: "pack_history", 677 677 - max: 30usize, 678 678 - actual: value.len(), 679 679 - }); 680 680 - } 681 681 - } 682 682 - { 683 683 - let value = &self.streak; 684 684 - if *value < 0i64 { 685 685 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 686 686 - field: "streak", 687 687 - min: 0i64, 688 688 - actual: *value, 689 689 - }); 690 690 - } 691 691 - } 692 692 - { 693 693 - let value = &self.total_opens; 694 694 - if *value < 0i64 { 695 695 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 696 696 - field: "total_opens", 697 697 - min: 0i64, 698 698 - actual: *value, 699 699 - }); 700 700 - } 701 701 - } 702 664 Ok(()) 703 665 } 704 666 } ··· 973 935 fn validate( 974 936 &self, 975 937 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 976 976 - if let Some(ref value) = self.longest_streak { 977 977 - if *value < 0i64 { 978 978 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 979 979 - field: "longest_streak", 980 980 - min: 0i64, 981 981 - actual: *value, 982 982 - }); 983 983 - } 984 984 - } 985 985 - if let Some(ref value) = self.pack_history { 986 986 - if value.len() > 30usize { 987 987 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 988 988 - field: "pack_history", 989 989 - max: 30usize, 990 990 - actual: value.len(), 991 991 - }); 992 992 - } 993 993 - } 994 994 - { 995 995 - let value = &self.streak; 996 996 - if *value < 0i64 { 997 997 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 998 998 - field: "streak", 999 999 - min: 0i64, 1000 1000 - actual: *value, 1001 1001 - }); 1002 1002 - } 1003 1003 - } 1004 1004 - { 1005 1005 - let value = &self.total_opens; 1006 1006 - if *value < 0i64 { 1007 1007 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1008 1008 - field: "total_opens", 1009 1009 - min: 0i64, 1010 1010 - actual: *value, 1011 1011 - }); 1012 1012 - } 1013 1013 - } 1014 938 Ok(()) 1015 939 } 1016 940 }

+32 -65

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

reviewed

··· 988 988 fn validate( 989 989 &self, 990 990 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 991 991 - { 992 992 - let value = &self.level; 993 993 - if *value < 1i64 { 994 994 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 995 995 - field: "level", 996 996 - min: 1i64, 997 997 - actual: *value, 998 998 - }); 999 999 - } 1000 1000 - } 1001 1001 - if let Some(ref value) = self.previous_level { 1002 1002 - if *value < 1i64 { 1003 1003 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1004 1004 - field: "previous_level", 1005 1005 - min: 1i64, 1006 1006 - actual: *value, 1007 1007 - }); 1008 1008 - } 1009 1009 - } 1010 1010 - { 1011 1011 - let value = &self.total_xp; 1012 1012 - if *value < 0i64 { 1013 1013 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1014 1014 - field: "total_xp", 1015 1015 - min: 0i64, 1016 1016 - actual: *value, 1017 1017 - }); 1018 1018 - } 1019 1019 - } 1020 1020 - if let Some(ref value) = self.xp_gained_since_last_save { 1021 1021 - if *value < 0i64 { 1022 1022 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1023 1023 - field: "xp_gained_since_last_save", 1024 1024 - min: 0i64, 1025 1025 - actual: *value, 1026 1026 - }); 1027 1027 - } 1028 1028 - } 1029 1029 - { 1030 1030 - let value = &self.xp_to_next_level; 1031 1031 - if *value < 0i64 { 1032 1032 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1033 1033 - field: "xp_to_next_level", 1034 1034 - min: 0i64, 1035 1035 - actual: *value, 1036 1036 - }); 1037 1037 - } 1038 1038 - } 1039 991 Ok(()) 1040 992 } 1041 993 } ··· 1468 1420 fn validate( 1469 1421 &self, 1470 1422 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1471 1471 - { 1472 1472 - let value = &self.level; 1473 1473 - if *value < 1i64 { 1423 1423 + if let Some(ref value) = self.daily_rewards_claimed { 1424 1424 + if *value < 0i64 { 1425 1425 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1426 1426 + field: "daily_rewards_claimed", 1427 1427 + min: 0i64, 1428 1428 + actual: *value, 1429 1429 + }); 1430 1430 + } 1431 1431 + } 1432 1432 + if let Some(ref value) = self.items_collected { 1433 1433 + if *value < 0i64 { 1434 1434 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1435 1435 + field: "items_collected", 1436 1436 + min: 0i64, 1437 1437 + actual: *value, 1438 1438 + }); 1439 1439 + } 1440 1440 + } 1441 1441 + if let Some(ref value) = self.posts_read_today { 1442 1442 + if *value < 0i64 { 1474 1443 return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1475 1475 - field: "level", 1476 1476 - min: 1i64, 1444 1444 + field: "posts_read_today", 1445 1445 + min: 0i64, 1477 1446 actual: *value, 1478 1447 }); 1479 1448 } 1480 1449 } 1481 1481 - if let Some(ref value) = self.previous_level { 1482 1482 - if *value < 1i64 { 1450 1450 + if let Some(ref value) = self.posts_read_total { 1451 1451 + if *value < 0i64 { 1483 1452 return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1484 1484 - field: "previous_level", 1485 1485 - min: 1i64, 1453 1453 + field: "posts_read_total", 1454 1454 + min: 0i64, 1486 1455 actual: *value, 1487 1456 }); 1488 1457 } 1489 1458 } 1490 1490 - { 1491 1491 - let value = &self.total_xp; 1459 1459 + if let Some(ref value) = self.posts_viewed { 1492 1460 if *value < 0i64 { 1493 1461 return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1494 1494 - field: "total_xp", 1462 1462 + field: "posts_viewed", 1495 1463 min: 0i64, 1496 1464 actual: *value, 1497 1465 }); 1498 1466 } 1499 1467 } 1500 1500 - if let Some(ref value) = self.xp_gained_since_last_save { 1468 1468 + if let Some(ref value) = self.shuffles_performed { 1501 1469 if *value < 0i64 { 1502 1470 return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1503 1503 - field: "xp_gained_since_last_save", 1471 1471 + field: "shuffles_performed", 1504 1472 min: 0i64, 1505 1473 actual: *value, 1506 1474 }); 1507 1475 } 1508 1476 } 1509 1509 - { 1510 1510 - let value = &self.xp_to_next_level; 1477 1477 + if let Some(ref value) = self.specimens_collected { 1511 1478 if *value < 0i64 { 1512 1479 return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1513 1513 - field: "xp_to_next_level", 1480 1480 + field: "specimens_collected", 1514 1481 min: 0i64, 1515 1482 actual: *value, 1516 1483 });

+87 -24

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

reviewed

··· 650 650 fn validate( 651 651 &self, 652 652 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 653 653 - if let Some(ref value) = self.duration { 653 653 + if let Some(ref value) = self.current_level { 654 654 + if *value < 1i64 { 655 655 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 656 656 + field: "current_level", 657 657 + min: 1i64, 658 658 + actual: *value, 659 659 + }); 660 660 + } 661 661 + } 662 662 + if let Some(ref value) = self.current_xp { 663 663 + if *value < 0i64 { 664 664 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 665 665 + field: "current_xp", 666 666 + min: 0i64, 667 667 + actual: *value, 668 668 + }); 669 669 + } 670 670 + } 671 671 + if let Some(ref value) = self.total_events { 672 672 + if *value < 0i64 { 673 673 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 674 674 + field: "total_events", 675 675 + min: 0i64, 676 676 + actual: *value, 677 677 + }); 678 678 + } 679 679 + } 680 680 + if let Some(ref value) = self.xp_gained_this_session { 654 681 if *value < 0i64 { 655 682 return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 656 656 - field: "duration", 683 683 + field: "xp_gained_this_session", 657 684 min: 0i64, 658 685 actual: *value, 659 686 }); ··· 1299 1326 fn validate( 1300 1327 &self, 1301 1328 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1302 1302 - if let Some(ref value) = self.duration { 1329 1329 + if let Some(ref value) = self.daily_rewards_claimed { 1330 1330 + if *value < 0i64 { 1331 1331 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1332 1332 + field: "daily_rewards_claimed", 1333 1333 + min: 0i64, 1334 1334 + actual: *value, 1335 1335 + }); 1336 1336 + } 1337 1337 + } 1338 1338 + if let Some(ref value) = self.feeds_loaded { 1339 1339 + if *value < 0i64 { 1340 1340 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1341 1341 + field: "feeds_loaded", 1342 1342 + min: 0i64, 1343 1343 + actual: *value, 1344 1344 + }); 1345 1345 + } 1346 1346 + } 1347 1347 + if let Some(ref value) = self.items_collected { 1348 1348 + if *value < 0i64 { 1349 1349 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1350 1350 + field: "items_collected", 1351 1351 + min: 0i64, 1352 1352 + actual: *value, 1353 1353 + }); 1354 1354 + } 1355 1355 + } 1356 1356 + if let Some(ref value) = self.level_ups { 1303 1357 if *value < 0i64 { 1304 1358 return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1305 1305 - field: "duration", 1359 1359 + field: "level_ups", 1360 1360 + min: 0i64, 1361 1361 + actual: *value, 1362 1362 + }); 1363 1363 + } 1364 1364 + } 1365 1365 + if let Some(ref value) = self.posts_viewed { 1366 1366 + if *value < 0i64 { 1367 1367 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1368 1368 + field: "posts_viewed", 1369 1369 + min: 0i64, 1370 1370 + actual: *value, 1371 1371 + }); 1372 1372 + } 1373 1373 + } 1374 1374 + if let Some(ref value) = self.specimens_collected { 1375 1375 + if *value < 0i64 { 1376 1376 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 1377 1377 + field: "specimens_collected", 1306 1378 min: 0i64, 1307 1379 actual: *value, 1308 1380 }); ··· 2722 2794 fn validate( 2723 2795 &self, 2724 2796 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2725 2725 - if let Some(ref value) = self.duration { 2726 2726 - if *value < 0i64 { 2727 2727 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 2728 2728 - field: "duration", 2729 2729 - min: 0i64, 2730 2730 - actual: *value, 2731 2731 - }); 2732 2732 - } 2733 2733 - } 2734 2797 Ok(()) 2735 2798 } 2736 2799 } ··· 3365 3428 fn validate( 3366 3429 &self, 3367 3430 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3368 3368 - if let Some(ref value) = self.duration { 3431 3431 + if let Some(ref value) = self.average_response_time { 3432 3432 + if *value < 0i64 { 3433 3433 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 3434 3434 + field: "average_response_time", 3435 3435 + min: 0i64, 3436 3436 + actual: *value, 3437 3437 + }); 3438 3438 + } 3439 3439 + } 3440 3440 + if let Some(ref value) = self.error_count { 3369 3441 if *value < 0i64 { 3370 3442 return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 3371 3371 - field: "duration", 3443 3443 + field: "error_count", 3372 3444 min: 0i64, 3373 3445 actual: *value, 3374 3446 }); ··· 4017 4089 fn validate( 4018 4090 &self, 4019 4091 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 4020 4020 - if let Some(ref value) = self.duration { 4021 4021 - if *value < 0i64 { 4022 4022 - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 4023 4023 - field: "duration", 4024 4024 - min: 0i64, 4025 4025 - actual: *value, 4026 4026 - }); 4027 4027 - } 4028 4028 - } 4029 4092 Ok(()) 4030 4093 } 4031 4094 }

-45

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

reviewed

··· 574 574 fn validate( 575 575 &self, 576 576 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 577 577 - if let Some(ref value) = self.langs { 578 578 - if value.len() > 3usize { 579 579 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 580 580 - field: "langs", 581 581 - max: 3usize, 582 582 - actual: value.len(), 583 583 - }); 584 584 - } 585 585 - } 586 586 - if let Some(ref value) = self.tags { 587 587 - if value.len() > 8usize { 588 588 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 589 589 - field: "tags", 590 590 - max: 8usize, 591 591 - actual: value.len(), 592 592 - }); 593 593 - } 594 594 - } 595 595 - { 596 596 - let value = &self.text; 597 597 - if value.len() > 3000usize { 598 598 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 599 599 - field: "text", 600 600 - max: 3000usize, 601 601 - actual: value.len(), 602 602 - }); 603 603 - } 604 604 - } 605 605 - { 606 606 - let value = &self.text; 607 607 - { 608 608 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 609 609 - value.as_ref(), 610 610 - true, 611 611 - ) 612 612 - .count(); 613 613 - if count > 300usize { 614 614 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 615 615 - field: "text", 616 616 - max: 300usize, 617 617 - actual: count, 618 618 - }); 619 619 - } 620 620 - } 621 621 - } 622 577 Ok(()) 623 578 } 624 579 }

-45

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

reviewed

··· 536 536 fn validate( 537 537 &self, 538 538 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 539 539 - if let Some(ref value) = self.langs { 540 540 - if value.len() > 3usize { 541 541 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 542 542 - field: "langs", 543 543 - max: 3usize, 544 544 - actual: value.len(), 545 545 - }); 546 546 - } 547 547 - } 548 548 - if let Some(ref value) = self.tags { 549 549 - if value.len() > 8usize { 550 550 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 551 551 - field: "tags", 552 552 - max: 8usize, 553 553 - actual: value.len(), 554 554 - }); 555 555 - } 556 556 - } 557 557 - { 558 558 - let value = &self.text; 559 559 - if value.len() > 3000usize { 560 560 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 561 561 - field: "text", 562 562 - max: 3000usize, 563 563 - actual: value.len(), 564 564 - }); 565 565 - } 566 566 - } 567 567 - { 568 568 - let value = &self.text; 569 569 - { 570 570 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 571 571 - value.as_ref(), 572 572 - true, 573 573 - ) 574 574 - .count(); 575 575 - if count > 300usize { 576 576 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 577 577 - field: "text", 578 578 - max: 300usize, 579 579 - actual: count, 580 580 - }); 581 581 - } 582 582 - } 583 583 - } 584 539 Ok(()) 585 540 } 586 541 }

-18

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

reviewed

··· 209 209 fn validate( 210 210 &self, 211 211 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 212 212 - if let Some(ref value) = self.reason { 213 213 - if value.len() > 300usize { 214 214 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 215 215 - field: "reason", 216 216 - max: 300usize, 217 217 - actual: value.len(), 218 218 - }); 219 219 - } 220 220 - } 221 221 - if let Some(ref value) = self.target_feeds { 222 222 - if value.len() > 50usize { 223 223 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 224 224 - field: "target_feeds", 225 225 - max: 50usize, 226 226 - actual: value.len(), 227 227 - }); 228 228 - } 229 229 - } 230 212 Ok(()) 231 213 } 232 214 }

-18

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

reviewed

··· 209 209 fn validate( 210 210 &self, 211 211 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 212 212 - if let Some(ref value) = self.reason { 213 213 - if value.len() > 300usize { 214 214 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 215 215 - field: "reason", 216 216 - max: 300usize, 217 217 - actual: value.len(), 218 218 - }); 219 219 - } 220 220 - } 221 221 - if let Some(ref value) = self.target_feeds { 222 222 - if value.len() > 50usize { 223 223 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 224 224 - field: "target_feeds", 225 225 - max: 50usize, 226 226 - actual: value.len(), 227 227 - }); 228 228 - } 229 229 - } 230 212 Ok(()) 231 213 } 232 214 }

+50

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

reviewed

··· 151 151 fn validate( 152 152 &self, 153 153 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 154 154 + if let Some(ref value) = self.description { 155 155 + if value.len() > 2560usize { 156 156 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 157 157 + field: "description", 158 158 + max: 2560usize, 159 159 + actual: value.len(), 160 160 + }); 161 161 + } 162 162 + } 163 163 + if let Some(ref value) = self.description { 164 164 + { 165 165 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 166 166 + value.as_ref(), 167 167 + true, 168 168 + ) 169 169 + .count(); 170 170 + if count > 256usize { 171 171 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 172 172 + field: "description", 173 173 + max: 256usize, 174 174 + actual: count, 175 175 + }); 176 176 + } 177 177 + } 178 178 + } 179 179 + if let Some(ref value) = self.display_name { 180 180 + if value.len() > 640usize { 181 181 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 182 182 + field: "display_name", 183 183 + max: 640usize, 184 184 + actual: value.len(), 185 185 + }); 186 186 + } 187 187 + } 188 188 + if let Some(ref value) = self.display_name { 189 189 + { 190 190 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 191 191 + value.as_ref(), 192 192 + true, 193 193 + ) 194 194 + .count(); 195 195 + if count > 64usize { 196 196 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 197 197 + field: "display_name", 198 198 + max: 64usize, 199 199 + actual: count, 200 200 + }); 201 201 + } 202 202 + } 203 203 + } 154 204 Ok(()) 155 205 } 156 206 }

+10

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

reviewed

··· 761 761 fn validate( 762 762 &self, 763 763 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 764 764 + { 765 765 + let value = &self.count; 766 766 + if *value < 0i64 { 767 767 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 768 768 + field: "count", 769 769 + min: 0i64, 770 770 + actual: *value, 771 771 + }); 772 772 + } 773 773 + } 764 774 Ok(()) 765 775 } 766 776 }

-27

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

reviewed

··· 416 416 fn validate( 417 417 &self, 418 418 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 419 419 - { 420 420 - let value = &self.text; 421 421 - if value.len() > 3000usize { 422 422 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 423 423 - field: "text", 424 424 - max: 3000usize, 425 425 - actual: value.len(), 426 426 - }); 427 427 - } 428 428 - } 429 429 - { 430 430 - let value = &self.text; 431 431 - { 432 432 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 433 433 - value.as_ref(), 434 434 - true, 435 435 - ) 436 436 - .count(); 437 437 - if count > 300usize { 438 438 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 439 439 - field: "text", 440 440 - max: 300usize, 441 441 - actual: count, 442 442 - }); 443 443 - } 444 444 - } 445 445 - } 446 419 Ok(()) 447 420 } 448 421 }

+60

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

reviewed

··· 115 115 fn validate( 116 116 &self, 117 117 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 118 118 + { 119 119 + let value = &self.blue; 120 120 + if *value > 255i64 { 121 121 + return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 122 122 + field: "blue", 123 123 + max: 255i64, 124 124 + actual: *value, 125 125 + }); 126 126 + } 127 127 + } 128 128 + { 129 129 + let value = &self.blue; 130 130 + if *value < 0i64 { 131 131 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 132 132 + field: "blue", 133 133 + min: 0i64, 134 134 + actual: *value, 135 135 + }); 136 136 + } 137 137 + } 138 138 + { 139 139 + let value = &self.green; 140 140 + if *value > 255i64 { 141 141 + return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 142 142 + field: "green", 143 143 + max: 255i64, 144 144 + actual: *value, 145 145 + }); 146 146 + } 147 147 + } 148 148 + { 149 149 + let value = &self.green; 150 150 + if *value < 0i64 { 151 151 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 152 152 + field: "green", 153 153 + min: 0i64, 154 154 + actual: *value, 155 155 + }); 156 156 + } 157 157 + } 158 158 + { 159 159 + let value = &self.red; 160 160 + if *value > 255i64 { 161 161 + return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 162 162 + field: "red", 163 163 + max: 255i64, 164 164 + actual: *value, 165 165 + }); 166 166 + } 167 167 + } 168 168 + { 169 169 + let value = &self.red; 170 170 + if *value < 0i64 { 171 171 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 172 172 + field: "red", 173 173 + min: 0i64, 174 174 + actual: *value, 175 175 + }); 176 176 + } 177 177 + } 118 178 Ok(()) 119 179 } 120 180 }

-108

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

reviewed

··· 321 321 fn validate( 322 322 &self, 323 323 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 324 324 - { 325 325 - let value = &self.title; 326 326 - if value.len() > 1400usize { 327 327 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 328 328 - field: "title", 329 329 - max: 1400usize, 330 330 - actual: value.len(), 331 331 - }); 332 332 - } 333 333 - } 334 334 - { 335 335 - let value = &self.title; 336 336 - { 337 337 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 338 338 - value.as_ref(), 339 339 - true, 340 340 - ) 341 341 - .count(); 342 342 - if count > 140usize { 343 343 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 344 344 - field: "title", 345 345 - max: 140usize, 346 346 - actual: count, 347 347 - }); 348 348 - } 349 349 - } 350 350 - } 351 324 Ok(()) 352 325 } 353 326 } ··· 1088 1061 fn validate( 1089 1062 &self, 1090 1063 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1091 1091 - { 1092 1092 - let value = &self.title; 1093 1093 - if value.len() > 1400usize { 1094 1094 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1095 1095 - field: "title", 1096 1096 - max: 1400usize, 1097 1097 - actual: value.len(), 1098 1098 - }); 1099 1099 - } 1100 1100 - } 1101 1101 - { 1102 1102 - let value = &self.title; 1103 1103 - { 1104 1104 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 1105 1105 - value.as_ref(), 1106 1106 - true, 1107 1107 - ) 1108 1108 - .count(); 1109 1109 - if count > 140usize { 1110 1110 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1111 1111 - field: "title", 1112 1112 - max: 140usize, 1113 1113 - actual: count, 1114 1114 - }); 1115 1115 - } 1116 1116 - } 1117 1117 - } 1118 1064 Ok(()) 1119 1065 } 1120 1066 } ··· 1450 1396 fn validate( 1451 1397 &self, 1452 1398 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1453 1453 - { 1454 1454 - let value = &self.title; 1455 1455 - if value.len() > 1400usize { 1456 1456 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1457 1457 - field: "title", 1458 1458 - max: 1400usize, 1459 1459 - actual: value.len(), 1460 1460 - }); 1461 1461 - } 1462 1462 - } 1463 1463 - { 1464 1464 - let value = &self.title; 1465 1465 - { 1466 1466 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 1467 1467 - value.as_ref(), 1468 1468 - true, 1469 1469 - ) 1470 1470 - .count(); 1471 1471 - if count > 140usize { 1472 1472 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1473 1473 - field: "title", 1474 1474 - max: 140usize, 1475 1475 - actual: count, 1476 1476 - }); 1477 1477 - } 1478 1478 - } 1479 1479 - } 1480 1399 Ok(()) 1481 1400 } 1482 1401 } ··· 1784 1703 fn validate( 1785 1704 &self, 1786 1705 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1787 1787 - { 1788 1788 - let value = &self.title; 1789 1789 - if value.len() > 1400usize { 1790 1790 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1791 1791 - field: "title", 1792 1792 - max: 1400usize, 1793 1793 - actual: value.len(), 1794 1794 - }); 1795 1795 - } 1796 1796 - } 1797 1797 - { 1798 1798 - let value = &self.title; 1799 1799 - { 1800 1800 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 1801 1801 - value.as_ref(), 1802 1802 - true, 1803 1803 - ) 1804 1804 - .count(); 1805 1805 - if count > 140usize { 1806 1806 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1807 1807 - field: "title", 1808 1808 - max: 140usize, 1809 1809 - actual: count, 1810 1810 - }); 1811 1811 - } 1812 1812 - } 1813 1813 - } 1814 1706 Ok(()) 1815 1707 } 1816 1708 }

+66

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

reviewed

··· 327 327 fn validate( 328 328 &self, 329 329 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 330 330 + { 331 331 + let value = &self.from; 332 332 + if value.len() > 100usize { 333 333 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 334 334 + field: "from", 335 335 + max: 100usize, 336 336 + actual: value.len(), 337 337 + }); 338 338 + } 339 339 + } 340 340 + { 341 341 + let value = &self.from; 342 342 + if value.len() < 1usize { 343 343 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 344 344 + field: "from", 345 345 + min: 1usize, 346 346 + actual: value.len(), 347 347 + }); 348 348 + } 349 349 + } 350 350 + { 351 351 + let value = &self.to; 352 352 + if value.len() > 100usize { 353 353 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 354 354 + field: "to", 355 355 + max: 100usize, 356 356 + actual: value.len(), 357 357 + }); 358 358 + } 359 359 + } 330 360 Ok(()) 331 361 } 332 362 } ··· 697 727 fn validate( 698 728 &self, 699 729 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 730 730 + if let Some(ref value) = self.description { 731 731 + if value.len() > 500usize { 732 732 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 733 733 + field: "description", 734 734 + max: 500usize, 735 735 + actual: value.len(), 736 736 + }); 737 737 + } 738 738 + } 739 739 + if let Some(ref value) = self.name { 740 740 + if value.len() > 100usize { 741 741 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 742 742 + field: "name", 743 743 + max: 100usize, 744 744 + actual: value.len(), 745 745 + }); 746 746 + } 747 747 + } 748 748 + if let Some(ref value) = self.prefix { 749 749 + if value.len() > 100usize { 750 750 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 751 751 + field: "prefix", 752 752 + max: 100usize, 753 753 + actual: value.len(), 754 754 + }); 755 755 + } 756 756 + } 757 757 + if let Some(ref value) = self.suffix { 758 758 + if value.len() > 100usize { 759 759 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 760 760 + field: "suffix", 761 761 + max: 100usize, 762 762 + actual: value.len(), 763 763 + }); 764 764 + } 765 765 + } 700 766 Ok(()) 701 767 } 702 768 }

+6 -8

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

reviewed

··· 355 355 fn validate( 356 356 &self, 357 357 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 358 358 - { 359 359 - let value = &self.name; 358 358 + if let Some(ref value) = self.text { 360 359 if value.len() > 500usize { 361 360 return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 362 362 - field: "name", 361 361 + field: "text", 363 362 max: 500usize, 364 363 actual: value.len(), 365 364 }); 366 365 } 367 366 } 368 368 - { 369 369 - let value = &self.name; 367 367 + if let Some(ref value) = self.text { 370 368 { 371 369 let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 372 370 value.as_ref(), 373 371 true, 374 372 ) 375 373 .count(); 376 376 - if count > 100usize { 374 374 + if count > 50usize { 377 375 return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 378 378 - field: "name", 379 379 - max: 100usize, 376 376 + field: "text", 377 377 + max: 50usize, 380 378 actual: count, 381 379 }); 382 380 }

-38

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

reviewed

··· 505 505 fn validate( 506 506 &self, 507 507 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 508 508 - if let Some(ref value) = self.description { 509 509 - if value.len() > 2000usize { 510 510 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 511 511 - field: "description", 512 512 - max: 2000usize, 513 513 - actual: value.len(), 514 514 - }); 515 515 - } 516 516 - } 517 517 - { 518 518 - let value = &self.name; 519 519 - if value.len() > 2000usize { 520 520 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 521 521 - field: "name", 522 522 - max: 2000usize, 523 523 - actual: value.len(), 524 524 - }); 525 525 - } 526 526 - } 527 508 Ok(()) 528 509 } 529 510 } ··· 839 820 fn validate( 840 821 &self, 841 822 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 842 842 - if let Some(ref value) = self.description { 843 843 - if value.len() > 2000usize { 844 844 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 845 845 - field: "description", 846 846 - max: 2000usize, 847 847 - actual: value.len(), 848 848 - }); 849 849 - } 850 850 - } 851 851 - { 852 852 - let value = &self.name; 853 853 - if value.len() > 2000usize { 854 854 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 855 855 - field: "name", 856 856 - max: 2000usize, 857 857 - actual: value.len(), 858 858 - }); 859 859 - } 860 860 - } 861 823 Ok(()) 862 824 } 863 825 }

+20

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

reviewed

··· 475 475 fn validate( 476 476 &self, 477 477 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 478 478 + { 479 479 + let value = &self.byte_end; 480 480 + if *value < 0i64 { 481 481 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 482 482 + field: "byte_end", 483 483 + min: 0i64, 484 484 + actual: *value, 485 485 + }); 486 486 + } 487 487 + } 488 488 + { 489 489 + let value = &self.byte_start; 490 490 + if *value < 0i64 { 491 491 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 492 492 + field: "byte_start", 493 493 + min: 0i64, 494 494 + actual: *value, 495 495 + }); 496 496 + } 497 497 + } 478 498 Ok(()) 479 499 } 480 500 }

+140

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

reviewed

··· 147 147 fn validate( 148 148 &self, 149 149 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 150 150 + { 151 151 + let value = &self.b; 152 152 + if *value > 255i64 { 153 153 + return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 154 154 + field: "b", 155 155 + max: 255i64, 156 156 + actual: *value, 157 157 + }); 158 158 + } 159 159 + } 160 160 + { 161 161 + let value = &self.b; 162 162 + if *value < 0i64 { 163 163 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 164 164 + field: "b", 165 165 + min: 0i64, 166 166 + actual: *value, 167 167 + }); 168 168 + } 169 169 + } 170 170 + { 171 171 + let value = &self.g; 172 172 + if *value > 255i64 { 173 173 + return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 174 174 + field: "g", 175 175 + max: 255i64, 176 176 + actual: *value, 177 177 + }); 178 178 + } 179 179 + } 180 180 + { 181 181 + let value = &self.g; 182 182 + if *value < 0i64 { 183 183 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 184 184 + field: "g", 185 185 + min: 0i64, 186 186 + actual: *value, 187 187 + }); 188 188 + } 189 189 + } 190 190 + { 191 191 + let value = &self.r; 192 192 + if *value > 255i64 { 193 193 + return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 194 194 + field: "r", 195 195 + max: 255i64, 196 196 + actual: *value, 197 197 + }); 198 198 + } 199 199 + } 200 200 + { 201 201 + let value = &self.r; 202 202 + if *value < 0i64 { 203 203 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 204 204 + field: "r", 205 205 + min: 0i64, 206 206 + actual: *value, 207 207 + }); 208 208 + } 209 209 + } 150 210 Ok(()) 151 211 } 152 212 } ··· 294 354 fn validate( 295 355 &self, 296 356 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 357 357 + { 358 358 + let value = &self.a; 359 359 + if *value > 100i64 { 360 360 + return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 361 361 + field: "a", 362 362 + max: 100i64, 363 363 + actual: *value, 364 364 + }); 365 365 + } 366 366 + } 367 367 + { 368 368 + let value = &self.a; 369 369 + if *value < 0i64 { 370 370 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 371 371 + field: "a", 372 372 + min: 0i64, 373 373 + actual: *value, 374 374 + }); 375 375 + } 376 376 + } 377 377 + { 378 378 + let value = &self.b; 379 379 + if *value > 255i64 { 380 380 + return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 381 381 + field: "b", 382 382 + max: 255i64, 383 383 + actual: *value, 384 384 + }); 385 385 + } 386 386 + } 387 387 + { 388 388 + let value = &self.b; 389 389 + if *value < 0i64 { 390 390 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 391 391 + field: "b", 392 392 + min: 0i64, 393 393 + actual: *value, 394 394 + }); 395 395 + } 396 396 + } 397 397 + { 398 398 + let value = &self.g; 399 399 + if *value > 255i64 { 400 400 + return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 401 401 + field: "g", 402 402 + max: 255i64, 403 403 + actual: *value, 404 404 + }); 405 405 + } 406 406 + } 407 407 + { 408 408 + let value = &self.g; 409 409 + if *value < 0i64 { 410 410 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 411 411 + field: "g", 412 412 + min: 0i64, 413 413 + actual: *value, 414 414 + }); 415 415 + } 416 416 + } 417 417 + { 418 418 + let value = &self.r; 419 419 + if *value > 255i64 { 420 420 + return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 421 421 + field: "r", 422 422 + max: 255i64, 423 423 + actual: *value, 424 424 + }); 425 425 + } 426 426 + } 427 427 + { 428 428 + let value = &self.r; 429 429 + if *value < 0i64 { 430 430 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 431 431 + field: "r", 432 432 + min: 0i64, 433 433 + actual: *value, 434 434 + }); 435 435 + } 436 436 + } 297 437 Ok(()) 298 438 } 299 439 }

-335

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

reviewed

··· 329 329 fn validate( 330 330 &self, 331 331 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 332 332 - { 333 333 - let value = &self.new_sha; 334 334 - if value.len() > 40usize { 335 335 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 336 336 - field: "new_sha", 337 337 - max: 40usize, 338 338 - actual: value.len(), 339 339 - }); 340 340 - } 341 341 - } 342 342 - { 343 343 - let value = &self.new_sha; 344 344 - if value.len() < 40usize { 345 345 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 346 346 - field: "new_sha", 347 347 - min: 40usize, 348 348 - actual: value.len(), 349 349 - }); 350 350 - } 351 351 - } 352 352 - { 353 353 - let value = &self.old_sha; 354 354 - if value.len() > 40usize { 355 355 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 356 356 - field: "old_sha", 357 357 - max: 40usize, 358 358 - actual: value.len(), 359 359 - }); 360 360 - } 361 361 - } 362 362 - { 363 363 - let value = &self.old_sha; 364 364 - if value.len() < 40usize { 365 365 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 366 366 - field: "old_sha", 367 367 - min: 40usize, 368 368 - actual: value.len(), 369 369 - }); 370 370 - } 371 371 - } 372 372 - { 373 373 - let value = &self.r#ref; 374 374 - if value.len() > 2560usize { 375 375 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 376 376 - field: "ref", 377 377 - max: 2560usize, 378 378 - actual: value.len(), 379 379 - }); 380 380 - } 381 381 - } 382 382 - { 383 383 - let value = &self.r#ref; 384 384 - { 385 385 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 386 386 - value.as_ref(), 387 387 - true, 388 388 - ) 389 389 - .count(); 390 390 - if count > 256usize { 391 391 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 392 392 - field: "ref", 393 393 - max: 256usize, 394 394 - actual: count, 395 395 - }); 396 396 - } 397 397 - } 398 398 - } 399 332 Ok(()) 400 333 } 401 334 } ··· 723 656 fn validate( 724 657 &self, 725 658 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 726 726 - { 727 727 - let value = &self.new_sha; 728 728 - if value.len() > 40usize { 729 729 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 730 730 - field: "new_sha", 731 731 - max: 40usize, 732 732 - actual: value.len(), 733 733 - }); 734 734 - } 735 735 - } 736 736 - { 737 737 - let value = &self.new_sha; 738 738 - if value.len() < 40usize { 739 739 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 740 740 - field: "new_sha", 741 741 - min: 40usize, 742 742 - actual: value.len(), 743 743 - }); 744 744 - } 745 745 - } 746 746 - { 747 747 - let value = &self.old_sha; 748 748 - if value.len() > 40usize { 749 749 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 750 750 - field: "old_sha", 751 751 - max: 40usize, 752 752 - actual: value.len(), 753 753 - }); 754 754 - } 755 755 - } 756 756 - { 757 757 - let value = &self.old_sha; 758 758 - if value.len() < 40usize { 759 759 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 760 760 - field: "old_sha", 761 761 - min: 40usize, 762 762 - actual: value.len(), 763 763 - }); 764 764 - } 765 765 - } 766 766 - { 767 767 - let value = &self.r#ref; 768 768 - if value.len() > 2560usize { 769 769 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 770 770 - field: "ref", 771 771 - max: 2560usize, 772 772 - actual: value.len(), 773 773 - }); 774 774 - } 775 775 - } 776 776 - { 777 777 - let value = &self.r#ref; 778 778 - { 779 779 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 780 780 - value.as_ref(), 781 781 - true, 782 782 - ) 783 783 - .count(); 784 784 - if count > 256usize { 785 785 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 786 786 - field: "ref", 787 787 - max: 256usize, 788 788 - actual: count, 789 789 - }); 790 790 - } 791 791 - } 792 792 - } 793 659 Ok(()) 794 660 } 795 661 } ··· 1117 983 fn validate( 1118 984 &self, 1119 985 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1120 1120 - { 1121 1121 - let value = &self.new_sha; 1122 1122 - if value.len() > 40usize { 1123 1123 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1124 1124 - field: "new_sha", 1125 1125 - max: 40usize, 1126 1126 - actual: value.len(), 1127 1127 - }); 1128 1128 - } 1129 1129 - } 1130 1130 - { 1131 1131 - let value = &self.new_sha; 1132 1132 - if value.len() < 40usize { 1133 1133 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 1134 1134 - field: "new_sha", 1135 1135 - min: 40usize, 1136 1136 - actual: value.len(), 1137 1137 - }); 1138 1138 - } 1139 1139 - } 1140 1140 - { 1141 1141 - let value = &self.old_sha; 1142 1142 - if value.len() > 40usize { 1143 1143 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1144 1144 - field: "old_sha", 1145 1145 - max: 40usize, 1146 1146 - actual: value.len(), 1147 1147 - }); 1148 1148 - } 1149 1149 - } 1150 1150 - { 1151 1151 - let value = &self.old_sha; 1152 1152 - if value.len() < 40usize { 1153 1153 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 1154 1154 - field: "old_sha", 1155 1155 - min: 40usize, 1156 1156 - actual: value.len(), 1157 1157 - }); 1158 1158 - } 1159 1159 - } 1160 1160 - { 1161 1161 - let value = &self.r#ref; 1162 1162 - if value.len() > 2560usize { 1163 1163 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1164 1164 - field: "ref", 1165 1165 - max: 2560usize, 1166 1166 - actual: value.len(), 1167 1167 - }); 1168 1168 - } 1169 1169 - } 1170 1170 - { 1171 1171 - let value = &self.r#ref; 1172 1172 - { 1173 1173 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 1174 1174 - value.as_ref(), 1175 1175 - true, 1176 1176 - ) 1177 1177 - .count(); 1178 1178 - if count > 256usize { 1179 1179 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1180 1180 - field: "ref", 1181 1181 - max: 256usize, 1182 1182 - actual: count, 1183 1183 - }); 1184 1184 - } 1185 1185 - } 1186 1186 - } 1187 986 Ok(()) 1188 987 } 1189 988 } ··· 1512 1311 fn validate( 1513 1312 &self, 1514 1313 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1515 1515 - { 1516 1516 - let value = &self.new_sha; 1517 1517 - if value.len() > 40usize { 1518 1518 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1519 1519 - field: "new_sha", 1520 1520 - max: 40usize, 1521 1521 - actual: value.len(), 1522 1522 - }); 1523 1523 - } 1524 1524 - } 1525 1525 - { 1526 1526 - let value = &self.new_sha; 1527 1527 - if value.len() < 40usize { 1528 1528 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 1529 1529 - field: "new_sha", 1530 1530 - min: 40usize, 1531 1531 - actual: value.len(), 1532 1532 - }); 1533 1533 - } 1534 1534 - } 1535 1535 - { 1536 1536 - let value = &self.old_sha; 1537 1537 - if value.len() > 40usize { 1538 1538 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1539 1539 - field: "old_sha", 1540 1540 - max: 40usize, 1541 1541 - actual: value.len(), 1542 1542 - }); 1543 1543 - } 1544 1544 - } 1545 1545 - { 1546 1546 - let value = &self.old_sha; 1547 1547 - if value.len() < 40usize { 1548 1548 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 1549 1549 - field: "old_sha", 1550 1550 - min: 40usize, 1551 1551 - actual: value.len(), 1552 1552 - }); 1553 1553 - } 1554 1554 - } 1555 1555 - { 1556 1556 - let value = &self.r#ref; 1557 1557 - if value.len() > 2560usize { 1558 1558 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1559 1559 - field: "ref", 1560 1560 - max: 2560usize, 1561 1561 - actual: value.len(), 1562 1562 - }); 1563 1563 - } 1564 1564 - } 1565 1565 - { 1566 1566 - let value = &self.r#ref; 1567 1567 - { 1568 1568 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 1569 1569 - value.as_ref(), 1570 1570 - true, 1571 1571 - ) 1572 1572 - .count(); 1573 1573 - if count > 256usize { 1574 1574 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1575 1575 - field: "ref", 1576 1576 - max: 256usize, 1577 1577 - actual: count, 1578 1578 - }); 1579 1579 - } 1580 1580 - } 1581 1581 - } 1582 1314 Ok(()) 1583 1315 } 1584 1316 } ··· 2385 2117 fn validate( 2386 2118 &self, 2387 2119 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2388 2388 - { 2389 2389 - let value = &self.new_sha; 2390 2390 - if value.len() > 40usize { 2391 2391 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2392 2392 - field: "new_sha", 2393 2393 - max: 40usize, 2394 2394 - actual: value.len(), 2395 2395 - }); 2396 2396 - } 2397 2397 - } 2398 2398 - { 2399 2399 - let value = &self.new_sha; 2400 2400 - if value.len() < 40usize { 2401 2401 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 2402 2402 - field: "new_sha", 2403 2403 - min: 40usize, 2404 2404 - actual: value.len(), 2405 2405 - }); 2406 2406 - } 2407 2407 - } 2408 2408 - { 2409 2409 - let value = &self.old_sha; 2410 2410 - if value.len() > 40usize { 2411 2411 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2412 2412 - field: "old_sha", 2413 2413 - max: 40usize, 2414 2414 - actual: value.len(), 2415 2415 - }); 2416 2416 - } 2417 2417 - } 2418 2418 - { 2419 2419 - let value = &self.old_sha; 2420 2420 - if value.len() < 40usize { 2421 2421 - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 2422 2422 - field: "old_sha", 2423 2423 - min: 40usize, 2424 2424 - actual: value.len(), 2425 2425 - }); 2426 2426 - } 2427 2427 - } 2428 2428 - { 2429 2429 - let value = &self.r#ref; 2430 2430 - if value.len() > 2560usize { 2431 2431 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2432 2432 - field: "ref", 2433 2433 - max: 2560usize, 2434 2434 - actual: value.len(), 2435 2435 - }); 2436 2436 - } 2437 2437 - } 2438 2438 - { 2439 2439 - let value = &self.r#ref; 2440 2440 - { 2441 2441 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 2442 2442 - value.as_ref(), 2443 2443 - true, 2444 2444 - ) 2445 2445 - .count(); 2446 2446 - if count > 256usize { 2447 2447 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 2448 2448 - field: "ref", 2449 2449 - max: 256usize, 2450 2450 - actual: count, 2451 2451 - }); 2452 2452 - } 2453 2453 - } 2454 2454 - } 2455 2120 Ok(()) 2456 2121 } 2457 2122 }

+10

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

reviewed

··· 260 260 fn validate( 261 261 &self, 262 262 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 263 263 + { 264 264 + let value = &self.key; 265 265 + if value.len() > 4096usize { 266 266 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 267 267 + field: "key", 268 268 + max: 4096usize, 269 269 + actual: value.len(), 270 270 + }); 271 271 + } 272 272 + } 263 273 Ok(()) 264 274 } 265 275 }

-34

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

reviewed

··· 540 540 fn validate( 541 541 &self, 542 542 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 543 543 - { 544 544 - let value = &self.name; 545 545 - { 546 546 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 547 547 - value.as_ref(), 548 548 - true, 549 549 - ) 550 550 - .count(); 551 551 - if count > 40usize { 552 552 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 553 553 - field: "name", 554 554 - max: 40usize, 555 555 - actual: count, 556 556 - }); 557 557 - } 558 558 - } 559 559 - } 560 560 - { 561 561 - let value = &self.name; 562 562 - { 563 563 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 564 564 - value.as_ref(), 565 565 - true, 566 566 - ) 567 567 - .count(); 568 568 - if count < 1usize { 569 569 - return Err(::jacquard_lexicon::schema::ValidationError::MinGraphemes { 570 570 - field: "name", 571 571 - min: 1usize, 572 572 - actual: count, 573 573 - }); 574 574 - } 575 575 - } 576 576 - } 577 543 Ok(()) 578 544 } 579 545 }

+60

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

reviewed

··· 2696 2696 fn validate( 2697 2697 &self, 2698 2698 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2699 2699 + { 2700 2700 + let value = &self.source_sha; 2701 2701 + if value.len() > 40usize { 2702 2702 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2703 2703 + field: "source_sha", 2704 2704 + max: 40usize, 2705 2705 + actual: value.len(), 2706 2706 + }); 2707 2707 + } 2708 2708 + } 2709 2709 + { 2710 2710 + let value = &self.source_sha; 2711 2711 + if value.len() < 40usize { 2712 2712 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 2713 2713 + field: "source_sha", 2714 2714 + min: 40usize, 2715 2715 + actual: value.len(), 2716 2716 + }); 2717 2717 + } 2718 2718 + } 2699 2719 Ok(()) 2700 2720 } 2701 2721 } ··· 3224 3244 fn validate( 3225 3245 &self, 3226 3246 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 3247 3247 + { 3248 3248 + let value = &self.new_sha; 3249 3249 + if value.len() > 40usize { 3250 3250 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3251 3251 + field: "new_sha", 3252 3252 + max: 40usize, 3253 3253 + actual: value.len(), 3254 3254 + }); 3255 3255 + } 3256 3256 + } 3257 3257 + { 3258 3258 + let value = &self.new_sha; 3259 3259 + if value.len() < 40usize { 3260 3260 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 3261 3261 + field: "new_sha", 3262 3262 + min: 40usize, 3263 3263 + actual: value.len(), 3264 3264 + }); 3265 3265 + } 3266 3266 + } 3267 3267 + { 3268 3268 + let value = &self.old_sha; 3269 3269 + if value.len() > 40usize { 3270 3270 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 3271 3271 + field: "old_sha", 3272 3272 + max: 40usize, 3273 3273 + actual: value.len(), 3274 3274 + }); 3275 3275 + } 3276 3276 + } 3277 3277 + { 3278 3278 + let value = &self.old_sha; 3279 3279 + if value.len() < 40usize { 3280 3280 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 3281 3281 + field: "old_sha", 3282 3282 + min: 40usize, 3283 3283 + actual: value.len(), 3284 3284 + }); 3285 3285 + } 3286 3286 + } 3227 3287 Ok(()) 3228 3288 } 3229 3289 }

+20

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

reviewed

··· 226 226 fn validate( 227 227 &self, 228 228 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 229 229 + { 230 230 + let value = &self.key; 231 231 + if value.len() > 50usize { 232 232 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 233 233 + field: "key", 234 234 + max: 50usize, 235 235 + actual: value.len(), 236 236 + }); 237 237 + } 238 238 + } 239 239 + { 240 240 + let value = &self.key; 241 241 + if value.len() < 1usize { 242 242 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 243 243 + field: "key", 244 244 + min: 1usize, 245 245 + actual: value.len(), 246 246 + }); 247 247 + } 248 248 + } 229 249 Ok(()) 230 250 } 231 251 }

+20

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

reviewed

··· 569 569 fn validate( 570 570 &self, 571 571 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 572 572 + { 573 573 + let value = &self.sha; 574 574 + if value.len() > 40usize { 575 575 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 576 576 + field: "sha", 577 577 + max: 40usize, 578 578 + actual: value.len(), 579 579 + }); 580 580 + } 581 581 + } 582 582 + { 583 583 + let value = &self.sha; 584 584 + if value.len() < 40usize { 585 585 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 586 586 + field: "sha", 587 587 + min: 40usize, 588 588 + actual: value.len(), 589 589 + }); 590 590 + } 591 591 + } 572 592 Ok(()) 573 593 } 574 594 }

+222

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

reviewed

··· 465 465 fn validate( 466 466 &self, 467 467 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 468 468 + if let Some(ref value) = self.display_name { 469 469 + if value.len() > 640usize { 470 470 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 471 471 + field: "display_name", 472 472 + max: 640usize, 473 473 + actual: value.len(), 474 474 + }); 475 475 + } 476 476 + } 477 477 + if let Some(ref value) = self.display_name { 478 478 + { 479 479 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 480 480 + value.as_ref(), 481 481 + true, 482 482 + ) 483 483 + .count(); 484 484 + if count > 64usize { 485 485 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 486 486 + field: "display_name", 487 487 + max: 64usize, 488 488 + actual: count, 489 489 + }); 490 490 + } 491 491 + } 492 492 + } 468 493 Ok(()) 469 494 } 470 495 } ··· 1426 1451 fn validate( 1427 1452 &self, 1428 1453 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1454 1454 + if let Some(ref value) = self.description { 1455 1455 + if value.len() > 2560usize { 1456 1456 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1457 1457 + field: "description", 1458 1458 + max: 2560usize, 1459 1459 + actual: value.len(), 1460 1460 + }); 1461 1461 + } 1462 1462 + } 1463 1463 + if let Some(ref value) = self.description { 1464 1464 + { 1465 1465 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 1466 1466 + value.as_ref(), 1467 1467 + true, 1468 1468 + ) 1469 1469 + .count(); 1470 1470 + if count > 256usize { 1471 1471 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1472 1472 + field: "description", 1473 1473 + max: 256usize, 1474 1474 + actual: count, 1475 1475 + }); 1476 1476 + } 1477 1477 + } 1478 1478 + } 1479 1479 + if let Some(ref value) = self.display_name { 1480 1480 + if value.len() > 640usize { 1481 1481 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1482 1482 + field: "display_name", 1483 1483 + max: 640usize, 1484 1484 + actual: value.len(), 1485 1485 + }); 1486 1486 + } 1487 1487 + } 1488 1488 + if let Some(ref value) = self.display_name { 1489 1489 + { 1490 1490 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 1491 1491 + value.as_ref(), 1492 1492 + true, 1493 1493 + ) 1494 1494 + .count(); 1495 1495 + if count > 64usize { 1496 1496 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1497 1497 + field: "display_name", 1498 1498 + max: 64usize, 1499 1499 + actual: count, 1500 1500 + }); 1501 1501 + } 1502 1502 + } 1503 1503 + } 1504 1504 + if let Some(ref value) = self.links { 1505 1505 + if value.len() > 5usize { 1506 1506 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1507 1507 + field: "links", 1508 1508 + max: 5usize, 1509 1509 + actual: value.len(), 1510 1510 + }); 1511 1511 + } 1512 1512 + } 1513 1513 + if let Some(ref value) = self.links { 1514 1514 + if value.len() < 0usize { 1515 1515 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 1516 1516 + field: "links", 1517 1517 + min: 0usize, 1518 1518 + actual: value.len(), 1519 1519 + }); 1520 1520 + } 1521 1521 + } 1522 1522 + if let Some(ref value) = self.location { 1523 1523 + if value.len() > 400usize { 1524 1524 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1525 1525 + field: "location", 1526 1526 + max: 400usize, 1527 1527 + actual: value.len(), 1528 1528 + }); 1529 1529 + } 1530 1530 + } 1531 1531 + if let Some(ref value) = self.location { 1532 1532 + { 1533 1533 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 1534 1534 + value.as_ref(), 1535 1535 + true, 1536 1536 + ) 1537 1537 + .count(); 1538 1538 + if count > 40usize { 1539 1539 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1540 1540 + field: "location", 1541 1541 + max: 40usize, 1542 1542 + actual: count, 1543 1543 + }); 1544 1544 + } 1545 1545 + } 1546 1546 + } 1429 1547 Ok(()) 1430 1548 } 1431 1549 } ··· 1905 2023 fn validate( 1906 2024 &self, 1907 2025 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2026 2026 + if let Some(ref value) = self.description { 2027 2027 + if value.len() > 2560usize { 2028 2028 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2029 2029 + field: "description", 2030 2030 + max: 2560usize, 2031 2031 + actual: value.len(), 2032 2032 + }); 2033 2033 + } 2034 2034 + } 2035 2035 + if let Some(ref value) = self.description { 2036 2036 + { 2037 2037 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 2038 2038 + value.as_ref(), 2039 2039 + true, 2040 2040 + ) 2041 2041 + .count(); 2042 2042 + if count > 256usize { 2043 2043 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 2044 2044 + field: "description", 2045 2045 + max: 256usize, 2046 2046 + actual: count, 2047 2047 + }); 2048 2048 + } 2049 2049 + } 2050 2050 + } 2051 2051 + if let Some(ref value) = self.links { 2052 2052 + if value.len() > 5usize { 2053 2053 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2054 2054 + field: "links", 2055 2055 + max: 5usize, 2056 2056 + actual: value.len(), 2057 2057 + }); 2058 2058 + } 2059 2059 + } 2060 2060 + if let Some(ref value) = self.links { 2061 2061 + if value.len() < 0usize { 2062 2062 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 2063 2063 + field: "links", 2064 2064 + min: 0usize, 2065 2065 + actual: value.len(), 2066 2066 + }); 2067 2067 + } 2068 2068 + } 2069 2069 + if let Some(ref value) = self.location { 2070 2070 + if value.len() > 400usize { 2071 2071 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2072 2072 + field: "location", 2073 2073 + max: 400usize, 2074 2074 + actual: value.len(), 2075 2075 + }); 2076 2076 + } 2077 2077 + } 2078 2078 + if let Some(ref value) = self.location { 2079 2079 + { 2080 2080 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 2081 2081 + value.as_ref(), 2082 2082 + true, 2083 2083 + ) 2084 2084 + .count(); 2085 2085 + if count > 40usize { 2086 2086 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 2087 2087 + field: "location", 2088 2088 + max: 40usize, 2089 2089 + actual: count, 2090 2090 + }); 2091 2091 + } 2092 2092 + } 2093 2093 + } 2094 2094 + if let Some(ref value) = self.pinned_repositories { 2095 2095 + if value.len() > 6usize { 2096 2096 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2097 2097 + field: "pinned_repositories", 2098 2098 + max: 6usize, 2099 2099 + actual: value.len(), 2100 2100 + }); 2101 2101 + } 2102 2102 + } 2103 2103 + if let Some(ref value) = self.pinned_repositories { 2104 2104 + if value.len() < 0usize { 2105 2105 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 2106 2106 + field: "pinned_repositories", 2107 2107 + min: 0usize, 2108 2108 + actual: value.len(), 2109 2109 + }); 2110 2110 + } 2111 2111 + } 2112 2112 + if let Some(ref value) = self.stats { 2113 2113 + if value.len() > 2usize { 2114 2114 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2115 2115 + field: "stats", 2116 2116 + max: 2usize, 2117 2117 + actual: value.len(), 2118 2118 + }); 2119 2119 + } 2120 2120 + } 2121 2121 + if let Some(ref value) = self.stats { 2122 2122 + if value.len() < 0usize { 2123 2123 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 2124 2124 + field: "stats", 2125 2125 + min: 0usize, 2126 2126 + actual: value.len(), 2127 2127 + }); 2128 2128 + } 2129 2129 + } 1908 2130 Ok(()) 1909 2131 } 1910 2132 }

-30

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

reviewed

··· 243 243 fn validate( 244 244 &self, 245 245 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 246 246 - { 247 247 - let value = &self.embeds; 248 248 - if value.len() > 48usize { 249 249 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 250 250 - field: "embeds", 251 251 - max: 48usize, 252 252 - actual: value.len(), 253 253 - }); 254 254 - } 255 255 - } 256 246 Ok(()) 257 247 } 258 248 } ··· 727 717 fn validate( 728 718 &self, 729 719 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 730 730 - { 731 731 - let value = &self.embeds; 732 732 - if value.len() > 48usize { 733 733 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 734 734 - field: "embeds", 735 735 - max: 48usize, 736 736 - actual: value.len(), 737 737 - }); 738 738 - } 739 739 - } 740 720 Ok(()) 741 721 } 742 722 } ··· 979 959 fn validate( 980 960 &self, 981 961 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 982 982 - { 983 983 - let value = &self.embeds; 984 984 - if value.len() > 48usize { 985 985 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 986 986 - field: "embeds", 987 987 - max: 48usize, 988 988 - actual: value.len(), 989 989 - }); 990 990 - } 991 991 - } 992 962 Ok(()) 993 963 } 994 964 }

+4 -5

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

reviewed

··· 155 155 fn validate( 156 156 &self, 157 157 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 158 158 - { 159 159 - let value = &self.images; 160 160 - if value.len() > 48usize { 158 158 + if let Some(ref value) = self.blurhash { 159 159 + if value.len() > 32usize { 161 160 return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 162 162 - field: "images", 163 163 - max: 48usize, 161 161 + field: "blurhash", 162 162 + max: 32usize, 164 163 actual: value.len(), 165 164 }); 166 165 }

-50

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

reviewed

··· 754 754 fn validate( 755 755 &self, 756 756 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 757 757 - { 758 758 - let value = &self.records; 759 759 - if value.len() > 48usize { 760 760 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 761 761 - field: "records", 762 762 - max: 48usize, 763 763 - actual: value.len(), 764 764 - }); 765 765 - } 766 766 - } 767 757 Ok(()) 768 758 } 769 759 } ··· 1123 1113 fn validate( 1124 1114 &self, 1125 1115 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1126 1126 - { 1127 1127 - let value = &self.records; 1128 1128 - if value.len() > 48usize { 1129 1129 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1130 1130 - field: "records", 1131 1131 - max: 48usize, 1132 1132 - actual: value.len(), 1133 1133 - }); 1134 1134 - } 1135 1135 - } 1136 1116 Ok(()) 1137 1117 } 1138 1118 } ··· 1490 1470 fn validate( 1491 1471 &self, 1492 1472 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1493 1493 - { 1494 1494 - let value = &self.records; 1495 1495 - if value.len() > 48usize { 1496 1496 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1497 1497 - field: "records", 1498 1498 - max: 48usize, 1499 1499 - actual: value.len(), 1500 1500 - }); 1501 1501 - } 1502 1502 - } 1503 1473 Ok(()) 1504 1474 } 1505 1475 } ··· 1857 1827 fn validate( 1858 1828 &self, 1859 1829 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1860 1860 - { 1861 1861 - let value = &self.records; 1862 1862 - if value.len() > 48usize { 1863 1863 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1864 1864 - field: "records", 1865 1865 - max: 48usize, 1866 1866 - actual: value.len(), 1867 1867 - }); 1868 1868 - } 1869 1869 - } 1870 1830 Ok(()) 1871 1831 } 1872 1832 } ··· 2278 2238 fn validate( 2279 2239 &self, 2280 2240 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 2281 2281 - { 2282 2282 - let value = &self.records; 2283 2283 - if value.len() > 48usize { 2284 2284 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 2285 2285 - field: "records", 2286 2286 - max: 48usize, 2287 2287 - actual: value.len(), 2288 2288 - }); 2289 2289 - } 2290 2290 - } 2291 2241 Ok(()) 2292 2242 } 2293 2243 }

-43

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

reviewed

··· 220 220 fn validate( 221 221 &self, 222 222 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 223 223 - if let Some(ref value) = self.alt { 224 224 - if value.len() > 10000usize { 225 225 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 226 226 - field: "alt", 227 227 - max: 10000usize, 228 228 - actual: value.len(), 229 229 - }); 230 230 - } 231 231 - } 232 232 - if let Some(ref value) = self.alt { 233 233 - { 234 234 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 235 235 - value.as_ref(), 236 236 - true, 237 237 - ) 238 238 - .count(); 239 239 - if count > 1000usize { 240 240 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 241 241 - field: "alt", 242 242 - max: 1000usize, 243 243 - actual: count, 244 244 - }); 245 245 - } 246 246 - } 247 247 - } 248 248 - if let Some(ref value) = self.captions { 249 249 - if value.len() > 20usize { 250 250 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 251 251 - field: "captions", 252 252 - max: 20usize, 253 253 - actual: value.len(), 254 254 - }); 255 255 - } 256 256 - } 257 223 Ok(()) 258 224 } 259 225 } ··· 775 741 actual: count, 776 742 }); 777 743 } 778 778 - } 779 779 - } 780 780 - if let Some(ref value) = self.captions { 781 781 - if value.len() > 20usize { 782 782 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 783 783 - field: "captions", 784 784 - max: 20usize, 785 785 - actual: value.len(), 786 786 - }); 787 744 } 788 745 } 789 746 Ok(())

+52

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

reviewed

··· 233 233 fn validate( 234 234 &self, 235 235 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 236 236 + if let Some(ref value) = self.description { 237 237 + if value.len() > 5000usize { 238 238 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 239 239 + field: "description", 240 240 + max: 5000usize, 241 241 + actual: value.len(), 242 242 + }); 243 243 + } 244 244 + } 245 245 + if let Some(ref value) = self.description { 246 246 + { 247 247 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 248 248 + value.as_ref(), 249 249 + true, 250 250 + ) 251 251 + .count(); 252 252 + if count > 500usize { 253 253 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 254 254 + field: "description", 255 255 + max: 500usize, 256 256 + actual: count, 257 257 + }); 258 258 + } 259 259 + } 260 260 + } 261 261 + { 262 262 + let value = &self.display_name; 263 263 + if value.len() > 640usize { 264 264 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 265 265 + field: "display_name", 266 266 + max: 640usize, 267 267 + actual: value.len(), 268 268 + }); 269 269 + } 270 270 + } 271 271 + { 272 272 + let value = &self.display_name; 273 273 + { 274 274 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 275 275 + value.as_ref(), 276 276 + true, 277 277 + ) 278 278 + .count(); 279 279 + if count > 64usize { 280 280 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 281 281 + field: "display_name", 282 282 + max: 64usize, 283 283 + actual: count, 284 284 + }); 285 285 + } 286 286 + } 287 287 + } 236 288 Ok(()) 237 289 } 238 290 }

+20

crates/jacquard-api/src/social_grain.rs

reviewed

··· 83 83 fn validate( 84 84 &self, 85 85 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 86 86 + { 87 87 + let value = &self.height; 88 88 + if *value < 1i64 { 89 89 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 90 90 + field: "height", 91 91 + min: 1i64, 92 92 + actual: *value, 93 93 + }); 94 94 + } 95 95 + } 96 96 + { 97 97 + let value = &self.width; 98 98 + if *value < 1i64 { 99 99 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 100 100 + field: "width", 101 101 + min: 1i64, 102 102 + actual: *value, 103 103 + }); 104 104 + } 105 105 + } 86 106 Ok(()) 87 107 } 88 108 }

+50

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

reviewed

··· 188 188 fn validate( 189 189 &self, 190 190 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 191 191 + if let Some(ref value) = self.description { 192 192 + if value.len() > 2560usize { 193 193 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 194 194 + field: "description", 195 195 + max: 2560usize, 196 196 + actual: value.len(), 197 197 + }); 198 198 + } 199 199 + } 200 200 + if let Some(ref value) = self.description { 201 201 + { 202 202 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 203 203 + value.as_ref(), 204 204 + true, 205 205 + ) 206 206 + .count(); 207 207 + if count > 256usize { 208 208 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 209 209 + field: "description", 210 210 + max: 256usize, 211 211 + actual: count, 212 212 + }); 213 213 + } 214 214 + } 215 215 + } 216 216 + if let Some(ref value) = self.display_name { 217 217 + if value.len() > 640usize { 218 218 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 219 219 + field: "display_name", 220 220 + max: 640usize, 221 221 + actual: value.len(), 222 222 + }); 223 223 + } 224 224 + } 225 225 + if let Some(ref value) = self.display_name { 226 226 + { 227 227 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 228 228 + value.as_ref(), 229 229 + true, 230 230 + ) 231 231 + .count(); 232 232 + if count > 64usize { 233 233 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 234 234 + field: "display_name", 235 235 + max: 64usize, 236 236 + actual: count, 237 237 + }); 238 238 + } 239 239 + } 240 240 + } 191 241 Ok(()) 192 242 } 193 243 }

-70

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

reviewed

··· 529 529 fn validate( 530 530 &self, 531 531 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 532 532 - if let Some(ref value) = self.languages { 533 533 - if value.len() > 3usize { 534 534 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 535 535 - field: "languages", 536 536 - max: 3usize, 537 537 - actual: value.len(), 538 538 - }); 539 539 - } 540 540 - } 541 541 - { 542 542 - let value = &self.name; 543 543 - if value.len() > 320usize { 544 544 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 545 545 - field: "name", 546 546 - max: 320usize, 547 547 - actual: value.len(), 548 548 - }); 549 549 - } 550 550 - } 551 551 - { 552 552 - let value = &self.name; 553 553 - { 554 554 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 555 555 - value.as_ref(), 556 556 - true, 557 557 - ) 558 558 - .count(); 559 559 - if count > 32usize { 560 560 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 561 561 - field: "name", 562 562 - max: 32usize, 563 563 - actual: count, 564 564 - }); 565 565 - } 566 566 - } 567 567 - } 568 568 - if let Some(ref value) = self.tags { 569 569 - if value.len() > 20usize { 570 570 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 571 571 - field: "tags", 572 572 - max: 20usize, 573 573 - actual: value.len(), 574 574 - }); 575 575 - } 576 576 - } 577 577 - if let Some(ref value) = self.topic { 578 578 - if value.len() > 2560usize { 579 579 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 580 580 - field: "topic", 581 581 - max: 2560usize, 582 582 - actual: value.len(), 583 583 - }); 584 584 - } 585 585 - } 586 586 - if let Some(ref value) = self.topic { 587 587 - { 588 588 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 589 589 - value.as_ref(), 590 590 - true, 591 591 - ) 592 592 - .count(); 593 593 - if count > 256usize { 594 594 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 595 595 - field: "topic", 596 596 - max: 256usize, 597 597 - actual: count, 598 598 - }); 599 599 - } 600 600 - } 601 601 - } 602 532 Ok(()) 603 533 } 604 534 }

+47

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

reviewed

··· 197 197 fn validate( 198 198 &self, 199 199 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 200 200 + { 201 201 + let value = &self.byte_end; 202 202 + if *value < 0i64 { 203 203 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 204 204 + field: "byte_end", 205 205 + min: 0i64, 206 206 + actual: *value, 207 207 + }); 208 208 + } 209 209 + } 210 210 + { 211 211 + let value = &self.byte_start; 212 212 + if *value < 0i64 { 213 213 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 214 214 + field: "byte_start", 215 215 + min: 0i64, 216 216 + actual: *value, 217 217 + }); 218 218 + } 219 219 + } 200 220 Ok(()) 201 221 } 202 222 } ··· 1004 1024 fn validate( 1005 1025 &self, 1006 1026 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1027 1027 + { 1028 1028 + let value = &self.room; 1029 1029 + if value.len() > 640usize { 1030 1030 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1031 1031 + field: "room", 1032 1032 + max: 640usize, 1033 1033 + actual: value.len(), 1034 1034 + }); 1035 1035 + } 1036 1036 + } 1037 1037 + { 1038 1038 + let value = &self.room; 1039 1039 + { 1040 1040 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 1041 1041 + value.as_ref(), 1042 1042 + true, 1043 1043 + ) 1044 1044 + .count(); 1045 1045 + if count > 64usize { 1046 1046 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 1047 1047 + field: "room", 1048 1048 + max: 64usize, 1049 1049 + actual: count, 1050 1050 + }); 1051 1051 + } 1052 1052 + } 1053 1053 + } 1007 1054 Ok(()) 1008 1055 } 1009 1056 }

+47

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

reviewed

··· 62533 62533 fn validate( 62534 62534 &self, 62535 62535 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 62536 62536 + { 62537 62537 + let value = &self.score; 62538 62538 + if *value > 100i64 { 62539 62539 + return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 62540 62540 + field: "score", 62541 62541 + max: 100i64, 62542 62542 + actual: *value, 62543 62543 + }); 62544 62544 + } 62545 62545 + } 62546 62546 + { 62547 62547 + let value = &self.score; 62548 62548 + if *value < 0i64 { 62549 62549 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 62550 62550 + field: "score", 62551 62551 + min: 0i64, 62552 62552 + actual: *value, 62553 62553 + }); 62554 62554 + } 62555 62555 + } 62536 62556 Ok(()) 62537 62557 } 62538 62558 } ··· 79890 79910 fn validate( 79891 79911 &self, 79892 79912 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 79913 79913 + if let Some(ref value) = self.policies { 79914 79914 + if value.len() > 5usize { 79915 79915 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 79916 79916 + field: "policies", 79917 79917 + max: 5usize, 79918 79918 + actual: value.len(), 79919 79919 + }); 79920 79920 + } 79921 79921 + } 79893 79922 Ok(()) 79894 79923 } 79895 79924 } ··· 153383 153412 fn validate( 153384 153413 &self, 153385 153414 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 153415 153415 + if let Some(ref value) = self.priority_score { 153416 153416 + if *value > 100i64 { 153417 153417 + return Err(::jacquard_lexicon::schema::ValidationError::Maximum { 153418 153418 + field: "priority_score", 153419 153419 + max: 100i64, 153420 153420 + actual: *value, 153421 153421 + }); 153422 153422 + } 153423 153423 + } 153424 153424 + if let Some(ref value) = self.priority_score { 153425 153425 + if *value < 0i64 { 153426 153426 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 153427 153427 + field: "priority_score", 153428 153428 + min: 0i64, 153429 153429 + actual: *value, 153430 153430 + }); 153431 153431 + } 153432 153432 + } 153386 153433 Ok(()) 153387 153434 } 153388 153435 }

+9

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

reviewed

··· 1564 1564 fn validate( 1565 1565 &self, 1566 1566 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 1567 1567 + if let Some(ref value) = self.policies { 1568 1568 + if value.len() > 5usize { 1569 1569 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 1570 1570 + field: "policies", 1571 1571 + max: 5usize, 1572 1572 + actual: value.len(), 1573 1573 + }); 1574 1574 + } 1575 1575 + } 1567 1576 Ok(()) 1568 1577 } 1569 1578 }

+90

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

reviewed

··· 187 187 fn validate( 188 188 &self, 189 189 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 190 190 + if let Some(ref value) = self.description { 191 191 + if value.len() > 10240usize { 192 192 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 193 193 + field: "description", 194 194 + max: 10240usize, 195 195 + actual: value.len(), 196 196 + }); 197 197 + } 198 198 + } 199 199 + if let Some(ref value) = self.description { 200 200 + { 201 201 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 202 202 + value.as_ref(), 203 203 + true, 204 204 + ) 205 205 + .count(); 206 206 + if count > 1024usize { 207 207 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 208 208 + field: "description", 209 209 + max: 1024usize, 210 210 + actual: count, 211 211 + }); 212 212 + } 213 213 + } 214 214 + } 215 215 + { 216 216 + let value = &self.name; 217 217 + if value.len() > 128usize { 218 218 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 219 219 + field: "name", 220 220 + max: 128usize, 221 221 + actual: value.len(), 222 222 + }); 223 223 + } 224 224 + } 225 225 + { 226 226 + let value = &self.name; 227 227 + if value.len() < 3usize { 228 228 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 229 229 + field: "name", 230 230 + min: 3usize, 231 231 + actual: value.len(), 232 232 + }); 233 233 + } 234 234 + } 190 235 Ok(()) 191 236 } 192 237 } ··· 371 416 fn validate( 372 417 &self, 373 418 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 419 419 + if let Some(ref value) = self.description { 420 420 + if value.len() > 10240usize { 421 421 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 422 422 + field: "description", 423 423 + max: 10240usize, 424 424 + actual: value.len(), 425 425 + }); 426 426 + } 427 427 + } 428 428 + if let Some(ref value) = self.description { 429 429 + { 430 430 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 431 431 + value.as_ref(), 432 432 + true, 433 433 + ) 434 434 + .count(); 435 435 + if count > 1024usize { 436 436 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 437 437 + field: "description", 438 438 + max: 1024usize, 439 439 + actual: count, 440 440 + }); 441 441 + } 442 442 + } 443 443 + } 444 444 + { 445 445 + let value = &self.name; 446 446 + if value.len() > 128usize { 447 447 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 448 448 + field: "name", 449 449 + max: 128usize, 450 450 + actual: value.len(), 451 451 + }); 452 452 + } 453 453 + } 454 454 + { 455 455 + let value = &self.name; 456 456 + if value.len() < 3usize { 457 457 + return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 458 458 + field: "name", 459 459 + min: 3usize, 460 460 + actual: value.len(), 461 461 + }); 462 462 + } 463 463 + } 374 464 Ok(()) 375 465 } 376 466 }

+25

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

reviewed

··· 236 236 fn validate( 237 237 &self, 238 238 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 239 239 + if let Some(ref value) = self.description { 240 240 + if value.len() > 10240usize { 241 241 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 242 242 + field: "description", 243 243 + max: 10240usize, 244 244 + actual: value.len(), 245 245 + }); 246 246 + } 247 247 + } 248 248 + if let Some(ref value) = self.description { 249 249 + { 250 250 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 251 251 + value.as_ref(), 252 252 + true, 253 253 + ) 254 254 + .count(); 255 255 + if count > 1024usize { 256 256 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 257 257 + field: "description", 258 258 + max: 1024usize, 259 259 + actual: count, 260 260 + }); 261 261 + } 262 262 + } 263 263 + } 239 264 Ok(()) 240 265 } 241 266 }

-34

crates/jacquard-api/src/tools_smokesignal/blahg/content/post.rs

reviewed

··· 173 173 fn validate( 174 174 &self, 175 175 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 176 176 - if let Some(ref value) = self.langs { 177 177 - if value.len() > 3usize { 178 178 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 179 179 - field: "langs", 180 180 - max: 3usize, 181 181 - actual: value.len(), 182 182 - }); 183 183 - } 184 184 - } 185 185 - if let Some(ref value) = self.title { 186 186 - if value.len() > 2000usize { 187 187 - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 188 188 - field: "title", 189 189 - max: 2000usize, 190 190 - actual: value.len(), 191 191 - }); 192 192 - } 193 193 - } 194 194 - if let Some(ref value) = self.title { 195 195 - { 196 196 - let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 197 197 - value.as_ref(), 198 198 - true, 199 199 - ) 200 200 - .count(); 201 201 - if count > 200usize { 202 202 - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 203 203 - field: "title", 204 204 - max: 200usize, 205 205 - actual: count, 206 206 - }); 207 207 - } 208 208 - } 209 209 - } 210 176 Ok(()) 211 177 } 212 178 }

+25

crates/jacquard-api/src/uk_skyblur/preference.rs

reviewed

··· 262 262 fn validate( 263 263 &self, 264 264 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 265 265 + if let Some(ref value) = self.description { 266 266 + if value.len() > 10000usize { 267 267 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 268 268 + field: "description", 269 269 + max: 10000usize, 270 270 + actual: value.len(), 271 271 + }); 272 272 + } 273 273 + } 274 274 + if let Some(ref value) = self.description { 275 275 + { 276 276 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 277 277 + value.as_ref(), 278 278 + true, 279 279 + ) 280 280 + .count(); 281 281 + if count > 100000usize { 282 282 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 283 283 + field: "description", 284 284 + max: 100000usize, 285 285 + actual: count, 286 286 + }); 287 287 + } 288 288 + } 289 289 + } 265 290 Ok(()) 266 291 } 267 292 }

+20

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

reviewed

··· 82 82 fn validate( 83 83 &self, 84 84 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 85 85 + { 86 86 + let value = &self.height; 87 87 + if *value < 1i64 { 88 88 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 89 89 + field: "height", 90 90 + min: 1i64, 91 91 + actual: *value, 92 92 + }); 93 93 + } 94 94 + } 95 95 + { 96 96 + let value = &self.width; 97 97 + if *value < 1i64 { 98 98 + return Err(::jacquard_lexicon::schema::ValidationError::Minimum { 99 99 + field: "width", 100 100 + min: 1i64, 101 101 + actual: *value, 102 102 + }); 103 103 + } 104 104 + } 85 105 Ok(()) 86 106 } 87 107 }

+27

crates/jacquard-api/src/win_tomo_x/pushat.rs

reviewed

··· 181 181 fn validate( 182 182 &self, 183 183 ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { 184 184 + { 185 185 + let value = &self.name; 186 186 + if value.len() > 300usize { 187 187 + return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 188 188 + field: "name", 189 189 + max: 300usize, 190 190 + actual: value.len(), 191 191 + }); 192 192 + } 193 193 + } 194 194 + { 195 195 + let value = &self.name; 196 196 + { 197 197 + let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( 198 198 + value.as_ref(), 199 199 + true, 200 200 + ) 201 201 + .count(); 202 202 + if count > 30usize { 203 203 + return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { 204 204 + field: "name", 205 205 + max: 30usize, 206 206 + actual: count, 207 207 + }); 208 208 + } 209 209 + } 210 210 + } 184 211 Ok(()) 185 212 } 186 213 }

+2 -3

crates/jacquard-common/src/xrpc.rs

reviewed

··· 124 124 /// Decode the request body for procedures. 125 125 /// 126 126 /// Default implementation deserializes from JSON. Override for non-JSON encodings. 127 127 - fn decode_body<'de>(body: &'de [u8]) -> XrpcResult<Box<Self>> 127 127 + fn decode_body<'de>(body: &'de [u8]) -> Result<Box<Self>, DecodeError> 128 128 where 129 129 Self: Deserialize<'de>, 130 130 { 131 131 - let body: Self = serde_json::from_slice(body) 132 132 - .map_err(|e| crate::error::ClientError::decode(format!("{:?}", e)))?; 131 131 + let body: Self = serde_json::from_slice(body)?; 133 132 134 133 Ok(Box::new(body)) 135 134 }

+4 -4

crates/jacquard-lexicon/src/derive_impl/doc_to_tokens.rs

reviewed

··· 583 583 // Generate the inner validation check 584 584 let inner_check = match &check.check { 585 585 ConstraintCheck::MaxLength { max } => quote! { 586 586 - if value.len() > #max { 586 586 + if value.as_ref().len() > #max { 587 587 return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { 588 588 field: #field_name_static, 589 589 max: #max, 590 590 - actual: value.len(), 590 590 + actual: value.as_ref().len(), 591 591 }); 592 592 } 593 593 }, 594 594 ConstraintCheck::MinLength { min } => quote! { 595 595 - if value.len() < #min { 595 595 + if value.as_ref().len() < #min { 596 596 return Err(::jacquard_lexicon::schema::ValidationError::MinLength { 597 597 field: #field_name_static, 598 598 min: #min, 599 599 - actual: value.len(), 599 599 + actual: value.as_ref().len(), 600 600 }); 601 601 } 602 602 },