From 117b66ade1632ecba80b22bca633bb72d8ea2595 Mon Sep 17 00:00:00 2001 From: Orual Date: Mon, 27 Oct 2025 15:19:35 +0000 Subject: [PATCH] api generation post more cleanup --- justfile | 4 ++-- crates/jacquard-api/src/blue__2048.rs | 2 +- crates/jacquard-api/src/buzz_bookhive.rs | 94 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------------- crates/jacquard-api/src/my_skylights.rs | 2 +- crates/jacquard-api/src/place_stream.rs | 6 +++--- crates/jacquard-api/src/social_grain.rs | 14 +++++++++----- crates/jacquard-lexicon/src/codegen.rs | 4 +++- crates/jacquard-lexicon/src/schema.rs | 71 ++++++++--------------------------------------------------------------- crates/jacquard-lexicon/src/validation.rs | 7 +++++++ crates/jacquard-lexicon/tests/schema_tests.rs | 11 ++++++----- crates/jacquard-api/src/app_bsky/actor.rs | 198 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------------------------------------------------------------------------- crates/jacquard-api/src/app_bsky/bookmark.rs | 4 ++-- crates/jacquard-api/src/app_bsky/embed.rs | 14 +++++++++----- crates/jacquard-api/src/app_bsky/feed.rs | 84 ++++++++++++++++++++++++++++++++++++++++++++++++++---------------------------------- crates/jacquard-api/src/app_bsky/graph.rs | 106 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------------------------- crates/jacquard-api/src/app_bsky/labeler.rs | 20 ++++++++++++-------- crates/jacquard-api/src/app_bsky/notification.rs | 14 +++++++------- crates/jacquard-api/src/app_bsky/unspecced.rs | 24 ++++++++++++------------ crates/jacquard-api/src/app_bsky/video.rs | 14 +++++++++----- crates/jacquard-api/src/app_ocho/auth.rs | 2 +- crates/jacquard-api/src/app_ocho/plugin.rs | 26 +++++++++++++------------- crates/jacquard-api/src/app_rocksky/actor.rs | 4 ++-- crates/jacquard-api/src/app_rocksky/album.rs | 60 +++++++++++++++++++++++++++++++++++++++--------------------- crates/jacquard-api/src/app_rocksky/apikey.rs | 2 +- crates/jacquard-api/src/app_rocksky/artist.rs | 54 +++++++++++++++++++++++++++++++++++------------------- crates/jacquard-api/src/app_rocksky/charts.rs | 4 ++-- crates/jacquard-api/src/app_rocksky/dropbox.rs | 6 +++--- crates/jacquard-api/src/app_rocksky/feed.rs | 6 +++--- crates/jacquard-api/src/app_rocksky/googledrive.rs | 4 ++-- crates/jacquard-api/src/app_rocksky/like.rs | 2 +- crates/jacquard-api/src/app_rocksky/player.rs | 2 +- crates/jacquard-api/src/app_rocksky/playlist.rs | 36 +++++++++++++++++++++++------------- crates/jacquard-api/src/app_rocksky/radio.rs | 42 +++++++++++++++++++++++++++--------------- crates/jacquard-api/src/app_rocksky/scrobble.rs | 108 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------------------- crates/jacquard-api/src/app_rocksky/shout.rs | 18 +++++++++++------- crates/jacquard-api/src/app_rocksky/song.rs | 138 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----------------------------------------------- crates/jacquard-api/src/app_rocksky/spotify.rs | 2 +- crates/jacquard-api/src/app_rocksky/stats.rs | 2 +- crates/jacquard-api/src/blog_pckt/blog.rs | 6 +++--- crates/jacquard-api/src/blog_pckt/post.rs | 2 +- crates/jacquard-api/src/blog_pckt/publication.rs | 20 +++++++++++++------- crates/jacquard-api/src/blog_pckt/theme.rs | 40 ++++++++++++++++++++++++++-------------- crates/jacquard-api/src/blue__2048/game.rs | 2 +- crates/jacquard-api/src/blue__2048/key.rs | 4 ++-- crates/jacquard-api/src/blue__2048/verification.rs | 2 +- crates/jacquard-api/src/blue_atplane/fav_client.rs | 8 +++++--- crates/jacquard-api/src/blue_linkat/board.rs | 4 ++-- crates/jacquard-api/src/buzz_bookhive/book.rs | 44 +++++++++++++++++++++++++++++--------------- crates/jacquard-api/src/buzz_bookhive/buzz.rs | 14 +++++++++----- crates/jacquard-api/src/buzz_bookhive/hive_book.rs | 44 +++++++++++++++++++++++++++++--------------- crates/jacquard-api/src/chat_bsky/actor.rs | 14 +++++++++----- crates/jacquard-api/src/chat_bsky/convo.rs | 62 +++++++++++++++++++++++++++++++++++--------------------------- crates/jacquard-api/src/com_atproto/admin.rs | 10 +++++----- crates/jacquard-api/src/com_atproto/identity.rs | 2 +- crates/jacquard-api/src/com_atproto/label.rs | 64 +++++++++++++++++++++++++++++++++++++++++----------------------- crates/jacquard-api/src/com_atproto/repo.rs | 2 +- crates/jacquard-api/src/com_atproto/server.rs | 4 ++-- crates/jacquard-api/src/com_whtwnd/blog.rs | 20 ++++++++++++-------- crates/jacquard-api/src/my_skylights/list.rs | 2 +- crates/jacquard-api/src/my_skylights/list_item.rs | 4 ++-- crates/jacquard-api/src/my_skylights/rel.rs | 18 +++++++++++------- crates/jacquard-api/src/net_aftertheinter/coolthingtwo.rs | 20 +++++++++++++------- crates/jacquard-api/src/net_altq/aqfile.rs | 42 +++++++++++++++++++++++++++--------------- crates/jacquard-api/src/net_bnewbold/m.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/network_slices/actor.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/network_slices/lexicon.rs | 14 +++++++++----- crates/jacquard-api/src/network_slices/slice.rs | 24 +++++++++++++++--------- crates/jacquard-api/src/network_slices/waitlist.rs | 4 ++-- crates/jacquard-api/src/place_atwork/endorsement.rs | 14 +++++++++----- crates/jacquard-api/src/place_atwork/endorsement_proof.rs | 2 +- crates/jacquard-api/src/place_atwork/get_listings.rs | 2 +- crates/jacquard-api/src/place_atwork/listing.rs | 20 +++++++++++++------- crates/jacquard-api/src/place_atwork/profile.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/place_atwork/search_listings.rs | 2 +- crates/jacquard-api/src/place_stream/broadcast.rs | 2 +- crates/jacquard-api/src/place_stream/chat.rs | 2 +- crates/jacquard-api/src/place_stream/key.rs | 14 +++++++++----- crates/jacquard-api/src/place_stream/livestream.rs | 22 +++++++++++++--------- crates/jacquard-api/src/place_stream/segment.rs | 10 +++++----- crates/jacquard-api/src/place_stream/server.rs | 46 ++++++++++++++++++++++++++++++---------------- crates/jacquard-api/src/place_wisp/fs.rs | 32 ++++++++++++++++++++------------ crates/jacquard-api/src/pub_leaflet/comment.rs | 6 +++--- crates/jacquard-api/src/pub_leaflet/document.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/pub_leaflet/publication.rs | 18 +++++++++++------- crates/jacquard-api/src/sh_tangled/knot.rs | 2 +- crates/jacquard-api/src/sh_tangled/pipeline.rs | 54 +++++++++++++++++++++++++++++++++--------------------- crates/jacquard-api/src/sh_tangled/public_key.rs | 8 +++++--- crates/jacquard-api/src/sh_tangled/repo.rs | 14 +++++++++----- crates/jacquard-api/src/sh_tangled/spindle.rs | 2 +- crates/jacquard-api/src/sh_tangled/string.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/sh_weaver/actor.rs | 128 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------------------------------- crates/jacquard-api/src/sh_weaver/edit.rs | 6 +++--- crates/jacquard-api/src/sh_weaver/embed.rs | 4 ++-- crates/jacquard-api/src/sh_weaver/notebook.rs | 14 +++++++------- crates/jacquard-api/src/social_clippr/actor.rs | 28 ++++++++++++++++++---------- crates/jacquard-api/src/social_clippr/feed.rs | 4 ++-- crates/jacquard-api/src/social_grain/actor.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/social_grain/favorite.rs | 2 +- crates/jacquard-api/src/social_grain/gallery.rs | 16 ++++++++++------ crates/jacquard-api/src/social_grain/photo.rs | 6 +++--- crates/jacquard-api/src/social_pmsky/proposal.rs | 8 +++++--- crates/jacquard-api/src/social_pmsky/vote.rs | 2 +- crates/jacquard-api/src/tools_ozone/communication.rs | 2 +- crates/jacquard-api/src/tools_ozone/moderation.rs | 122 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------------------------------------------- crates/jacquard-api/src/tools_ozone/safelink.rs | 4 ++-- crates/jacquard-api/src/tools_ozone/set.rs | 52 ++++++++++++++++++++++++++++++++++------------------ crates/jacquard-api/src/tools_ozone/setting.rs | 14 +++++++++----- crates/jacquard-api/src/tools_ozone/signature.rs | 2 +- crates/jacquard-api/src/tools_ozone/team.rs | 2 +- crates/jacquard-api/src/tools_ozone/verification.rs | 2 +- crates/jacquard-api/src/uk_ewancroft/now.rs | 14 +++++++++----- crates/jacquard-api/src/uk_skyblur/post.rs | 38 +++++++++++++++++++++++++------------- crates/jacquard-api/src/uk_skyblur/preference.rs | 16 ++++++++++------ crates/jacquard-api/src/us_polhem/blog.rs | 14 +++++++++----- crates/jacquard-api/src/win_tomo_x/pushat.rs | 16 ++++++++++------ crates/jacquard-lexicon/src/codegen/builder_heuristics.rs | 76 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ crates/jacquard-lexicon/src/codegen/lifetime.rs | 5 ----- crates/jacquard-lexicon/src/codegen/names.rs | 14 +++++++------- crates/jacquard-lexicon/src/codegen/schema_impl.rs | 2 +- crates/jacquard-lexicon/src/codegen/structs.rs | 330 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- crates/jacquard-lexicon/src/codegen/types.rs | 45 +++++++++++++++------------------------------ crates/jacquard-lexicon/src/codegen/union_codegen.rs | 184 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ crates/jacquard-lexicon/src/codegen/utils.rs | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++--- crates/jacquard-lexicon/src/codegen/xrpc.rs | 223 ++++++++++++++++++++++++++++++++++++++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- crates/jacquard-lexicon/src/derive_impl/doc_to_tokens.rs | 24 ++++++++++++------------ crates/jacquard-lexicon/src/derive_impl/lexicon_schema.rs | 4 ++-- crates/jacquard-api/src/app_blebbit/authr/folder.rs | 4 ++-- crates/jacquard-api/src/app_blebbit/authr/group.rs | 4 ++-- crates/jacquard-api/src/app_blebbit/authr/page.rs | 4 ++-- crates/jacquard-api/src/app_bsky/actor/profile.rs | 38 +++++++++++++++++++++++++------------- crates/jacquard-api/src/app_bsky/actor/status.rs | 8 +++++--- crates/jacquard-api/src/app_bsky/embed/external.rs | 8 ++++---- crates/jacquard-api/src/app_bsky/embed/images.rs | 20 ++++++++++++-------- crates/jacquard-api/src/app_bsky/embed/record.rs | 12 ++++++------ crates/jacquard-api/src/app_bsky/embed/record_with_media.rs | 4 ++-- crates/jacquard-api/src/app_bsky/embed/video.rs | 36 +++++++++++++++++++++++------------- crates/jacquard-api/src/app_bsky/feed/describe_feed_generator.rs | 4 ++-- crates/jacquard-api/src/app_bsky/feed/generator.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/app_bsky/feed/get_likes.rs | 2 +- crates/jacquard-api/src/app_bsky/feed/like.rs | 2 +- crates/jacquard-api/src/app_bsky/feed/post.rs | 44 ++++++++++++++++++++++++++++---------------- crates/jacquard-api/src/app_bsky/feed/postgate.rs | 16 ++++++++++------ crates/jacquard-api/src/app_bsky/feed/repost.rs | 2 +- crates/jacquard-api/src/app_bsky/feed/threadgate.rs | 22 +++++++++++++--------- crates/jacquard-api/src/app_bsky/graph/block.rs | 2 +- crates/jacquard-api/src/app_bsky/graph/follow.rs | 2 +- crates/jacquard-api/src/app_bsky/graph/get_lists_with_membership.rs | 2 +- crates/jacquard-api/src/app_bsky/graph/get_starter_packs_with_membership.rs | 2 +- crates/jacquard-api/src/app_bsky/graph/list.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/app_bsky/graph/listblock.rs | 2 +- crates/jacquard-api/src/app_bsky/graph/listitem.rs | 2 +- crates/jacquard-api/src/app_bsky/graph/starterpack.rs | 40 ++++++++++++++++++++++++++-------------- crates/jacquard-api/src/app_bsky/graph/verification.rs | 2 +- crates/jacquard-api/src/app_bsky/labeler/service.rs | 2 +- crates/jacquard-api/src/app_bsky/notification/declaration.rs | 2 +- crates/jacquard-api/src/app_bsky/notification/list_notifications.rs | 2 +- crates/jacquard-api/src/app_bsky/richtext/facet.rs | 34 +++++++++++++++++++++------------- crates/jacquard-api/src/app_bsky/unspecced/get_config.rs | 2 +- crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_other_v2.rs | 2 +- crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_v2.rs | 2 +- crates/jacquard-api/src/app_bsky/unspecced/get_tagged_suggestions.rs | 2 +- crates/jacquard-api/src/app_ocho/edu/verification.rs | 2 +- crates/jacquard-api/src/app_ocho/plugin/service.rs | 2 +- crates/jacquard-api/src/beauty_cybernetic/trustcow/review.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/beauty_cybernetic/trustcow/transaction.rs | 20 +++++++++++++------- crates/jacquard-api/src/beauty_cybernetic/trustcow/warrant.rs | 8 +++++--- crates/jacquard-api/src/blue__2048/key/game.rs | 2 +- crates/jacquard-api/src/blue__2048/player/profile.rs | 2 +- crates/jacquard-api/src/blue__2048/player/stats.rs | 2 +- crates/jacquard-api/src/blue__2048/verification/game.rs | 2 +- crates/jacquard-api/src/blue__2048/verification/stats.rs | 2 +- crates/jacquard-api/src/blue_rito/feed/bookmark.rs | 46 ++++++++++++++++++++++++++++++---------------- crates/jacquard-api/src/blue_rito/feed/like.rs | 2 +- crates/jacquard-api/src/blue_rito/service/get_schema.rs | 2 +- crates/jacquard-api/src/blue_rito/service/schema.rs | 2 +- crates/jacquard-api/src/blue_zio/atfile/finger.rs | 4 ++-- crates/jacquard-api/src/blue_zio/atfile/lock.rs | 2 +- crates/jacquard-api/src/blue_zio/atfile/meta.rs | 2 +- crates/jacquard-api/src/chat_bsky/actor/declaration.rs | 2 +- crates/jacquard-api/src/chat_bsky/convo/send_message_batch.rs | 2 +- crates/jacquard-api/src/chat_bsky/moderation/get_actor_metadata.rs | 2 +- crates/jacquard-api/src/club_stellz/evm/address_control.rs | 34 ++++++++++++++++++++++------------ crates/jacquard-api/src/com_atproto/label/subscribe_labels.rs | 4 ++-- crates/jacquard-api/src/com_atproto/lexicon/schema.rs | 2 +- crates/jacquard-api/src/com_atproto/moderation/create_report.rs | 2 +- crates/jacquard-api/src/com_atproto/repo/apply_writes.rs | 18 ++++++++++-------- crates/jacquard-api/src/com_atproto/repo/list_missing_blobs.rs | 2 +- crates/jacquard-api/src/com_atproto/repo/list_records.rs | 2 +- crates/jacquard-api/src/com_atproto/repo/strong_ref.rs | 2 +- crates/jacquard-api/src/com_atproto/server/create_app_password.rs | 2 +- crates/jacquard-api/src/com_atproto/server/create_invite_codes.rs | 2 +- crates/jacquard-api/src/com_atproto/server/describe_server.rs | 4 ++-- crates/jacquard-api/src/com_atproto/server/list_app_passwords.rs | 2 +- crates/jacquard-api/src/com_atproto/sync/list_hosts.rs | 2 +- crates/jacquard-api/src/com_atproto/sync/list_repos.rs | 2 +- crates/jacquard-api/src/com_atproto/sync/list_repos_by_collection.rs | 2 +- crates/jacquard-api/src/com_atproto/sync/subscribe_repos.rs | 18 ++++++++++-------- crates/jacquard-api/src/com_atproto/temp/check_handle_availability.rs | 6 +++--- crates/jacquard-api/src/com_crabdance/nandi/post.rs | 38 +++++++++++++++++++++++++------------- crates/jacquard-api/src/com_shinolabs/pinksea/app_view_defs.rs | 12 +++++++----- crates/jacquard-api/src/com_shinolabs/pinksea/oekaki.rs | 12 +++++++----- crates/jacquard-api/src/com_shinolabs/pinksea/profile.rs | 46 ++++++++++++++++++++++++++++++---------------- crates/jacquard-api/src/com_whtwnd/blog/entry.rs | 20 +++++++++++++------- crates/jacquard-api/src/community_lexicon/bookmarks/bookmark.rs | 2 +- crates/jacquard-api/src/community_lexicon/calendar/event.rs | 4 ++-- crates/jacquard-api/src/community_lexicon/calendar/rsvp.rs | 2 +- crates/jacquard-api/src/community_lexicon/interaction/like.rs | 2 +- crates/jacquard-api/src/community_lexicon/location/address.rs | 14 +++++++++----- crates/jacquard-api/src/community_lexicon/location/fsq.rs | 2 +- crates/jacquard-api/src/community_lexicon/location/geo.rs | 2 +- crates/jacquard-api/src/community_lexicon/location/hthree.rs | 2 +- crates/jacquard-api/src/community_lexicon/payments/web_monetization.rs | 2 +- crates/jacquard-api/src/dev_baileytownsend/health/calories.rs | 2 +- crates/jacquard-api/src/dev_baileytownsend/health/rings.rs | 2 +- crates/jacquard-api/src/dev_baileytownsend/health/steps.rs | 2 +- crates/jacquard-api/src/dev_baileytownsend/health/workout.rs | 2 +- crates/jacquard-api/src/dev_ocbwoy3/blueboard/board.rs | 14 +++++++++----- crates/jacquard-api/src/dev_ocbwoy3/blueboard/post.rs | 8 +++++--- crates/jacquard-api/src/dev_regnault/webfishing/savefile.rs | 2 +- crates/jacquard-api/src/fm_teal/alpha/actor.rs | 6 +++--- crates/jacquard-api/src/fm_teal/alpha/feed.rs | 64 ++++++++++++++++++++++++++++++++++++++++++---------------------- crates/jacquard-api/src/fm_teal/alpha/stats.rs | 6 +++--- crates/jacquard-api/src/fyi_frontpage/feed/comment.rs | 8 +++++--- crates/jacquard-api/src/fyi_frontpage/feed/post.rs | 16 ++++++++++------ crates/jacquard-api/src/fyi_frontpage/feed/vote.rs | 2 +- crates/jacquard-api/src/fyi_frontpage/richtext/block.rs | 16 ++++++++++------ crates/jacquard-api/src/fyi_unravel/frontpage/comment.rs | 14 +++++++++----- crates/jacquard-api/src/fyi_unravel/frontpage/post.rs | 14 +++++++++----- crates/jacquard-api/src/fyi_unravel/frontpage/vote.rs | 2 +- crates/jacquard-api/src/moe_karashiiro/kpaste/paste.rs | 14 +++++++++----- crates/jacquard-api/src/net_anisota/feed/draft.rs | 28 ++++++++++++++++++---------- crates/jacquard-api/src/net_anisota/feed/like.rs | 2 +- crates/jacquard-api/src/net_anisota/feed/list.rs | 20 +++++++++++++------- crates/jacquard-api/src/net_anisota/feed/list_item.rs | 2 +- crates/jacquard-api/src/net_anisota/feed/post.rs | 28 ++++++++++++++++++---------- crates/jacquard-api/src/net_anisota/feed/repost.rs | 2 +- crates/jacquard-api/src/net_anisota/graph/list_mute.rs | 16 ++++++++++------ crates/jacquard-api/src/net_anisota/graph/mute.rs | 16 ++++++++++------ crates/jacquard-api/src/net_bnewbold/demo/mushies.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/net_bnewbold/demo/mushroom.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/net_mmatt/right/now.rs | 2 +- crates/jacquard-api/src/net_mmatt/vitals/car.rs | 2 +- crates/jacquard-api/src/network_slices/actor/profile.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/network_slices/slice/get_actors.rs | 2 +- crates/jacquard-api/src/network_slices/slice/get_job_logs.rs | 2 +- crates/jacquard-api/src/network_slices/slice/get_job_status.rs | 4 ++-- crates/jacquard-api/src/network_slices/slice/get_o_auth_clients.rs | 2 +- crates/jacquard-api/src/network_slices/slice/get_slice_records.rs | 2 +- crates/jacquard-api/src/network_slices/slice/get_sparklines.rs | 2 +- crates/jacquard-api/src/network_slices/slice/get_sync_summary.rs | 2 +- crates/jacquard-api/src/network_slices/slice/stats.rs | 2 +- crates/jacquard-api/src/network_slices/waitlist/invite.rs | 2 +- crates/jacquard-api/src/network_slices/waitlist/request.rs | 2 +- crates/jacquard-api/src/org_devcon/event/test.rs | 2 +- crates/jacquard-api/src/org_robocracy/demo/fungus.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/org_robocracy/demo/mushies.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/place_stream/broadcast/origin.rs | 8 +++++--- crates/jacquard-api/src/place_stream/broadcast/syndication.rs | 2 +- crates/jacquard-api/src/place_stream/chat/gate.rs | 2 +- crates/jacquard-api/src/place_stream/chat/message.rs | 16 ++++++++++------ crates/jacquard-api/src/place_stream/chat/profile.rs | 40 ++++++++++++++++++++++++++-------------- crates/jacquard-api/src/place_stream/metadata/configuration.rs | 2 +- crates/jacquard-api/src/place_stream/metadata/content_rights.rs | 2 +- crates/jacquard-api/src/place_stream/metadata/content_warnings.rs | 2 +- crates/jacquard-api/src/place_stream/metadata/distribution_policy.rs | 2 +- crates/jacquard-api/src/place_stream/richtext/facet.rs | 2 +- crates/jacquard-api/src/place_stream/server/settings.rs | 2 +- crates/jacquard-api/src/pub_leaflet/blocks/blockquote.rs | 2 +- crates/jacquard-api/src/pub_leaflet/blocks/bsky_post.rs | 2 +- crates/jacquard-api/src/pub_leaflet/blocks/code.rs | 2 +- crates/jacquard-api/src/pub_leaflet/blocks/header.rs | 14 +++++++++----- crates/jacquard-api/src/pub_leaflet/blocks/horizontal_rule.rs | 2 +- crates/jacquard-api/src/pub_leaflet/blocks/iframe.rs | 14 +++++++++----- crates/jacquard-api/src/pub_leaflet/blocks/image.rs | 4 ++-- crates/jacquard-api/src/pub_leaflet/blocks/math.rs | 2 +- crates/jacquard-api/src/pub_leaflet/blocks/page.rs | 2 +- crates/jacquard-api/src/pub_leaflet/blocks/poll.rs | 2 +- crates/jacquard-api/src/pub_leaflet/blocks/text.rs | 2 +- crates/jacquard-api/src/pub_leaflet/blocks/unordered_list.rs | 4 ++-- crates/jacquard-api/src/pub_leaflet/blocks/website.rs | 2 +- crates/jacquard-api/src/pub_leaflet/graph/subscription.rs | 2 +- crates/jacquard-api/src/pub_leaflet/pages/canvas.rs | 8 ++++---- crates/jacquard-api/src/pub_leaflet/pages/linear_document.rs | 8 ++++---- crates/jacquard-api/src/pub_leaflet/poll/definition.rs | 28 ++++++++++++++++++---------- crates/jacquard-api/src/pub_leaflet/poll/vote.rs | 2 +- crates/jacquard-api/src/pub_leaflet/richtext/facet.rs | 32 ++++++++++++++++++-------------- crates/jacquard-api/src/pub_leaflet/theme/background_image.rs | 2 +- crates/jacquard-api/src/pub_leaflet/theme/color.rs | 88 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------------ crates/jacquard-api/src/sh_tangled/actor/profile.rs | 62 +++++++++++++++++++++++++++++++++++++++++--------------------- crates/jacquard-api/src/sh_tangled/feed/reaction.rs | 2 +- crates/jacquard-api/src/sh_tangled/feed/star.rs | 2 +- crates/jacquard-api/src/sh_tangled/git/ref_update.rs | 48 ++++++++++++++++++++++++++++++------------------ crates/jacquard-api/src/sh_tangled/graph/follow.rs | 2 +- crates/jacquard-api/src/sh_tangled/knot/list_keys.rs | 8 +++++--- crates/jacquard-api/src/sh_tangled/knot/member.rs | 2 +- crates/jacquard-api/src/sh_tangled/label/definition.rs | 16 ++++++++++------ crates/jacquard-api/src/sh_tangled/label/op.rs | 4 ++-- crates/jacquard-api/src/sh_tangled/pipeline/status.rs | 2 +- crates/jacquard-api/src/sh_tangled/repo/artifact.rs | 2 +- crates/jacquard-api/src/sh_tangled/repo/blob.rs | 4 ++-- crates/jacquard-api/src/sh_tangled/repo/branch.rs | 2 +- crates/jacquard-api/src/sh_tangled/repo/collaborator.rs | 2 +- crates/jacquard-api/src/sh_tangled/repo/get_default_branch.rs | 2 +- crates/jacquard-api/src/sh_tangled/repo/issue.rs | 2 +- crates/jacquard-api/src/sh_tangled/repo/languages.rs | 2 +- crates/jacquard-api/src/sh_tangled/repo/list_secrets.rs | 14 +++++++++----- crates/jacquard-api/src/sh_tangled/repo/merge_check.rs | 2 +- crates/jacquard-api/src/sh_tangled/repo/pull.rs | 18 +++++++++++------- crates/jacquard-api/src/sh_tangled/repo/tree.rs | 6 +++--- crates/jacquard-api/src/sh_tangled/spindle/member.rs | 2 +- crates/jacquard-api/src/sh_weaver/actor/profile.rs | 50 +++++++++++++++++++++++++++++++++----------------- crates/jacquard-api/src/sh_weaver/edit/cursor.rs | 12 ++++++------ crates/jacquard-api/src/sh_weaver/edit/diff.rs | 2 +- crates/jacquard-api/src/sh_weaver/edit/root.rs | 2 +- crates/jacquard-api/src/sh_weaver/embed/external.rs | 14 ++++++++------ crates/jacquard-api/src/sh_weaver/embed/images.rs | 16 ++++++++++------ crates/jacquard-api/src/sh_weaver/embed/record_with_media.rs | 4 ++-- crates/jacquard-api/src/sh_weaver/embed/records.rs | 18 ++++++++++-------- crates/jacquard-api/src/sh_weaver/embed/video.rs | 36 +++++++++++++++++++++++------------- crates/jacquard-api/src/sh_weaver/notebook/authors.rs | 4 ++-- crates/jacquard-api/src/sh_weaver/notebook/book.rs | 2 +- crates/jacquard-api/src/sh_weaver/notebook/chapter.rs | 2 +- crates/jacquard-api/src/sh_weaver/notebook/entry.rs | 8 +++++--- crates/jacquard-api/src/sh_weaver/publish/blob.rs | 2 +- crates/jacquard-api/src/social_clippr/actor/profile.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/social_clippr/feed/clip.rs | 56 +++++++++++++++++++++++++++++++++++++------------------- crates/jacquard-api/src/social_clippr/feed/tag.rs | 38 +++++++++++++++++++++++++------------- crates/jacquard-api/src/social_flockfeeds/lexical/action.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/aggregaterating.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/alignmentobject.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/audience.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/audioobject.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/brand.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/breadcrumblist.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/categorycode.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/certification.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/claim.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/clip.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/comment.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/correctioncomment.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/country.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/creativework.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/creativeworkseason.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/definedterm.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/demand.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/distance.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/duration.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/energyconsumptiondetails.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/episode.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/event.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/grant.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/howtosection.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/howtostep.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/howtosupply.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/howtotool.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/imageobject.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/interactioncounter.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/iptcdigitalsourceenumeration.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/itemlist.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/language.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/listitem.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/mass.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/mediaobject.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/merchantreturnpolicy.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/monetaryamount.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/musicgroup.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/musicrecording.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/newsarticle.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/nutritioninformation.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/offer.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/offeritemcondition.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/organization.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/performinggroup.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/person.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/physicalactivitycategory.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/place.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/product.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/productgroup.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/productmodel.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/propertyvalue.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/publicationevent.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/quantitativevalue.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/rating.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/recipe.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/restricteddiet.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/review.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/service.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/sizespecification.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/socialmediaposting.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/speakablespecification.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/textobject.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/thing.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/videoobject.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/webcontent.rs | 2 +- crates/jacquard-api/src/social_flockfeeds/lexical/webpage.rs | 2 +- crates/jacquard-api/src/social_grain/actor/profile.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/social_grain/gallery/item.rs | 2 +- crates/jacquard-api/src/social_grain/photo/exif.rs | 2 +- crates/jacquard-api/src/social_psky/actor/profile.rs | 14 +++++++++----- crates/jacquard-api/src/social_psky/chat/message.rs | 14 +++++++++----- crates/jacquard-api/src/social_psky/chat/room.rs | 40 ++++++++++++++++++++++++++-------------- crates/jacquard-api/src/social_psky/richtext/facet.rs | 34 +++++++++++++++++++++------------- crates/jacquard-api/src/tools_ozone/hosting/get_account_history.rs | 12 ++++++------ crates/jacquard-api/src/tools_ozone/moderation/cancel_scheduled_actions.rs | 4 ++-- crates/jacquard-api/src/tools_ozone/moderation/get_account_timeline.rs | 4 ++-- crates/jacquard-api/src/tools_ozone/moderation/schedule_action.rs | 14 ++++++++------ crates/jacquard-api/src/tools_ozone/server/get_config.rs | 4 ++-- crates/jacquard-api/src/tools_ozone/signature/find_related_accounts.rs | 2 +- crates/jacquard-api/src/tools_ozone/verification/grant_verifications.rs | 4 ++-- crates/jacquard-api/src/tools_ozone/verification/revoke_verifications.rs | 2 +- crates/jacquard-api/src/us_polhem/blog/content.rs | 14 +++++++++----- crates/jacquard-api/src/us_polhem/blog/post.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/us_polhem/blog/tag.rs | 20 +++++++++++++------- crates/jacquard-api/src/win_tomo_x/pushat/allow.rs | 2 +- crates/jacquard-api/src/app_blebbit/authr/folder/record.rs | 2 +- crates/jacquard-api/src/app_blebbit/authr/group/record.rs | 2 +- crates/jacquard-api/src/app_blebbit/authr/page/record.rs | 2 +- crates/jacquard-api/src/blue__2048/key/player/stats.rs | 2 +- crates/jacquard-api/src/fm_teal/alpha/actor/profile.rs | 28 ++++++++++++++++++---------- crates/jacquard-api/src/fm_teal/alpha/actor/profile_status.rs | 2 +- crates/jacquard-api/src/fm_teal/alpha/actor/status.rs | 2 +- crates/jacquard-api/src/fm_teal/alpha/feed/play.rs | 68 +++++++++++++++++++++++++++++++++++++++++++++----------------------- crates/jacquard-api/src/net_anisota/beta/game/collection.rs | 48 +++++++++++++++++++++++++++++++----------------- crates/jacquard-api/src/net_anisota/beta/game/inventory.rs | 40 ++++++++++++++++++++++++++-------------- crates/jacquard-api/src/net_anisota/beta/game/log.rs | 106 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------------------------- crates/jacquard-api/src/net_anisota/beta/game/pack.rs | 30 +++++++++++++++++++----------- crates/jacquard-api/src/net_anisota/beta/game/progress.rs | 78 +++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------- crates/jacquard-api/src/net_anisota/beta/game/session.rs | 90 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------------------- crates/jacquard-api/src/sh_tangled/repo/issue/comment.rs | 2 +- crates/jacquard-api/src/sh_tangled/repo/issue/state.rs | 2 +- crates/jacquard-api/src/sh_tangled/repo/pull/comment.rs | 2 +- crates/jacquard-api/src/sh_tangled/repo/pull/status.rs | 2 +- crates/jacquard-api/src/tools_smokesignal/blahg/content/post.rs | 22 ++++++++++++++-------- crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/post.rs | 32 +++++++++++++++++++++----------- crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/reply.rs | 8 +++++--- crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/announcement.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/category.rs | 26 +++++++++++++++++--------- crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/group.rs | 20 +++++++++++++------- crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/identity.rs | 26 +++++++++++++++++--------- 439 file(s) changed, 3996 insertion(s)(+), 2718 deletion(s)(-) diff --git a/justfile b/justfile --- a/justfile +++ b/justfile @@ -21,7 +21,7 @@ cargo run -p jacquard-lexgen --bin lex-fetch -- -v generate-api: - cargo run -p jacquard-lexgen --bin jacquard-codegen -- -i crates/jacquard-api/lexicons -o crates/jacquard-api/src -r crate + cargo run -p jacquard-lexgen --bin jacquard-codegen -- -i crates/jacquard-api/lexicons -o crates/jacquard-api/src lex-gen *ARGS: cargo run -p jacquard-lexgen --bin lex-fetch -- {{ARGS}} @@ -30,7 +30,7 @@ cargo run -p jacquard-lexgen --bin lex-fetch -- --no-codegen {{ARGS}} codegen *ARGS: - cargo run -p jacquard-lexgen --bin jacquard-codegen -- -r crate {{ARGS}} + cargo run -p jacquard-lexgen --bin jacquard-codegen -- {{ARGS}} # Package binaries for distribution (creates tar.xz archives) package-binaries: diff --git a/crates/jacquard-api/src/blue__2048.rs b/crates/jacquard-api/src/blue__2048.rs --- a/crates/jacquard-api/src/blue__2048.rs +++ b/crates/jacquard-api/src/blue__2048.rs @@ -150,7 +150,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/buzz_bookhive.rs b/crates/jacquard-api/src/buzz_bookhive.rs --- a/crates/jacquard-api/src/buzz_bookhive.rs +++ b/crates/jacquard-api/src/buzz_bookhive.rs @@ -799,7 +799,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -849,13 +849,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.comment; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "comment", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "comment", + ), max: 100000usize, actual: ::len(value.as_ref()), }); @@ -870,8 +872,10 @@ ) .count(); if count > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "comment", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "comment", + ), max: 10000usize, actual: count, }); @@ -961,12 +965,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.books_read; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "books_read", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "books_read", + ), min: 0i64, actual: *value, }); @@ -975,8 +981,10 @@ { let value = &self.reviews; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "reviews", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "reviews", + ), min: 0i64, actual: *value, }); @@ -1049,7 +1057,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1133,13 +1141,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.authors; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2048usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "authors", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "authors", + ), max: 2048usize, actual: ::len(value.as_ref()), }); @@ -1149,8 +1159,10 @@ let value = &self.authors; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "authors", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "authors", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -1159,8 +1171,10 @@ if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 5000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 5000usize, actual: ::len(value.as_ref()), }); @@ -1168,8 +1182,10 @@ } if let Some(ref value) = self.rating { if *value > 1000i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "rating", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "rating", + ), max: 1000i64, actual: *value, }); @@ -1177,8 +1193,10 @@ } if let Some(ref value) = self.rating { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "rating", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "rating", + ), min: 0i64, actual: *value, }); @@ -1192,8 +1210,10 @@ ) .count(); if count > 15000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "review", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "review", + ), max: 15000usize, actual: count, }); @@ -1202,8 +1222,10 @@ } if let Some(ref value) = self.stars { if *value > 10i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "stars", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "stars", + ), max: 10i64, actual: *value, }); @@ -1211,8 +1233,10 @@ } if let Some(ref value) = self.stars { if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "stars", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "stars", + ), min: 1i64, actual: *value, }); @@ -1222,8 +1246,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 512usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 512usize, actual: ::len(value.as_ref()), }); @@ -1233,8 +1259,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), min: 1usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/my_skylights.rs b/crates/jacquard-api/src/my_skylights.rs --- a/crates/jacquard-api/src/my_skylights.rs +++ b/crates/jacquard-api/src/my_skylights.rs @@ -101,7 +101,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/place_stream.rs b/crates/jacquard-api/src/place_stream.rs --- a/crates/jacquard-api/src/place_stream.rs +++ b/crates/jacquard-api/src/place_stream.rs @@ -218,7 +218,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -252,7 +252,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -286,7 +286,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/social_grain.rs b/crates/jacquard-api/src/social_grain.rs --- a/crates/jacquard-api/src/social_grain.rs +++ b/crates/jacquard-api/src/social_grain.rs @@ -97,12 +97,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.height; if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "height", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "height", + ), min: 1i64, actual: *value, }); @@ -111,8 +113,10 @@ { let value = &self.width; if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "width", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "width", + ), min: 1i64, actual: *value, }); diff --git a/crates/jacquard-lexicon/src/codegen.rs b/crates/jacquard-lexicon/src/codegen.rs --- a/crates/jacquard-lexicon/src/codegen.rs +++ b/crates/jacquard-lexicon/src/codegen.rs @@ -4,6 +4,7 @@ use proc_macro2::TokenStream; use quote::quote; +pub mod builder_heuristics; pub mod lifetime; pub mod names; pub mod nsid_utils; @@ -11,6 +12,7 @@ pub mod schema_impl; pub mod structs; pub mod types; +pub mod union_codegen; pub mod utils; pub mod xrpc; @@ -100,7 +102,7 @@ #shared_fn_ident() } - fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { #validation_code } } diff --git a/crates/jacquard-lexicon/src/schema.rs b/crates/jacquard-lexicon/src/schema.rs --- a/crates/jacquard-lexicon/src/schema.rs +++ b/crates/jacquard-lexicon/src/schema.rs @@ -122,65 +122,10 @@ /// /// Checks runtime constraints like `max_length`, `max_graphemes`, `minimum`, etc. /// Returns `Ok(())` if valid, `Err` with details if invalid. - fn validate(&self) -> Result<(), ValidationError> { + fn validate(&self) -> Result<(), crate::validation::ConstraintError> { // Default impl: no constraints to check Ok(()) } -} - -/// Error type for validation failures -#[derive(Debug, Clone, thiserror::Error, miette::Diagnostic)] -pub enum ValidationError { - #[error("field `{field}` exceeds maximum length: {actual} > {max}")] - MaxLength { - field: &'static str, - max: usize, - actual: usize, - }, - - #[error("field `{field}` exceeds maximum grapheme count: {actual} > {max}")] - MaxGraphemes { - field: &'static str, - max: usize, - actual: usize, - }, - - #[error("field `{field}` below minimum length: {actual} < {min}")] - MinLength { - field: &'static str, - min: usize, - actual: usize, - }, - - #[error("field `{field}` below minimum grapheme count: {actual} < {min}")] - MinGraphemes { - field: &'static str, - min: usize, - actual: usize, - }, - - #[error("field `{field}` value {actual} exceeds maximum: {max}")] - Maximum { - field: &'static str, - max: i64, - actual: i64, - }, - - #[error("field `{field}` value {actual} below minimum: {min}")] - Minimum { - field: &'static str, - min: i64, - actual: i64, - }, - - #[error("field `{field}` has invalid value: {message}")] - InvalidValue { - field: &'static str, - message: String, - }, - - #[error("multiple validation errors: {0:?}")] - Multiple(Vec), } /// Registry entry for schema discovery via inventory @@ -284,25 +229,25 @@ #[cfg(test)] mod tests { - use super::*; + use crate::validation::{ConstraintError, ValidationPath}; #[test] fn test_validation_max_length() { - let err = ValidationError::MaxLength { - field: "text", + let err = ConstraintError::MaxLength { + path: ValidationPath::from_field("text"), max: 100, actual: 150, }; - assert!(err.to_string().contains("exceeds maximum length")); + assert!(err.to_string().contains("exceeds max length")); } #[test] fn test_validation_max_graphemes() { - let err = ValidationError::MaxGraphemes { - field: "text", + let err = ConstraintError::MaxGraphemes { + path: ValidationPath::from_field("text"), max: 50, actual: 75, }; - assert!(err.to_string().contains("exceeds maximum grapheme count")); + assert!(err.to_string().contains("exceeds max graphemes")); } } diff --git a/crates/jacquard-lexicon/src/validation.rs b/crates/jacquard-lexicon/src/validation.rs --- a/crates/jacquard-lexicon/src/validation.rs +++ b/crates/jacquard-lexicon/src/validation.rs @@ -47,6 +47,13 @@ } } + /// Create a path with a single field segment + pub fn from_field(name: &str) -> Self { + let mut path = Self::new(); + path.push_field(name); + path + } + /// Add a field segment to the path pub fn push_field(&mut self, name: &str) { self.segments.push(PathSegment::Field(name.into())); diff --git a/crates/jacquard-lexicon/tests/schema_tests.rs b/crates/jacquard-lexicon/tests/schema_tests.rs --- a/crates/jacquard-lexicon/tests/schema_tests.rs +++ b/crates/jacquard-lexicon/tests/schema_tests.rs @@ -4,7 +4,8 @@ LexObject, LexObjectProperty, LexRecord, LexRecordRecord, LexString, LexStringFormat, LexUserType, Lexicon, LexiconDoc, }; -use jacquard_lexicon::schema::{LexiconSchema, ValidationError}; +use jacquard_lexicon::schema::LexiconSchema; +use jacquard_lexicon::validation::{ConstraintError, ValidationPath}; use std::collections::BTreeMap; // Simple test type @@ -80,11 +81,11 @@ } } - fn validate(&self) -> Result<(), ValidationError> { + fn validate(&self) -> Result<(), ConstraintError> { // Check text length if self.text.len() > 1000 { - return Err(ValidationError::MaxLength { - field: "text", + return Err(ConstraintError::MaxLength { + path: ValidationPath::from_field("text"), max: 1000, actual: self.text.len(), }); @@ -122,7 +123,7 @@ assert!(result.is_err()); let err = result.unwrap_err(); - assert!(matches!(err, ValidationError::MaxLength { .. })); + assert!(matches!(err, ConstraintError::MaxLength { .. })); } #[test] diff --git a/crates/jacquard-api/src/app_bsky/actor.rs b/crates/jacquard-api/src/app_bsky/actor.rs --- a/crates/jacquard-api/src/app_bsky/actor.rs +++ b/crates/jacquard-api/src/app_bsky/actor.rs @@ -2397,7 +2397,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2432,13 +2432,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.guide; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "guide", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "guide", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -2489,12 +2491,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.nuxs { #[allow(unused_comparisons)] if value.len() > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "nuxs", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "nuxs", + ), max: 100usize, actual: value.len(), }); @@ -2503,8 +2507,10 @@ if let Some(ref value) = self.queued_nudges { #[allow(unused_comparisons)] if value.len() > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "queued_nudges", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "queued_nudges", + ), max: 1000usize, actual: value.len(), }); @@ -2549,7 +2555,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2599,7 +2605,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2634,7 +2640,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2669,13 +2675,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.tags; #[allow(unused_comparisons)] if value.len() > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "tags", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "tags", + ), max: 100usize, actual: value.len(), }); @@ -2716,13 +2724,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.followers; #[allow(unused_comparisons)] if value.len() > 5usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "followers", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "followers", + ), max: 5usize, actual: value.len(), }); @@ -2732,8 +2742,10 @@ let value = &self.followers; #[allow(unused_comparisons)] if value.len() < 0usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "followers", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "followers", + ), min: 0usize, actual: value.len(), }); @@ -2772,7 +2784,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2806,7 +2818,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2859,13 +2871,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.value; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "value", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "value", + ), max: 10000usize, actual: ::len(value.as_ref()), }); @@ -2880,8 +2894,10 @@ ) .count(); if count > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "value", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "value", + ), max: 1000usize, actual: count, }); @@ -2998,7 +3014,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -3044,12 +3060,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.data { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 3000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "data", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "data", + ), max: 3000usize, actual: ::len(value.as_ref()), }); @@ -3063,8 +3081,10 @@ ) .count(); if count > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "data", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "data", + ), max: 300usize, actual: count, }); @@ -3075,8 +3095,10 @@ let value = &self.id; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "id", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "id", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -3116,7 +3138,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -3184,12 +3206,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.postgate_embedding_rules { #[allow(unused_comparisons)] if value.len() > 5usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "postgate_embedding_rules", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "postgate_embedding_rules", + ), max: 5usize, actual: value.len(), }); @@ -3198,8 +3222,10 @@ if let Some(ref value) = self.threadgate_allow_rules { #[allow(unused_comparisons)] if value.len() > 5usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "threadgate_allow_rules", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "threadgate_allow_rules", + ), max: 5usize, actual: value.len(), }); @@ -3298,7 +3324,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -3333,7 +3359,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -3367,7 +3393,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -3445,12 +3471,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -3464,8 +3492,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 256usize, actual: count, }); @@ -3475,8 +3505,10 @@ if let Some(ref value) = self.display_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -3490,8 +3522,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 64usize, actual: count, }); @@ -3568,12 +3602,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.display_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -3587,8 +3623,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 64usize, actual: count, }); @@ -3699,12 +3737,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -3718,8 +3758,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 256usize, actual: count, }); @@ -3729,8 +3771,10 @@ if let Some(ref value) = self.display_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -3744,8 +3788,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 64usize, actual: count, }); @@ -3793,7 +3839,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -3832,7 +3878,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -3866,7 +3912,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -3917,7 +3963,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -3956,7 +4002,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -3992,7 +4038,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4036,7 +4082,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4079,7 +4125,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4141,7 +4187,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_bsky/bookmark.rs b/crates/jacquard-api/src/app_bsky/bookmark.rs --- a/crates/jacquard-api/src/app_bsky/bookmark.rs +++ b/crates/jacquard-api/src/app_bsky/bookmark.rs @@ -141,7 +141,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -202,7 +202,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_bsky/embed.rs b/crates/jacquard-api/src/app_bsky/embed.rs --- a/crates/jacquard-api/src/app_bsky/embed.rs +++ b/crates/jacquard-api/src/app_bsky/embed.rs @@ -100,12 +100,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.height; if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "height", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "height", + ), min: 1i64, actual: *value, }); @@ -114,8 +116,10 @@ { let value = &self.width; if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "width", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "width", + ), min: 1i64, actual: *value, }); diff --git a/crates/jacquard-api/src/app_bsky/feed.rs b/crates/jacquard-api/src/app_bsky/feed.rs --- a/crates/jacquard-api/src/app_bsky/feed.rs +++ b/crates/jacquard-api/src/app_bsky/feed.rs @@ -1444,7 +1444,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1481,7 +1481,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1660,12 +1660,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.feed_context { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "feed_context", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "feed_context", + ), max: 2000usize, actual: ::len(value.as_ref()), }); @@ -1674,8 +1676,10 @@ if let Some(ref value) = self.req_id { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "req_id", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "req_id", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -1754,12 +1758,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 3000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 3000usize, actual: ::len(value.as_ref()), }); @@ -1773,8 +1779,10 @@ ) .count(); if count > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 300usize, actual: count, }); @@ -1783,8 +1791,10 @@ } if let Some(ref value) = self.like_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "like_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "like_count", + ), min: 0i64, actual: *value, }); @@ -1824,7 +1834,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1870,12 +1880,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.feed_context { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "feed_context", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "feed_context", + ), max: 2000usize, actual: ::len(value.as_ref()), }); @@ -1884,8 +1896,10 @@ if let Some(ref value) = self.req_id { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "req_id", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "req_id", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -2033,7 +2047,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2130,7 +2144,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2160,7 +2174,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2203,7 +2217,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2286,7 +2300,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2384,12 +2398,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.feed_context { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "feed_context", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "feed_context", + ), max: 2000usize, actual: ::len(value.as_ref()), }); @@ -2424,7 +2440,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2458,7 +2474,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2494,7 +2510,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2582,7 +2598,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2626,7 +2642,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2675,7 +2691,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_bsky/graph.rs b/crates/jacquard-api/src/app_bsky/graph.rs --- a/crates/jacquard-api/src/app_bsky/graph.rs +++ b/crates/jacquard-api/src/app_bsky/graph.rs @@ -994,7 +994,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1146,12 +1146,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 3000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 3000usize, actual: ::len(value.as_ref()), }); @@ -1165,8 +1167,10 @@ ) .count(); if count > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 300usize, actual: count, }); @@ -1175,8 +1179,10 @@ } if let Some(ref value) = self.list_item_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "list_item_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "list_item_count", + ), min: 0i64, actual: *value, }); @@ -1186,8 +1192,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 64usize, actual: ::len(value.as_ref()), }); @@ -1197,8 +1205,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -1262,11 +1272,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.list_item_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "list_item_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "list_item_count", + ), min: 0i64, actual: *value, }); @@ -1276,8 +1288,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 64usize, actual: ::len(value.as_ref()), }); @@ -1287,8 +1301,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -1330,7 +1346,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1384,7 +1400,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1447,7 +1463,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1510,12 +1526,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.feeds { #[allow(unused_comparisons)] if value.len() > 3usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "feeds", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "feeds", + ), max: 3usize, actual: value.len(), }); @@ -1523,8 +1541,10 @@ } if let Some(ref value) = self.joined_all_time_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "joined_all_time_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "joined_all_time_count", + ), min: 0i64, actual: *value, }); @@ -1532,8 +1552,10 @@ } if let Some(ref value) = self.joined_week_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "joined_week_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "joined_week_count", + ), min: 0i64, actual: *value, }); @@ -1542,8 +1564,10 @@ if let Some(ref value) = self.list_items_sample { #[allow(unused_comparisons)] if value.len() > 12usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "list_items_sample", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "list_items_sample", + ), max: 12usize, actual: value.len(), }); @@ -1602,11 +1626,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.joined_all_time_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "joined_all_time_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "joined_all_time_count", + ), min: 0i64, actual: *value, }); @@ -1614,8 +1640,10 @@ } if let Some(ref value) = self.joined_week_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "joined_week_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "joined_week_count", + ), min: 0i64, actual: *value, }); @@ -1623,8 +1651,10 @@ } if let Some(ref value) = self.list_item_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "list_item_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "list_item_count", + ), min: 0i64, actual: *value, }); diff --git a/crates/jacquard-api/src/app_bsky/labeler.rs b/crates/jacquard-api/src/app_bsky/labeler.rs --- a/crates/jacquard-api/src/app_bsky/labeler.rs +++ b/crates/jacquard-api/src/app_bsky/labeler.rs @@ -461,7 +461,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -511,11 +511,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.like_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "like_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "like_count", + ), min: 0i64, actual: *value, }); @@ -587,11 +589,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.like_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "like_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "like_count", + ), min: 0i64, actual: *value, }); @@ -631,7 +635,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_bsky/notification.rs b/crates/jacquard-api/src/app_bsky/notification.rs --- a/crates/jacquard-api/src/app_bsky/notification.rs +++ b/crates/jacquard-api/src/app_bsky/notification.rs @@ -433,7 +433,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -469,7 +469,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -506,7 +506,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -540,7 +540,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -598,7 +598,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -628,7 +628,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -665,7 +665,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_bsky/unspecced.rs b/crates/jacquard-api/src/app_bsky/unspecced.rs --- a/crates/jacquard-api/src/app_bsky/unspecced.rs +++ b/crates/jacquard-api/src/app_bsky/unspecced.rs @@ -964,7 +964,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1003,7 +1003,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1037,7 +1037,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1071,7 +1071,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1105,7 +1105,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1158,7 +1158,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1192,7 +1192,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1222,7 +1222,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1252,7 +1252,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1296,7 +1296,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1349,7 +1349,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1391,7 +1391,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_bsky/video.rs b/crates/jacquard-api/src/app_bsky/video.rs --- a/crates/jacquard-api/src/app_bsky/video.rs +++ b/crates/jacquard-api/src/app_bsky/video.rs @@ -195,11 +195,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.progress { if *value > 100i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "progress", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "progress", + ), max: 100i64, actual: *value, }); @@ -207,8 +209,10 @@ } if let Some(ref value) = self.progress { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "progress", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "progress", + ), min: 0i64, actual: *value, }); diff --git a/crates/jacquard-api/src/app_ocho/auth.rs b/crates/jacquard-api/src/app_ocho/auth.rs --- a/crates/jacquard-api/src/app_ocho/auth.rs +++ b/crates/jacquard-api/src/app_ocho/auth.rs @@ -151,7 +151,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_ocho/plugin.rs b/crates/jacquard-api/src/app_ocho/plugin.rs --- a/crates/jacquard-api/src/app_ocho/plugin.rs +++ b/crates/jacquard-api/src/app_ocho/plugin.rs @@ -1023,7 +1023,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1062,7 +1062,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1099,7 +1099,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1146,7 +1146,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1181,7 +1181,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1216,7 +1216,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1319,7 +1319,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1354,7 +1354,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1389,7 +1389,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1432,7 +1432,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1482,7 +1482,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1518,7 +1518,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1588,7 +1588,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_rocksky/actor.rs b/crates/jacquard-api/src/app_rocksky/actor.rs --- a/crates/jacquard-api/src/app_rocksky/actor.rs +++ b/crates/jacquard-api/src/app_rocksky/actor.rs @@ -397,7 +397,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -455,7 +455,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_rocksky/album.rs b/crates/jacquard-api/src/app_rocksky/album.rs --- a/crates/jacquard-api/src/app_rocksky/album.rs +++ b/crates/jacquard-api/src/app_rocksky/album.rs @@ -155,13 +155,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.artist; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "artist", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "artist", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -171,8 +173,10 @@ let value = &self.artist; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "artist", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "artist", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -181,8 +185,10 @@ if let Some(ref value) = self.genre { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "genre", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "genre", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -192,8 +198,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 512usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 512usize, actual: ::len(value.as_ref()), }); @@ -203,8 +211,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -1028,11 +1038,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.play_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "play_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "play_count", + ), min: 0i64, actual: *value, }); @@ -1040,8 +1052,10 @@ } if let Some(ref value) = self.unique_listeners { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "unique_listeners", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "unique_listeners", + ), min: 0i64, actual: *value, }); @@ -1122,11 +1136,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.play_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "play_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "play_count", + ), min: 0i64, actual: *value, }); @@ -1134,8 +1150,10 @@ } if let Some(ref value) = self.unique_listeners { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "unique_listeners", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "unique_listeners", + ), min: 0i64, actual: *value, }); diff --git a/crates/jacquard-api/src/app_rocksky/apikey.rs b/crates/jacquard-api/src/app_rocksky/apikey.rs --- a/crates/jacquard-api/src/app_rocksky/apikey.rs +++ b/crates/jacquard-api/src/app_rocksky/apikey.rs @@ -162,7 +162,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_rocksky/artist.rs b/crates/jacquard-api/src/app_rocksky/artist.rs --- a/crates/jacquard-api/src/app_rocksky/artist.rs +++ b/crates/jacquard-api/src/app_rocksky/artist.rs @@ -133,12 +133,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.bio { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "bio", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "bio", + ), max: 1000usize, actual: ::len(value.as_ref()), }); @@ -147,8 +149,10 @@ if let Some(ref value) = self.born_in { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "born_in", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "born_in", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -158,8 +162,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 512usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 512usize, actual: ::len(value.as_ref()), }); @@ -169,8 +175,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -713,11 +721,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.play_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "play_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "play_count", + ), min: 0i64, actual: *value, }); @@ -725,8 +735,10 @@ } if let Some(ref value) = self.unique_listeners { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "unique_listeners", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "unique_listeners", + ), min: 0i64, actual: *value, }); @@ -789,11 +801,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.play_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "play_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "play_count", + ), min: 0i64, actual: *value, }); @@ -801,8 +815,10 @@ } if let Some(ref value) = self.unique_listeners { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "unique_listeners", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "unique_listeners", + ), min: 0i64, actual: *value, }); diff --git a/crates/jacquard-api/src/app_rocksky/charts.rs b/crates/jacquard-api/src/app_rocksky/charts.rs --- a/crates/jacquard-api/src/app_rocksky/charts.rs +++ b/crates/jacquard-api/src/app_rocksky/charts.rs @@ -128,7 +128,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -166,7 +166,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_rocksky/dropbox.rs b/crates/jacquard-api/src/app_rocksky/dropbox.rs --- a/crates/jacquard-api/src/app_rocksky/dropbox.rs +++ b/crates/jacquard-api/src/app_rocksky/dropbox.rs @@ -260,7 +260,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -314,7 +314,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -350,7 +350,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_rocksky/feed.rs b/crates/jacquard-api/src/app_rocksky/feed.rs --- a/crates/jacquard-api/src/app_rocksky/feed.rs +++ b/crates/jacquard-api/src/app_rocksky/feed.rs @@ -462,7 +462,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -499,7 +499,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -567,7 +567,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_rocksky/googledrive.rs b/crates/jacquard-api/src/app_rocksky/googledrive.rs --- a/crates/jacquard-api/src/app_rocksky/googledrive.rs +++ b/crates/jacquard-api/src/app_rocksky/googledrive.rs @@ -113,7 +113,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -149,7 +149,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_rocksky/like.rs b/crates/jacquard-api/src/app_rocksky/like.rs --- a/crates/jacquard-api/src/app_rocksky/like.rs +++ b/crates/jacquard-api/src/app_rocksky/like.rs @@ -103,7 +103,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_rocksky/player.rs b/crates/jacquard-api/src/app_rocksky/player.rs --- a/crates/jacquard-api/src/app_rocksky/player.rs +++ b/crates/jacquard-api/src/app_rocksky/player.rs @@ -92,7 +92,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_rocksky/playlist.rs b/crates/jacquard-api/src/app_rocksky/playlist.rs --- a/crates/jacquard-api/src/app_rocksky/playlist.rs +++ b/crates/jacquard-api/src/app_rocksky/playlist.rs @@ -138,12 +138,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -152,8 +154,10 @@ if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -163,8 +167,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 512usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 512usize, actual: ::len(value.as_ref()), }); @@ -174,8 +180,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -985,11 +993,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.track_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "track_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "track_count", + ), min: 0i64, actual: *value, }); @@ -1074,7 +1084,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_rocksky/radio.rs b/crates/jacquard-api/src/app_rocksky/radio.rs --- a/crates/jacquard-api/src/app_rocksky/radio.rs +++ b/crates/jacquard-api/src/app_rocksky/radio.rs @@ -123,12 +123,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 1000usize, actual: ::len(value.as_ref()), }); @@ -137,8 +139,10 @@ if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -147,8 +151,10 @@ if let Some(ref value) = self.genre { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "genre", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "genre", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -157,8 +163,10 @@ if let Some(ref value) = self.genre { #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "genre", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "genre", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -168,8 +176,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 512usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 512usize, actual: ::len(value.as_ref()), }); @@ -179,8 +189,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -689,7 +701,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -752,7 +764,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_rocksky/scrobble.rs b/crates/jacquard-api/src/app_rocksky/scrobble.rs --- a/crates/jacquard-api/src/app_rocksky/scrobble.rs +++ b/crates/jacquard-api/src/app_rocksky/scrobble.rs @@ -199,13 +199,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.album; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "album", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "album", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -215,8 +217,10 @@ let value = &self.album; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "album", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "album", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -226,8 +230,10 @@ let value = &self.album_artist; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "album_artist", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "album_artist", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -237,8 +243,10 @@ let value = &self.album_artist; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "album_artist", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "album_artist", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -248,8 +256,10 @@ let value = &self.artist; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "artist", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "artist", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -259,8 +269,10 @@ let value = &self.artist; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "artist", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "artist", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -269,8 +281,10 @@ if let Some(ref value) = self.composer { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "composer", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "composer", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -279,8 +293,10 @@ if let Some(ref value) = self.copyright_message { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "copyright_message", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "copyright_message", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -288,8 +304,10 @@ } if let Some(ref value) = self.disc_number { if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "disc_number", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "disc_number", + ), min: 1i64, actual: *value, }); @@ -298,8 +316,10 @@ { let value = &self.duration; if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "duration", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "duration", + ), min: 1i64, actual: *value, }); @@ -308,8 +328,10 @@ if let Some(ref value) = self.genre { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "genre", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "genre", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -318,8 +340,10 @@ if let Some(ref value) = self.label { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "label", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "label", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -328,8 +352,10 @@ if let Some(ref value) = self.lyrics { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "lyrics", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "lyrics", + ), max: 10000usize, actual: ::len(value.as_ref()), }); @@ -339,8 +365,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 512usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 512usize, actual: ::len(value.as_ref()), }); @@ -350,8 +378,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -359,8 +389,10 @@ } if let Some(ref value) = self.track_number { if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "track_number", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "track_number", + ), min: 1i64, actual: *value, }); @@ -369,8 +401,10 @@ if let Some(ref value) = self.wiki { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "wiki", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "wiki", + ), max: 10000usize, actual: ::len(value.as_ref()), }); @@ -1441,7 +1475,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1522,7 +1556,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_rocksky/shout.rs b/crates/jacquard-api/src/app_rocksky/shout.rs --- a/crates/jacquard-api/src/app_rocksky/shout.rs +++ b/crates/jacquard-api/src/app_rocksky/shout.rs @@ -116,13 +116,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.message; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "message", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "message", + ), max: 1000usize, actual: ::len(value.as_ref()), }); @@ -132,8 +134,10 @@ let value = &self.message; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "message", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "message", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -523,7 +527,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -574,7 +578,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_rocksky/song.rs b/crates/jacquard-api/src/app_rocksky/song.rs --- a/crates/jacquard-api/src/app_rocksky/song.rs +++ b/crates/jacquard-api/src/app_rocksky/song.rs @@ -199,13 +199,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.album; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "album", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "album", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -215,8 +217,10 @@ let value = &self.album; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "album", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "album", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -226,8 +230,10 @@ let value = &self.album_artist; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "album_artist", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "album_artist", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -237,8 +243,10 @@ let value = &self.album_artist; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "album_artist", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "album_artist", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -248,8 +256,10 @@ let value = &self.artist; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "artist", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "artist", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -259,8 +269,10 @@ let value = &self.artist; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "artist", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "artist", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -269,8 +281,10 @@ if let Some(ref value) = self.composer { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "composer", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "composer", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -279,8 +293,10 @@ if let Some(ref value) = self.copyright_message { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "copyright_message", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "copyright_message", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -288,8 +304,10 @@ } if let Some(ref value) = self.disc_number { if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "disc_number", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "disc_number", + ), min: 1i64, actual: *value, }); @@ -298,8 +316,10 @@ { let value = &self.duration; if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "duration", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "duration", + ), min: 1i64, actual: *value, }); @@ -308,8 +328,10 @@ if let Some(ref value) = self.genre { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "genre", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "genre", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -318,8 +340,10 @@ if let Some(ref value) = self.genre { #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "genre", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "genre", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -328,8 +352,10 @@ if let Some(ref value) = self.label { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "label", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "label", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -338,8 +364,10 @@ if let Some(ref value) = self.lyrics { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "lyrics", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "lyrics", + ), max: 10000usize, actual: ::len(value.as_ref()), }); @@ -349,8 +377,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 512usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 512usize, actual: ::len(value.as_ref()), }); @@ -360,8 +390,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -369,8 +401,10 @@ } if let Some(ref value) = self.track_number { if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "track_number", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "track_number", + ), min: 1i64, actual: *value, }); @@ -379,8 +413,10 @@ if let Some(ref value) = self.wiki { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "wiki", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "wiki", + ), max: 10000usize, actual: ::len(value.as_ref()), }); @@ -1570,11 +1606,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.play_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "play_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "play_count", + ), min: 0i64, actual: *value, }); @@ -1582,8 +1620,10 @@ } if let Some(ref value) = self.unique_listeners { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "unique_listeners", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "unique_listeners", + ), min: 0i64, actual: *value, }); @@ -1678,11 +1718,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.play_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "play_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "play_count", + ), min: 0i64, actual: *value, }); @@ -1690,8 +1732,10 @@ } if let Some(ref value) = self.unique_listeners { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "unique_listeners", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "unique_listeners", + ), min: 0i64, actual: *value, }); diff --git a/crates/jacquard-api/src/app_rocksky/spotify.rs b/crates/jacquard-api/src/app_rocksky/spotify.rs --- a/crates/jacquard-api/src/app_rocksky/spotify.rs +++ b/crates/jacquard-api/src/app_rocksky/spotify.rs @@ -198,7 +198,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_rocksky/stats.rs b/crates/jacquard-api/src/app_rocksky/stats.rs --- a/crates/jacquard-api/src/app_rocksky/stats.rs +++ b/crates/jacquard-api/src/app_rocksky/stats.rs @@ -136,7 +136,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/blog_pckt/blog.rs b/crates/jacquard-api/src/blog_pckt/blog.rs --- a/crates/jacquard-api/src/blog_pckt/blog.rs +++ b/crates/jacquard-api/src/blog_pckt/blog.rs @@ -119,7 +119,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -434,7 +434,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -475,7 +475,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/blog_pckt/post.rs b/crates/jacquard-api/src/blog_pckt/post.rs --- a/crates/jacquard-api/src/blog_pckt/post.rs +++ b/crates/jacquard-api/src/blog_pckt/post.rs @@ -124,7 +124,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/blog_pckt/publication.rs b/crates/jacquard-api/src/blog_pckt/publication.rs --- a/crates/jacquard-api/src/blog_pckt/publication.rs +++ b/crates/jacquard-api/src/blog_pckt/publication.rs @@ -129,12 +129,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 2000usize, actual: ::len(value.as_ref()), }); @@ -143,8 +145,10 @@ if let Some(ref value) = self.extensions { #[allow(unused_comparisons)] if value.len() > 10usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "extensions", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "extensions", + ), max: 10usize, actual: value.len(), }); @@ -154,8 +158,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 200usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 200usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/blog_pckt/theme.rs b/crates/jacquard-api/src/blog_pckt/theme.rs --- a/crates/jacquard-api/src/blog_pckt/theme.rs +++ b/crates/jacquard-api/src/blog_pckt/theme.rs @@ -105,12 +105,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.font { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "font", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "font", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -359,13 +361,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.accent; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 7usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "accent", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "accent", + ), max: 7usize, actual: ::len(value.as_ref()), }); @@ -375,8 +379,10 @@ let value = &self.background; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 7usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "background", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "background", + ), max: 7usize, actual: ::len(value.as_ref()), }); @@ -386,8 +392,10 @@ let value = &self.link; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 7usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "link", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "link", + ), max: 7usize, actual: ::len(value.as_ref()), }); @@ -397,8 +405,10 @@ let value = &self.surface_hover; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 7usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "surface_hover", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "surface_hover", + ), max: 7usize, actual: ::len(value.as_ref()), }); @@ -408,8 +418,10 @@ let value = &self.text; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 7usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 7usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/blue__2048/game.rs b/crates/jacquard-api/src/blue__2048/game.rs --- a/crates/jacquard-api/src/blue__2048/game.rs +++ b/crates/jacquard-api/src/blue__2048/game.rs @@ -108,7 +108,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/blue__2048/key.rs b/crates/jacquard-api/src/blue__2048/key.rs --- a/crates/jacquard-api/src/blue__2048/key.rs +++ b/crates/jacquard-api/src/blue__2048/key.rs @@ -196,7 +196,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -238,7 +238,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/blue__2048/verification.rs b/crates/jacquard-api/src/blue__2048/verification.rs --- a/crates/jacquard-api/src/blue__2048/verification.rs +++ b/crates/jacquard-api/src/blue__2048/verification.rs @@ -195,7 +195,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/blue_atplane/fav_client.rs b/crates/jacquard-api/src/blue_atplane/fav_client.rs --- a/crates/jacquard-api/src/blue_atplane/fav_client.rs +++ b/crates/jacquard-api/src/blue_atplane/fav_client.rs @@ -98,13 +98,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.fav_client; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 32usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "fav_client", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "fav_client", + ), max: 32usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/blue_linkat/board.rs b/crates/jacquard-api/src/blue_linkat/board.rs --- a/crates/jacquard-api/src/blue_linkat/board.rs +++ b/crates/jacquard-api/src/blue_linkat/board.rs @@ -162,7 +162,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -259,7 +259,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/buzz_bookhive/book.rs b/crates/jacquard-api/src/buzz_bookhive/book.rs --- a/crates/jacquard-api/src/buzz_bookhive/book.rs +++ b/crates/jacquard-api/src/buzz_bookhive/book.rs @@ -133,13 +133,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.authors; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2048usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "authors", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "authors", + ), max: 2048usize, actual: ::len(value.as_ref()), }); @@ -149,8 +151,10 @@ let value = &self.authors; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "authors", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "authors", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -164,8 +168,10 @@ ) .count(); if count > 15000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "review", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "review", + ), max: 15000usize, actual: count, }); @@ -174,8 +180,10 @@ } if let Some(ref value) = self.stars { if *value > 10i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "stars", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "stars", + ), max: 10i64, actual: *value, }); @@ -183,8 +191,10 @@ } if let Some(ref value) = self.stars { if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "stars", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "stars", + ), min: 1i64, actual: *value, }); @@ -194,8 +204,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 512usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 512usize, actual: ::len(value.as_ref()), }); @@ -205,8 +217,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), min: 1usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/buzz_bookhive/buzz.rs b/crates/jacquard-api/src/buzz_bookhive/buzz.rs --- a/crates/jacquard-api/src/buzz_bookhive/buzz.rs +++ b/crates/jacquard-api/src/buzz_bookhive/buzz.rs @@ -104,13 +104,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.comment; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "comment", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "comment", + ), max: 100000usize, actual: ::len(value.as_ref()), }); @@ -125,8 +127,10 @@ ) .count(); if count > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "comment", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "comment", + ), max: 10000usize, actual: count, }); diff --git a/crates/jacquard-api/src/buzz_bookhive/hive_book.rs b/crates/jacquard-api/src/buzz_bookhive/hive_book.rs --- a/crates/jacquard-api/src/buzz_bookhive/hive_book.rs +++ b/crates/jacquard-api/src/buzz_bookhive/hive_book.rs @@ -145,13 +145,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.authors; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 512usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "authors", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "authors", + ), max: 512usize, actual: ::len(value.as_ref()), }); @@ -161,8 +163,10 @@ let value = &self.authors; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "authors", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "authors", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -171,8 +175,10 @@ if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 5000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 5000usize, actual: ::len(value.as_ref()), }); @@ -180,8 +186,10 @@ } if let Some(ref value) = self.rating { if *value > 1000i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "rating", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "rating", + ), max: 1000i64, actual: *value, }); @@ -189,8 +197,10 @@ } if let Some(ref value) = self.rating { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "rating", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "rating", + ), min: 0i64, actual: *value, }); @@ -200,8 +210,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 512usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 512usize, actual: ::len(value.as_ref()), }); @@ -211,8 +223,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), min: 1usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/chat_bsky/actor.rs b/crates/jacquard-api/src/chat_bsky/actor.rs --- a/crates/jacquard-api/src/chat_bsky/actor.rs +++ b/crates/jacquard-api/src/chat_bsky/actor.rs @@ -224,12 +224,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.display_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -243,8 +245,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 64usize, actual: count, }); diff --git a/crates/jacquard-api/src/chat_bsky/convo.rs b/crates/jacquard-api/src/chat_bsky/convo.rs --- a/crates/jacquard-api/src/chat_bsky/convo.rs +++ b/crates/jacquard-api/src/chat_bsky/convo.rs @@ -1296,7 +1296,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1337,7 +1337,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1373,7 +1373,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1434,7 +1434,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1470,7 +1470,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1529,7 +1529,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1588,7 +1588,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1624,7 +1624,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1660,7 +1660,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1719,7 +1719,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1780,7 +1780,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1816,7 +1816,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1852,7 +1852,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1893,13 +1893,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.text; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 10000usize, actual: ::len(value.as_ref()), }); @@ -1914,8 +1916,10 @@ ) .count(); if count > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 1000usize, actual: count, }); @@ -1961,7 +1965,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2019,13 +2023,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.text; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 10000usize, actual: ::len(value.as_ref()), }); @@ -2040,8 +2046,10 @@ ) .count(); if count > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 1000usize, actual: count, }); @@ -2081,7 +2089,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2119,7 +2127,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -2153,7 +2161,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/com_atproto/admin.rs b/crates/jacquard-api/src/com_atproto/admin.rs --- a/crates/jacquard-api/src/com_atproto/admin.rs +++ b/crates/jacquard-api/src/com_atproto/admin.rs @@ -496,7 +496,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -536,7 +536,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -570,7 +570,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -607,7 +607,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -643,7 +643,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/com_atproto/identity.rs b/crates/jacquard-api/src/com_atproto/identity.rs --- a/crates/jacquard-api/src/com_atproto/identity.rs +++ b/crates/jacquard-api/src/com_atproto/identity.rs @@ -128,7 +128,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/com_atproto/label.rs b/crates/jacquard-api/src/com_atproto/label.rs --- a/crates/jacquard-api/src/com_atproto/label.rs +++ b/crates/jacquard-api/src/com_atproto/label.rs @@ -559,13 +559,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.val; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 128usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "val", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "val", + ), max: 128usize, actual: ::len(value.as_ref()), }); @@ -747,13 +749,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.identifier; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "identifier", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "identifier", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -768,8 +772,10 @@ ) .count(); if count > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "identifier", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "identifier", + ), max: 100usize, actual: count, }); @@ -818,13 +824,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.description; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 100000usize, actual: ::len(value.as_ref()), }); @@ -839,8 +847,10 @@ ) .count(); if count > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 10000usize, actual: count, }); @@ -851,8 +861,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -867,8 +879,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 64usize, actual: count, }); @@ -910,13 +924,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.val; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 128usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "val", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "val", + ), max: 128usize, actual: ::len(value.as_ref()), }); @@ -956,13 +972,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.values; #[allow(unused_comparisons)] if value.len() > 10usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "values", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "values", + ), max: 10usize, actual: value.len(), }); diff --git a/crates/jacquard-api/src/com_atproto/repo.rs b/crates/jacquard-api/src/com_atproto/repo.rs --- a/crates/jacquard-api/src/com_atproto/repo.rs +++ b/crates/jacquard-api/src/com_atproto/repo.rs @@ -114,7 +114,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/com_atproto/server.rs b/crates/jacquard-api/src/com_atproto/server.rs --- a/crates/jacquard-api/src/com_atproto/server.rs +++ b/crates/jacquard-api/src/com_atproto/server.rs @@ -265,7 +265,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -300,7 +300,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/com_whtwnd/blog.rs b/crates/jacquard-api/src/com_whtwnd/blog.rs --- a/crates/jacquard-api/src/com_whtwnd/blog.rs +++ b/crates/jacquard-api/src/com_whtwnd/blog.rs @@ -250,7 +250,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -286,13 +286,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.content; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "content", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "content", + ), max: 100000usize, actual: ::len(value.as_ref()), }); @@ -334,13 +336,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.content; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "content", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "content", + ), max: 1000usize, actual: ::len(value.as_ref()), }); @@ -385,7 +389,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/my_skylights/list.rs b/crates/jacquard-api/src/my_skylights/list.rs --- a/crates/jacquard-api/src/my_skylights/list.rs +++ b/crates/jacquard-api/src/my_skylights/list.rs @@ -136,7 +136,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/my_skylights/list_item.rs b/crates/jacquard-api/src/my_skylights/list_item.rs --- a/crates/jacquard-api/src/my_skylights/list_item.rs +++ b/crates/jacquard-api/src/my_skylights/list_item.rs @@ -236,7 +236,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -319,7 +319,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/my_skylights/rel.rs b/crates/jacquard-api/src/my_skylights/rel.rs --- a/crates/jacquard-api/src/my_skylights/rel.rs +++ b/crates/jacquard-api/src/my_skylights/rel.rs @@ -106,7 +106,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -344,7 +344,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -378,12 +378,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.value; if *value > 10i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "value", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "value", + ), max: 10i64, actual: *value, }); @@ -392,8 +394,10 @@ { let value = &self.value; if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "value", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "value", + ), min: 1i64, actual: *value, }); diff --git a/crates/jacquard-api/src/net_aftertheinter/coolthingtwo.rs b/crates/jacquard-api/src/net_aftertheinter/coolthingtwo.rs --- a/crates/jacquard-api/src/net_aftertheinter/coolthingtwo.rs +++ b/crates/jacquard-api/src/net_aftertheinter/coolthingtwo.rs @@ -97,13 +97,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.status; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 32usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "status", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "status", + ), max: 32usize, actual: ::len(value.as_ref()), }); @@ -113,8 +115,10 @@ let value = &self.status; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "status", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "status", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -129,8 +133,10 @@ ) .count(); if count > 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "status", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "status", + ), max: 1usize, actual: count, }); diff --git a/crates/jacquard-api/src/net_altq/aqfile.rs b/crates/jacquard-api/src/net_altq/aqfile.rs --- a/crates/jacquard-api/src/net_altq/aqfile.rs +++ b/crates/jacquard-api/src/net_altq/aqfile.rs @@ -303,13 +303,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.algo; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 32usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "algo", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "algo", + ), max: 32usize, actual: ::len(value.as_ref()), }); @@ -319,8 +321,10 @@ let value = &self.hash; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 128usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "hash", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "hash", + ), max: 128usize, actual: ::len(value.as_ref()), }); @@ -373,12 +377,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.mime_type { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 255usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "mime_type", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "mime_type", + ), max: 255usize, actual: ::len(value.as_ref()), }); @@ -388,8 +394,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 512usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 512usize, actual: ::len(value.as_ref()), }); @@ -398,8 +406,10 @@ { let value = &self.size; if *value > 1000000000i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "size", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "size", + ), max: 1000000000i64, actual: *value, }); @@ -408,8 +418,10 @@ { let value = &self.size; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "size", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "size", + ), min: 0i64, actual: *value, }); @@ -526,7 +538,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/net_bnewbold/m.rs b/crates/jacquard-api/src/net_bnewbold/m.rs --- a/crates/jacquard-api/src/net_bnewbold/m.rs +++ b/crates/jacquard-api/src/net_bnewbold/m.rs @@ -104,13 +104,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.common_name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "common_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "common_name", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -125,8 +127,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "common_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "common_name", + ), max: 256usize, actual: count, }); @@ -136,8 +140,10 @@ if let Some(ref value) = self.species { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "species", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "species", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -151,8 +157,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "species", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "species", + ), max: 256usize, actual: count, }); diff --git a/crates/jacquard-api/src/network_slices/actor.rs b/crates/jacquard-api/src/network_slices/actor.rs --- a/crates/jacquard-api/src/network_slices/actor.rs +++ b/crates/jacquard-api/src/network_slices/actor.rs @@ -171,12 +171,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -190,8 +192,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 256usize, actual: count, }); @@ -201,8 +205,10 @@ if let Some(ref value) = self.display_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -216,8 +222,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 64usize, actual: count, }); diff --git a/crates/jacquard-api/src/network_slices/lexicon.rs b/crates/jacquard-api/src/network_slices/lexicon.rs --- a/crates/jacquard-api/src/network_slices/lexicon.rs +++ b/crates/jacquard-api/src/network_slices/lexicon.rs @@ -119,12 +119,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 500usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 500usize, actual: ::len(value.as_ref()), }); @@ -134,8 +136,10 @@ let value = &self.nsid; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "nsid", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "nsid", + ), max: 256usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/network_slices/slice.rs b/crates/jacquard-api/src/network_slices/slice.rs --- a/crates/jacquard-api/src/network_slices/slice.rs +++ b/crates/jacquard-api/src/network_slices/slice.rs @@ -120,13 +120,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.domain; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "domain", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "domain", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -136,8 +138,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -582,7 +586,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -616,12 +620,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.count; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "count", + ), min: 0i64, actual: *value, }); diff --git a/crates/jacquard-api/src/network_slices/waitlist.rs b/crates/jacquard-api/src/network_slices/waitlist.rs --- a/crates/jacquard-api/src/network_slices/waitlist.rs +++ b/crates/jacquard-api/src/network_slices/waitlist.rs @@ -289,7 +289,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -332,7 +332,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/place_atwork/endorsement.rs b/crates/jacquard-api/src/place_atwork/endorsement.rs --- a/crates/jacquard-api/src/place_atwork/endorsement.rs +++ b/crates/jacquard-api/src/place_atwork/endorsement.rs @@ -111,13 +111,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.text; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 1000usize, actual: ::len(value.as_ref()), }); @@ -132,8 +134,10 @@ ) .count(); if count > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 1000usize, actual: count, }); diff --git a/crates/jacquard-api/src/place_atwork/endorsement_proof.rs b/crates/jacquard-api/src/place_atwork/endorsement_proof.rs --- a/crates/jacquard-api/src/place_atwork/endorsement_proof.rs +++ b/crates/jacquard-api/src/place_atwork/endorsement_proof.rs @@ -97,7 +97,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/place_atwork/get_listings.rs b/crates/jacquard-api/src/place_atwork/get_listings.rs --- a/crates/jacquard-api/src/place_atwork/get_listings.rs +++ b/crates/jacquard-api/src/place_atwork/get_listings.rs @@ -191,7 +191,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/place_atwork/listing.rs b/crates/jacquard-api/src/place_atwork/listing.rs --- a/crates/jacquard-api/src/place_atwork/listing.rs +++ b/crates/jacquard-api/src/place_atwork/listing.rs @@ -126,13 +126,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.description; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 10000usize, actual: ::len(value.as_ref()), }); @@ -147,8 +149,10 @@ ) .count(); if count > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 10000usize, actual: count, }); @@ -159,8 +163,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 200usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 200usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/place_atwork/profile.rs b/crates/jacquard-api/src/place_atwork/profile.rs --- a/crates/jacquard-api/src/place_atwork/profile.rs +++ b/crates/jacquard-api/src/place_atwork/profile.rs @@ -170,12 +170,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 2000usize, actual: ::len(value.as_ref()), }); @@ -189,8 +191,10 @@ ) .count(); if count > 2000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 2000usize, actual: count, }); @@ -200,8 +204,10 @@ if let Some(ref value) = self.display_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 200usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 200usize, actual: ::len(value.as_ref()), }); @@ -215,8 +221,10 @@ ) .count(); if count > 200usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 200usize, actual: count, }); diff --git a/crates/jacquard-api/src/place_atwork/search_listings.rs b/crates/jacquard-api/src/place_atwork/search_listings.rs --- a/crates/jacquard-api/src/place_atwork/search_listings.rs +++ b/crates/jacquard-api/src/place_atwork/search_listings.rs @@ -174,7 +174,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/place_stream/broadcast.rs b/crates/jacquard-api/src/place_stream/broadcast.rs --- a/crates/jacquard-api/src/place_stream/broadcast.rs +++ b/crates/jacquard-api/src/place_stream/broadcast.rs @@ -128,7 +128,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/place_stream/chat.rs b/crates/jacquard-api/src/place_stream/chat.rs --- a/crates/jacquard-api/src/place_stream/chat.rs +++ b/crates/jacquard-api/src/place_stream/chat.rs @@ -207,7 +207,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/place_stream/key.rs b/crates/jacquard-api/src/place_stream/key.rs --- a/crates/jacquard-api/src/place_stream/key.rs +++ b/crates/jacquard-api/src/place_stream/key.rs @@ -105,13 +105,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.signing_key; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 57usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "signing_key", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "signing_key", + ), max: 57usize, actual: ::len(value.as_ref()), }); @@ -121,8 +123,10 @@ let value = &self.signing_key; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 57usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "signing_key", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "signing_key", + ), min: 57usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/place_stream/livestream.rs b/crates/jacquard-api/src/place_stream/livestream.rs --- a/crates/jacquard-api/src/place_stream/livestream.rs +++ b/crates/jacquard-api/src/place_stream/livestream.rs @@ -401,7 +401,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -531,13 +531,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 1400usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 1400usize, actual: ::len(value.as_ref()), }); @@ -552,8 +554,10 @@ ) .count(); if count > 140usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 140usize, actual: count, }); @@ -594,7 +598,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -655,7 +659,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -688,7 +692,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/place_stream/segment.rs b/crates/jacquard-api/src/place_stream/segment.rs --- a/crates/jacquard-api/src/place_stream/segment.rs +++ b/crates/jacquard-api/src/place_stream/segment.rs @@ -451,7 +451,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -485,7 +485,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -625,7 +625,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -661,7 +661,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -705,7 +705,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/place_stream/server.rs b/crates/jacquard-api/src/place_stream/server.rs --- a/crates/jacquard-api/src/place_stream/server.rs +++ b/crates/jacquard-api/src/place_stream/server.rs @@ -415,13 +415,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.from; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "from", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "from", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -431,8 +433,10 @@ let value = &self.from; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "from", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "from", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -442,8 +446,10 @@ let value = &self.to; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "to", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "to", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -537,12 +543,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 500usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 500usize, actual: ::len(value.as_ref()), }); @@ -551,8 +559,10 @@ if let Some(ref value) = self.name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -561,8 +571,10 @@ if let Some(ref value) = self.prefix { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "prefix", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "prefix", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -571,8 +583,10 @@ if let Some(ref value) = self.suffix { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "suffix", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "suffix", + ), max: 100usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/place_wisp/fs.rs b/crates/jacquard-api/src/place_wisp/fs.rs --- a/crates/jacquard-api/src/place_wisp/fs.rs +++ b/crates/jacquard-api/src/place_wisp/fs.rs @@ -261,13 +261,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.entries; #[allow(unused_comparisons)] if value.len() > 500usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "entries", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "entries", + ), max: 500usize, actual: value.len(), }); @@ -328,13 +330,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 255usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 255usize, actual: ::len(value.as_ref()), }); @@ -377,7 +381,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -480,11 +484,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.file_count { if *value > 1000i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "file_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "file_count", + ), max: 1000i64, actual: *value, }); @@ -492,8 +498,10 @@ } if let Some(ref value) = self.file_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "file_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "file_count", + ), min: 0i64, actual: *value, }); diff --git a/crates/jacquard-api/src/pub_leaflet/comment.rs b/crates/jacquard-api/src/pub_leaflet/comment.rs --- a/crates/jacquard-api/src/pub_leaflet/comment.rs +++ b/crates/jacquard-api/src/pub_leaflet/comment.rs @@ -255,7 +255,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -371,7 +371,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -405,7 +405,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/pub_leaflet/document.rs b/crates/jacquard-api/src/pub_leaflet/document.rs --- a/crates/jacquard-api/src/pub_leaflet/document.rs +++ b/crates/jacquard-api/src/pub_leaflet/document.rs @@ -133,12 +133,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 3000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 3000usize, actual: ::len(value.as_ref()), }); @@ -152,8 +154,10 @@ ) .count(); if count > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 300usize, actual: count, }); @@ -164,8 +168,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 1280usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 1280usize, actual: ::len(value.as_ref()), }); @@ -180,8 +186,10 @@ ) .count(); if count > 128usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 128usize, actual: count, }); diff --git a/crates/jacquard-api/src/pub_leaflet/publication.rs b/crates/jacquard-api/src/pub_leaflet/publication.rs --- a/crates/jacquard-api/src/pub_leaflet/publication.rs +++ b/crates/jacquard-api/src/pub_leaflet/publication.rs @@ -117,12 +117,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 2000usize, actual: ::len(value.as_ref()), }); @@ -132,8 +134,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 2000usize, actual: ::len(value.as_ref()), }); @@ -417,7 +421,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -566,7 +570,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_tangled/knot.rs b/crates/jacquard-api/src/sh_tangled/knot.rs --- a/crates/jacquard-api/src/sh_tangled/knot.rs +++ b/crates/jacquard-api/src/sh_tangled/knot.rs @@ -98,7 +98,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_tangled/pipeline.rs b/crates/jacquard-api/src/sh_tangled/pipeline.rs --- a/crates/jacquard-api/src/sh_tangled/pipeline.rs +++ b/crates/jacquard-api/src/sh_tangled/pipeline.rs @@ -597,7 +597,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -694,7 +694,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -729,7 +729,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -765,7 +765,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -805,13 +805,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.source_sha; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 40usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "source_sha", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "source_sha", + ), max: 40usize, actual: ::len(value.as_ref()), }); @@ -821,8 +823,10 @@ let value = &self.source_sha; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 40usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "source_sha", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "source_sha", + ), min: 40usize, actual: ::len(value.as_ref()), }); @@ -865,13 +869,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.new_sha; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 40usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "new_sha", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "new_sha", + ), max: 40usize, actual: ::len(value.as_ref()), }); @@ -881,8 +887,10 @@ let value = &self.new_sha; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 40usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "new_sha", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "new_sha", + ), min: 40usize, actual: ::len(value.as_ref()), }); @@ -892,8 +900,10 @@ let value = &self.old_sha; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 40usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "old_sha", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "old_sha", + ), max: 40usize, actual: ::len(value.as_ref()), }); @@ -903,8 +913,10 @@ let value = &self.old_sha; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 40usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "old_sha", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "old_sha", + ), min: 40usize, actual: ::len(value.as_ref()), }); @@ -958,7 +970,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1001,7 +1013,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1044,7 +1056,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_tangled/public_key.rs b/crates/jacquard-api/src/sh_tangled/public_key.rs --- a/crates/jacquard-api/src/sh_tangled/public_key.rs +++ b/crates/jacquard-api/src/sh_tangled/public_key.rs @@ -103,13 +103,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.key; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 4096usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "key", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "key", + ), max: 4096usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/sh_tangled/repo.rs b/crates/jacquard-api/src/sh_tangled/repo.rs --- a/crates/jacquard-api/src/sh_tangled/repo.rs +++ b/crates/jacquard-api/src/sh_tangled/repo.rs @@ -149,7 +149,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { { let count = ::unicode_segmentation::UnicodeSegmentation::graphemes( @@ -158,8 +158,10 @@ ) .count(); if count > 140usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 140usize, actual: count, }); @@ -174,8 +176,10 @@ ) .count(); if count < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MinGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), min: 1usize, actual: count, }); diff --git a/crates/jacquard-api/src/sh_tangled/spindle.rs b/crates/jacquard-api/src/sh_tangled/spindle.rs --- a/crates/jacquard-api/src/sh_tangled/spindle.rs +++ b/crates/jacquard-api/src/sh_tangled/spindle.rs @@ -96,7 +96,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_tangled/string.rs b/crates/jacquard-api/src/sh_tangled/string.rs --- a/crates/jacquard-api/src/sh_tangled/string.rs +++ b/crates/jacquard-api/src/sh_tangled/string.rs @@ -103,7 +103,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.contents; { @@ -113,8 +113,10 @@ ) .count(); if count < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinGraphemes { - field: "contents", + return Err(::jacquard_lexicon::validation::ConstraintError::MinGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "contents", + ), min: 1usize, actual: count, }); @@ -130,8 +132,10 @@ ) .count(); if count > 280usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 280usize, actual: count, }); @@ -147,8 +151,10 @@ ) .count(); if count > 140usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "filename", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "filename", + ), max: 140usize, actual: count, }); @@ -164,8 +170,10 @@ ) .count(); if count < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinGraphemes { - field: "filename", + return Err(::jacquard_lexicon::validation::ConstraintError::MinGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "filename", + ), min: 1usize, actual: count, }); diff --git a/crates/jacquard-api/src/sh_weaver/actor.rs b/crates/jacquard-api/src/sh_weaver/actor.rs --- a/crates/jacquard-api/src/sh_weaver/actor.rs +++ b/crates/jacquard-api/src/sh_weaver/actor.rs @@ -543,12 +543,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.display_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -562,8 +564,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 64usize, actual: count, }); @@ -622,7 +626,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -694,12 +698,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -713,8 +719,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 256usize, actual: count, }); @@ -724,8 +732,10 @@ if let Some(ref value) = self.display_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -739,8 +749,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 64usize, actual: count, }); @@ -750,8 +762,10 @@ if let Some(ref value) = self.links { #[allow(unused_comparisons)] if value.len() > 5usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "links", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "links", + ), max: 5usize, actual: value.len(), }); @@ -760,8 +774,10 @@ if let Some(ref value) = self.links { #[allow(unused_comparisons)] if value.len() < 0usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "links", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "links", + ), min: 0usize, actual: value.len(), }); @@ -770,8 +786,10 @@ if let Some(ref value) = self.location { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 400usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "location", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "location", + ), max: 400usize, actual: ::len(value.as_ref()), }); @@ -785,8 +803,10 @@ ) .count(); if count > 40usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "location", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "location", + ), max: 40usize, actual: count, }); @@ -853,12 +873,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -872,8 +894,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 256usize, actual: count, }); @@ -883,8 +907,10 @@ if let Some(ref value) = self.links { #[allow(unused_comparisons)] if value.len() > 5usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "links", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "links", + ), max: 5usize, actual: value.len(), }); @@ -893,8 +919,10 @@ if let Some(ref value) = self.links { #[allow(unused_comparisons)] if value.len() < 0usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "links", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "links", + ), min: 0usize, actual: value.len(), }); @@ -903,8 +931,10 @@ if let Some(ref value) = self.location { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 400usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "location", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "location", + ), max: 400usize, actual: ::len(value.as_ref()), }); @@ -918,8 +948,10 @@ ) .count(); if count > 40usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "location", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "location", + ), max: 40usize, actual: count, }); @@ -929,8 +961,10 @@ if let Some(ref value) = self.pinned_repositories { #[allow(unused_comparisons)] if value.len() > 6usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "pinned_repositories", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "pinned_repositories", + ), max: 6usize, actual: value.len(), }); @@ -939,8 +973,10 @@ if let Some(ref value) = self.pinned_repositories { #[allow(unused_comparisons)] if value.len() < 0usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "pinned_repositories", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "pinned_repositories", + ), min: 0usize, actual: value.len(), }); @@ -949,8 +985,10 @@ if let Some(ref value) = self.stats { #[allow(unused_comparisons)] if value.len() > 2usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "stats", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "stats", + ), max: 2usize, actual: value.len(), }); @@ -959,8 +997,10 @@ if let Some(ref value) = self.stats { #[allow(unused_comparisons)] if value.len() < 0usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "stats", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "stats", + ), min: 0usize, actual: value.len(), }); diff --git a/crates/jacquard-api/src/sh_weaver/edit.rs b/crates/jacquard-api/src/sh_weaver/edit.rs --- a/crates/jacquard-api/src/sh_weaver/edit.rs +++ b/crates/jacquard-api/src/sh_weaver/edit.rs @@ -150,7 +150,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -184,7 +184,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -218,7 +218,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_weaver/embed.rs b/crates/jacquard-api/src/sh_weaver/embed.rs --- a/crates/jacquard-api/src/sh_weaver/embed.rs +++ b/crates/jacquard-api/src/sh_weaver/embed.rs @@ -144,7 +144,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -179,7 +179,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_weaver/notebook.rs b/crates/jacquard-api/src/sh_weaver/notebook.rs --- a/crates/jacquard-api/src/sh_weaver/notebook.rs +++ b/crates/jacquard-api/src/sh_weaver/notebook.rs @@ -541,7 +541,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -575,7 +575,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -619,7 +619,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -656,7 +656,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -711,7 +711,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -762,7 +762,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -801,7 +801,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_clippr/actor.rs b/crates/jacquard-api/src/social_clippr/actor.rs --- a/crates/jacquard-api/src/social_clippr/actor.rs +++ b/crates/jacquard-api/src/social_clippr/actor.rs @@ -307,12 +307,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 5000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 5000usize, actual: ::len(value.as_ref()), }); @@ -326,8 +328,10 @@ ) .count(); if count > 500usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 500usize, actual: count, }); @@ -338,8 +342,10 @@ let value = &self.display_name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -354,8 +360,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 64usize, actual: count, }); @@ -397,7 +405,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/social_clippr/feed.rs b/crates/jacquard-api/src/social_clippr/feed.rs --- a/crates/jacquard-api/src/social_clippr/feed.rs +++ b/crates/jacquard-api/src/social_clippr/feed.rs @@ -274,7 +274,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -321,7 +321,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/social_grain/actor.rs b/crates/jacquard-api/src/social_grain/actor.rs --- a/crates/jacquard-api/src/social_grain/actor.rs +++ b/crates/jacquard-api/src/social_grain/actor.rs @@ -208,12 +208,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -227,8 +229,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 256usize, actual: count, }); @@ -238,8 +242,10 @@ if let Some(ref value) = self.display_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -253,8 +259,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 64usize, actual: count, }); diff --git a/crates/jacquard-api/src/social_grain/favorite.rs b/crates/jacquard-api/src/social_grain/favorite.rs --- a/crates/jacquard-api/src/social_grain/favorite.rs +++ b/crates/jacquard-api/src/social_grain/favorite.rs @@ -96,7 +96,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_grain/gallery.rs b/crates/jacquard-api/src/social_grain/gallery.rs --- a/crates/jacquard-api/src/social_grain/gallery.rs +++ b/crates/jacquard-api/src/social_grain/gallery.rs @@ -108,12 +108,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 1000usize, actual: ::len(value.as_ref()), }); @@ -123,8 +125,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -413,7 +417,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/social_grain/photo.rs b/crates/jacquard-api/src/social_grain/photo.rs --- a/crates/jacquard-api/src/social_grain/photo.rs +++ b/crates/jacquard-api/src/social_grain/photo.rs @@ -108,7 +108,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -675,7 +675,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -730,7 +730,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/social_pmsky/proposal.rs b/crates/jacquard-api/src/social_pmsky/proposal.rs --- a/crates/jacquard-api/src/social_pmsky/proposal.rs +++ b/crates/jacquard-api/src/social_pmsky/proposal.rs @@ -137,13 +137,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.val; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 128usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "val", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "val", + ), max: 128usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/social_pmsky/vote.rs b/crates/jacquard-api/src/social_pmsky/vote.rs --- a/crates/jacquard-api/src/social_pmsky/vote.rs +++ b/crates/jacquard-api/src/social_pmsky/vote.rs @@ -122,7 +122,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/tools_ozone/communication.rs b/crates/jacquard-api/src/tools_ozone/communication.rs --- a/crates/jacquard-api/src/tools_ozone/communication.rs +++ b/crates/jacquard-api/src/tools_ozone/communication.rs @@ -263,7 +263,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/tools_ozone/moderation.rs b/crates/jacquard-api/src/tools_ozone/moderation.rs --- a/crates/jacquard-api/src/tools_ozone/moderation.rs +++ b/crates/jacquard-api/src/tools_ozone/moderation.rs @@ -4328,7 +4328,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4372,7 +4372,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4420,7 +4420,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4483,7 +4483,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4522,7 +4522,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4588,7 +4588,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4624,7 +4624,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4673,7 +4673,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4707,7 +4707,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4745,7 +4745,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4784,7 +4784,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4820,7 +4820,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4864,7 +4864,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4899,7 +4899,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4944,7 +4944,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -4983,7 +4983,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -5022,7 +5022,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -5060,12 +5060,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.score; if *value > 100i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "score", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "score", + ), max: 100i64, actual: *value, }); @@ -5074,8 +5076,10 @@ { let value = &self.score; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "score", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "score", + ), min: 0i64, actual: *value, }); @@ -5123,7 +5127,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -5160,7 +5164,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -5197,7 +5201,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -5241,7 +5245,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -5287,12 +5291,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.policies { #[allow(unused_comparisons)] if value.len() > 5usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "policies", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "policies", + ), max: 5usize, actual: value.len(), }); @@ -5334,7 +5340,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -5371,7 +5377,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -5525,7 +5531,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -5673,7 +5679,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -5713,7 +5719,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -5750,7 +5756,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -5787,7 +5793,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -5832,7 +5838,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -5872,7 +5878,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -5917,7 +5923,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -5966,7 +5972,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -6000,7 +6006,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -6057,7 +6063,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -6120,7 +6126,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -6194,7 +6200,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -6228,7 +6234,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -6278,7 +6284,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -6387,7 +6393,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -6429,7 +6435,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -6518,7 +6524,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -6760,11 +6766,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.priority_score { if *value > 100i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "priority_score", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "priority_score", + ), max: 100i64, actual: *value, }); @@ -6772,8 +6780,10 @@ } if let Some(ref value) = self.priority_score { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "priority_score", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "priority_score", + ), min: 0i64, actual: *value, }); @@ -6832,7 +6842,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -6921,7 +6931,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/tools_ozone/safelink.rs b/crates/jacquard-api/src/tools_ozone/safelink.rs --- a/crates/jacquard-api/src/tools_ozone/safelink.rs +++ b/crates/jacquard-api/src/tools_ozone/safelink.rs @@ -522,7 +522,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -820,7 +820,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/tools_ozone/set.rs b/crates/jacquard-api/src/tools_ozone/set.rs --- a/crates/jacquard-api/src/tools_ozone/set.rs +++ b/crates/jacquard-api/src/tools_ozone/set.rs @@ -207,12 +207,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10240usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 10240usize, actual: ::len(value.as_ref()), }); @@ -226,8 +228,10 @@ ) .count(); if count > 1024usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 1024usize, actual: count, }); @@ -238,8 +242,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 128usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 128usize, actual: ::len(value.as_ref()), }); @@ -249,8 +255,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 3usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), min: 3usize, actual: ::len(value.as_ref()), }); @@ -297,12 +305,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10240usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 10240usize, actual: ::len(value.as_ref()), }); @@ -316,8 +326,10 @@ ) .count(); if count > 1024usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 1024usize, actual: count, }); @@ -328,8 +340,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 128usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 128usize, actual: ::len(value.as_ref()), }); @@ -339,8 +353,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 3usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), min: 3usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/tools_ozone/setting.rs b/crates/jacquard-api/src/tools_ozone/setting.rs --- a/crates/jacquard-api/src/tools_ozone/setting.rs +++ b/crates/jacquard-api/src/tools_ozone/setting.rs @@ -265,12 +265,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10240usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 10240usize, actual: ::len(value.as_ref()), }); @@ -284,8 +286,10 @@ ) .count(); if count > 1024usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 1024usize, actual: count, }); diff --git a/crates/jacquard-api/src/tools_ozone/signature.rs b/crates/jacquard-api/src/tools_ozone/signature.rs --- a/crates/jacquard-api/src/tools_ozone/signature.rs +++ b/crates/jacquard-api/src/tools_ozone/signature.rs @@ -103,7 +103,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/tools_ozone/team.rs b/crates/jacquard-api/src/tools_ozone/team.rs --- a/crates/jacquard-api/src/tools_ozone/team.rs +++ b/crates/jacquard-api/src/tools_ozone/team.rs @@ -220,7 +220,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/tools_ozone/verification.rs b/crates/jacquard-api/src/tools_ozone/verification.rs --- a/crates/jacquard-api/src/tools_ozone/verification.rs +++ b/crates/jacquard-api/src/tools_ozone/verification.rs @@ -405,7 +405,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/uk_ewancroft/now.rs b/crates/jacquard-api/src/uk_ewancroft/now.rs --- a/crates/jacquard-api/src/uk_ewancroft/now.rs +++ b/crates/jacquard-api/src/uk_ewancroft/now.rs @@ -99,13 +99,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.text; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 64usize, actual: ::len(value.as_ref()), }); @@ -115,8 +117,10 @@ let value = &self.text; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), min: 1usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/uk_skyblur/post.rs b/crates/jacquard-api/src/uk_skyblur/post.rs --- a/crates/jacquard-api/src/uk_skyblur/post.rs +++ b/crates/jacquard-api/src/uk_skyblur/post.rs @@ -120,12 +120,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.additional { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "additional", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "additional", + ), max: 100000usize, actual: ::len(value.as_ref()), }); @@ -139,8 +141,10 @@ ) .count(); if count > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "additional", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "additional", + ), max: 10000usize, actual: count, }); @@ -151,8 +155,10 @@ let value = &self.text; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 3000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 3000usize, actual: ::len(value.as_ref()), }); @@ -167,8 +173,10 @@ ) .count(); if count > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 300usize, actual: count, }); @@ -179,8 +187,10 @@ let value = &self.visibility; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "visibility", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "visibility", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -195,8 +205,10 @@ ) .count(); if count > 10usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "visibility", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "visibility", + ), max: 10usize, actual: count, }); diff --git a/crates/jacquard-api/src/uk_skyblur/preference.rs b/crates/jacquard-api/src/uk_skyblur/preference.rs --- a/crates/jacquard-api/src/uk_skyblur/preference.rs +++ b/crates/jacquard-api/src/uk_skyblur/preference.rs @@ -96,7 +96,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -233,12 +233,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 10000usize, actual: ::len(value.as_ref()), }); @@ -252,8 +254,10 @@ ) .count(); if count > 100000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 100000usize, actual: count, }); diff --git a/crates/jacquard-api/src/us_polhem/blog.rs b/crates/jacquard-api/src/us_polhem/blog.rs --- a/crates/jacquard-api/src/us_polhem/blog.rs +++ b/crates/jacquard-api/src/us_polhem/blog.rs @@ -98,12 +98,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.height; if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "height", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "height", + ), min: 1i64, actual: *value, }); @@ -112,8 +114,10 @@ { let value = &self.width; if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "width", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "width", + ), min: 1i64, actual: *value, }); diff --git a/crates/jacquard-api/src/win_tomo_x/pushat.rs b/crates/jacquard-api/src/win_tomo_x/pushat.rs --- a/crates/jacquard-api/src/win_tomo_x/pushat.rs +++ b/crates/jacquard-api/src/win_tomo_x/pushat.rs @@ -225,13 +225,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 300usize, actual: ::len(value.as_ref()), }); @@ -246,8 +248,10 @@ ) .count(); if count > 30usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 30usize, actual: count, }); @@ -299,7 +303,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-lexicon/src/codegen/builder_heuristics.rs b/crates/jacquard-lexicon/src/codegen/builder_heuristics.rs new file mode 100644 --- /dev/null +++ b/crates/jacquard-lexicon/src/codegen/builder_heuristics.rs @@ -0,0 +1,76 @@ +use crate::lexicon::{LexObject, LexObjectProperty}; + +/// Decision about whether to generate builder and/or Default impl for a struct. +#[derive(Debug, Clone, Copy)] +pub struct BuilderDecision { + /// Whether to generate a bon::Builder derive + pub has_builder: bool, + /// Whether to generate a Default derive + pub has_default: bool, +} + +/// Determine whether a struct should have builder and/or Default based on heuristics. +/// +/// Rules: +/// - 0 required fields → Default (no builder) +/// - All required fields are bare strings → Default (no builder) +/// - 1+ required fields (not all strings) → Builder (no Default) +/// - Type name conflicts with bon::Builder → no builder regardless +/// +/// # Parameters +/// - `type_name`: Name of the generated struct (to check for conflicts) +/// - `obj`: Lexicon object schema +/// +/// # Returns +/// Decision about builder and Default generation +pub fn should_generate_builder(type_name: &str, obj: &LexObject<'static>) -> BuilderDecision { + let required_count = count_required_fields(obj); + let has_default = required_count == 0 || all_required_are_defaultable_strings(obj); + let has_builder = + required_count >= 1 && !has_default && !conflicts_with_builder_macro(type_name); + + BuilderDecision { + has_builder, + has_default, + } +} + +/// Check if a type name conflicts with types referenced by bon::Builder macro. +/// bon::Builder generates code that uses unqualified `Option` and `Result`, +/// so structs with these names cause compilation errors. +/// +/// This is public for cases where a struct always wants a builder (like records) +/// but needs to check for conflicts. +pub fn conflicts_with_builder_macro(type_name: &str) -> bool { + matches!(type_name, "Option" | "Result") +} + +/// Count the number of required fields in a lexicon object. +/// Used to determine whether to generate builders or Default impls. +fn count_required_fields(obj: &LexObject<'static>) -> usize { + let required = obj.required.as_ref().map(|r| r.as_slice()).unwrap_or(&[]); + required.len() +} + +/// Check if a field property is a plain string that can default to empty. +/// Returns true for bare CowStr fields (no format constraints). +fn is_defaultable_string(prop: &LexObjectProperty<'static>) -> bool { + matches!(prop, LexObjectProperty::String(s) if s.format.is_none()) +} + +/// Check if all required fields in an object are defaultable strings. +fn all_required_are_defaultable_strings(obj: &LexObject<'static>) -> bool { + let required = obj.required.as_ref().map(|r| r.as_slice()).unwrap_or(&[]); + + if required.is_empty() { + return false; // Handled separately by count check + } + + required.iter().all(|field_name| { + let field_name_str: &str = field_name.as_ref(); + obj.properties + .get(field_name_str) + .map(is_defaultable_string) + .unwrap_or(false) + }) +} diff --git a/crates/jacquard-lexicon/src/codegen/lifetime.rs b/crates/jacquard-lexicon/src/codegen/lifetime.rs --- a/crates/jacquard-lexicon/src/codegen/lifetime.rs +++ b/crates/jacquard-lexicon/src/codegen/lifetime.rs @@ -132,11 +132,6 @@ } } - /// Check if a lexicon def needs a lifetime parameter - pub(super) fn def_needs_lifetime(&self, def: &LexUserType<'_>) -> bool { - def.needs_lifetime(self) - } - /// Check if xrpc params need a lifetime parameter pub(super) fn params_need_lifetime( &self, diff --git a/crates/jacquard-lexicon/src/codegen/names.rs b/crates/jacquard-lexicon/src/codegen/names.rs --- a/crates/jacquard-lexicon/src/codegen/names.rs +++ b/crates/jacquard-lexicon/src/codegen/names.rs @@ -1,5 +1,5 @@ use super::nsid_utils::NsidPath; -use super::utils::sanitize_name; +use super::utils::{namespace_prefix, sanitize_name, sanitize_name_cow}; use super::CodeGenerator; use heck::{ToPascalCase, ToSnakeCase}; @@ -140,7 +140,7 @@ if nsid_path.is_defs() && parts.len() >= 3 { // defs go in parent module: com.atproto.label.defs → com_atproto/label.rs - let first_two = format!("{}_{}", sanitize_name(parts[0]), sanitize_name(parts[1])); + let first_two = namespace_prefix(parts[0], parts[1]); if parts.len() == 3 { // com.atproto.defs → com_atproto.rs format!("{}.rs", first_two).into() @@ -149,21 +149,21 @@ let middle: Vec<&str> = parts[2..parts.len() - 1].iter().copied().collect(); let mut path = std::path::PathBuf::from(first_two); for segment in &middle[..middle.len() - 1] { - path.push(sanitize_name(segment)); + path.push(sanitize_name_cow(segment).as_ref()); } - path.push(format!("{}.rs", sanitize_name(middle.last().unwrap()))); + path.push(format!("{}.rs", sanitize_name_cow(middle.last().unwrap()))); path } } else { // Regular path: app.bsky.feed.post → app_bsky/feed/post.rs - let first_two = format!("{}_{}", sanitize_name(parts[0]), sanitize_name(parts[1])); + let first_two = namespace_prefix(parts[0], parts[1]); let mut path = std::path::PathBuf::from(first_two); for segment in &parts[2..parts.len() - 1] { - path.push(sanitize_name(segment)); + path.push(sanitize_name_cow(segment).as_ref()); } - path.push(format!("{}.rs", sanitize_name(&last.to_snake_case()))); + path.push(format!("{}.rs", sanitize_name_cow(&last.to_snake_case()))); path } } diff --git a/crates/jacquard-lexicon/src/codegen/schema_impl.rs b/crates/jacquard-lexicon/src/codegen/schema_impl.rs --- a/crates/jacquard-lexicon/src/codegen/schema_impl.rs +++ b/crates/jacquard-lexicon/src/codegen/schema_impl.rs @@ -54,7 +54,7 @@ #doc_literal } - fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { #validation_code } } diff --git a/crates/jacquard-lexicon/src/codegen/structs.rs b/crates/jacquard-lexicon/src/codegen/structs.rs --- a/crates/jacquard-lexicon/src/codegen/structs.rs +++ b/crates/jacquard-lexicon/src/codegen/structs.rs @@ -2,11 +2,12 @@ use crate::lexicon::{ LexArrayItem, LexInteger, LexObject, LexObjectProperty, LexRecord, LexString, }; -use heck::{ToPascalCase, ToSnakeCase}; +use heck::ToSnakeCase; +use jacquard_common::smol_str::SmolStr; use proc_macro2::TokenStream; use quote::quote; +use std::collections::BTreeMap; -use super::nsid_utils::{NsidPath, RefPath}; use super::CodeGenerator; use super::utils::{make_ident, value_to_variant_name}; @@ -19,44 +20,78 @@ Struct(Vec), } -/// Check if a type name conflicts with types referenced by bon::Builder macro. -/// bon::Builder generates code that uses unqualified `Option` and `Result`, -/// so structs with these names cause compilation errors. -pub(crate) fn conflicts_with_builder_macro(type_name: &str) -> bool { - matches!(type_name, "Option" | "Result") -} +impl<'c> CodeGenerator<'c> { + /// Generate all nested type definitions (unions, objects) for an object's properties. + /// This consolidates the pattern of iterating properties to find unions and nested objects + /// that need their own type definitions. + /// + /// # Parameters + /// - `include_nested_objects`: If false, skips generating nested object types (used by XRPC) + pub(super) fn generate_nested_types( + &self, + nsid: &str, + parent_type_name: &str, + properties: &BTreeMap>, + include_nested_objects: bool, + ) -> Result> { + let mut nested = Vec::new(); -/// Count the number of required fields in a lexicon object. -/// Used to determine whether to generate builders or Default impls. -pub(crate) fn count_required_fields(obj: &LexObject<'static>) -> usize { - let required = obj.required.as_ref().map(|r| r.as_slice()).unwrap_or(&[]); - required.len() -} + for (field_name, field_type) in properties { + match field_type { + LexObjectProperty::Union(union) => { + // Skip empty, single-variant unions unless they're self-referential + if !union.refs.is_empty() + && (union.refs.len() > 1 + || self.is_self_referential_union(nsid, parent_type_name, &union)) + { + let union_name = + self.generate_field_type_name(nsid, parent_type_name, field_name, ""); + let refs: Vec<_> = union.refs.iter().cloned().collect(); + let union_def = self.generate_union( + nsid, + &union_name, + &refs, + None, + union.closed, + )?; + nested.push(union_def); + } + } + LexObjectProperty::Object(nested_obj) if include_nested_objects => { + let object_name = + self.generate_field_type_name(nsid, parent_type_name, field_name, ""); + let obj_def = self.generate_object(nsid, &object_name, &nested_obj)?; + nested.push(obj_def); + } + LexObjectProperty::Array(array) => { + if let LexArrayItem::Union(union) = &array.items { + // Skip single-variant array unions + if union.refs.len() > 1 { + let union_name = self.generate_field_type_name( + nsid, + parent_type_name, + field_name, + "Item", + ); + let refs: Vec<_> = union.refs.iter().cloned().collect(); + let union_def = self.generate_union( + nsid, + &union_name, + &refs, + None, + union.closed, + )?; + nested.push(union_def); + } + } + } + _ => {} + } + } -/// Check if a field property is a plain string that can default to empty. -/// Returns true for bare CowStr fields (no format constraints). -fn is_defaultable_string(prop: &LexObjectProperty<'static>) -> bool { - matches!(prop, LexObjectProperty::String(s) if s.format.is_none()) -} - -/// Check if all required fields in an object are defaultable strings. -pub(crate) fn all_required_are_defaultable_strings(obj: &LexObject<'static>) -> bool { - let required = obj.required.as_ref().map(|r| r.as_slice()).unwrap_or(&[]); - - if required.is_empty() { - return false; // Handled separately by count check + Ok(nested) } - required.iter().all(|field_name| { - let field_name_str: &str = field_name.as_ref(); - obj.properties - .get(field_name_str) - .map(is_defaultable_string) - .unwrap_or(false) - }) -} - -impl<'c> CodeGenerator<'c> { pub(super) fn generate_record( &self, nsid: &str, @@ -71,7 +106,8 @@ // Records always get a lifetime since they have the #[lexicon] attribute // which adds extra_data: BTreeMap<..., Data<'a>> // Skip bon::Builder for types that conflict with the macro's unqualified type references - let has_builder = !conflicts_with_builder_macro(&type_name); + let has_builder = + !super::builder_heuristics::conflicts_with_builder_macro(&type_name); // Generate main struct fields let fields = self.generate_object_fields(nsid, &type_name, obj, has_builder)?; @@ -100,56 +136,7 @@ }; // Generate union types and nested object types for this record - let mut unions = Vec::new(); - for (field_name, field_type) in &obj.properties { - match field_type { - LexObjectProperty::Union(union) => { - // Skip empty, single-variant unions unless they're self-referential - if !union.refs.is_empty() - && (union.refs.len() > 1 - || self.is_self_referential_union(nsid, &type_name, union)) - { - let union_name = - self.generate_field_type_name(nsid, &type_name, field_name, ""); - let refs: Vec<_> = union.refs.iter().cloned().collect(); - let union_def = self.generate_union( - nsid, - &union_name, - &refs, - None, - union.closed, - )?; - unions.push(union_def); - } - } - LexObjectProperty::Object(nested_obj) => { - let object_name = - self.generate_field_type_name(nsid, &type_name, field_name, ""); - let obj_def = self.generate_object(nsid, &object_name, nested_obj)?; - unions.push(obj_def); - } - LexObjectProperty::Array(array) => { - if let LexArrayItem::Union(union) = &array.items { - // Skip single-variant array unions - if union.refs.len() > 1 { - let union_name = self.generate_field_type_name( - nsid, &type_name, field_name, "Item", - ); - let refs: Vec<_> = union.refs.iter().cloned().collect(); - let union_def = self.generate_union( - nsid, - &union_name, - &refs, - None, - union.closed, - )?; - unions.push(union_def); - } - } - } - _ => {} - } - } + let unions = self.generate_nested_types(nsid, &type_name, &obj.properties, true)?; // Generate typed GetRecordOutput wrapper let output_type_name = format!("{}GetRecordOutput", type_name); @@ -257,10 +244,9 @@ // - 0 required fields: Default instead of builder // - All required fields are bare strings: Default instead of builder // - 1+ required fields (not all strings): bon::Builder (but not if name conflicts) - let required_count = count_required_fields(obj); - let has_default = required_count == 0 || all_required_are_defaultable_strings(obj); - let has_builder = - required_count >= 1 && !has_default && !conflicts_with_builder_macro(&type_name); + let decision = super::builder_heuristics::should_generate_builder(&type_name, obj); + let has_builder = decision.has_builder; + let has_default = decision.has_default; let fields = self.generate_object_fields(nsid, &type_name, obj, has_builder)?; let doc = self.generate_doc_comment(obj.description.as_ref()); @@ -298,45 +284,7 @@ }; // Generate union types and nested object types for this object - let mut unions = Vec::new(); - for (field_name, field_type) in &obj.properties { - match field_type { - LexObjectProperty::Union(union) => { - // Skip empty, single-variant unions unless they're self-referential - if !union.refs.is_empty() - && (union.refs.len() > 1 - || self.is_self_referential_union(nsid, &type_name, union)) - { - let union_name = - self.generate_field_type_name(nsid, &type_name, field_name, ""); - let refs: Vec<_> = union.refs.iter().cloned().collect(); - let union_def = - self.generate_union(nsid, &union_name, &refs, None, union.closed)?; - unions.push(union_def); - } - } - LexObjectProperty::Object(nested_obj) => { - let object_name = - self.generate_field_type_name(nsid, &type_name, field_name, ""); - let obj_def = self.generate_object(nsid, &object_name, nested_obj)?; - unions.push(obj_def); - } - LexObjectProperty::Array(array) => { - if let LexArrayItem::Union(union) = &array.items { - // Skip single-variant array unions - if union.refs.len() > 1 { - let union_name = - self.generate_field_type_name(nsid, &type_name, field_name, "Item"); - let refs: Vec<_> = union.refs.iter().cloned().collect(); - let union_def = - self.generate_union(nsid, &union_name, &refs, None, union.closed)?; - unions.push(union_def); - } - } - } - _ => {} - } - } + let unions = self.generate_nested_types(nsid, &type_name, &obj.properties, true)?; // Generate LexiconSchema impl with shared lexicon_doc function let (shared_fn, schema_impl) = @@ -467,121 +415,15 @@ ) -> Result { let enum_ident = syn::Ident::new(union_name, proc_macro2::Span::call_site()); - // Extract namespace prefix from current NSID (first two segments: "sh.weaver" from "sh.weaver.embed.recordWithMedia") - let current_nsid_path = NsidPath::parse(current_nsid); - let current_namespace = current_nsid_path.namespace(); + // Build variants using the union_codegen module + let ctx = super::union_codegen::UnionGenContext { + corpus: self.corpus, + namespace_deps: &self.namespace_deps, + current_nsid, + }; - // First pass: collect all variant names and detect collisions - #[derive(Debug)] - struct VariantInfo { - ref_str: String, - ref_nsid: String, - simple_name: String, - is_current_namespace: bool, - } - - let mut variant_infos = Vec::new(); - for ref_str in refs { - // Normalize local refs (starting with #) by prepending current NSID - let normalized_ref = RefPath::normalize(ref_str, current_nsid); - - // Parse ref to get NSID and def name - let ref_path = RefPath::parse(&normalized_ref, None); - let ref_nsid_str = ref_path.nsid(); - let ref_def = ref_path.def(); - - // Skip unknown refs - they'll be handled by Unknown variant - if !self.corpus.ref_exists(&normalized_ref) { - continue; - } - - // Check if ref is in current namespace and if it's the same module - let is_current_namespace = ref_nsid_str.starts_with(¤t_namespace); - let is_same_module = ref_nsid_str == current_nsid; - - // Generate simple variant name (without namespace prefix) - let last_segment = ref_nsid_str.split('.').last().unwrap(); - let simple_name = if ref_def == "main" { - // For main, use the last NSID segment - // e.g. app.bsky.embed.images#main -> Images - last_segment.to_pascal_case() - } else if last_segment == "defs" { - // For defs modules, just use the fragment name without "Defs" prefix - // e.g. app.bsky.embed.defs#images -> Images (not DefsImages) - ref_def.to_pascal_case() - } else if is_same_module { - // For same-module refs, just use the fragment name to avoid redundancy - // e.g. sh.weaver.embed.records#viewRecord in records.rs -> ViewRecord (not RecordsViewRecord) - ref_def.to_pascal_case() - } else { - // For other fragments, include the last NSID segment to avoid collisions - // e.g. app.bsky.embed.images#view -> ImagesView - // app.bsky.embed.video#view -> VideoView - format!( - "{}{}", - last_segment.to_pascal_case(), - ref_def.to_pascal_case() - ) - }; - - variant_infos.push(VariantInfo { - ref_str: normalized_ref.clone(), - ref_nsid: ref_nsid_str.to_string(), - simple_name, - is_current_namespace, - }); - } - - // Second pass: detect collisions and disambiguate - use std::collections::HashMap; - let mut name_counts: HashMap = HashMap::new(); - for info in &variant_infos { - *name_counts.entry(info.simple_name.clone()).or_insert(0) += 1; - } - - let mut variants = Vec::new(); - for info in variant_infos { - let has_collision = name_counts.get(&info.simple_name).copied().unwrap_or(0) > 1; - - // Track namespace dependency for foreign refs - if !info.is_current_namespace { - let ref_nsid_path = NsidPath::parse(&info.ref_nsid); - let foreign_namespace = ref_nsid_path.namespace(); - self.namespace_deps - .borrow_mut() - .entry(current_namespace.clone()) - .or_default() - .insert(foreign_namespace); - } - - // Disambiguate: add second NSID segment prefix only to foreign refs when there's a collision - let variant_name = if has_collision && !info.is_current_namespace { - // Get second segment (namespace identifier: "bsky" from "app.bsky.embed.images") - let ref_nsid_path = NsidPath::parse(&info.ref_nsid); - let segments = ref_nsid_path.segments(); - let prefix = if segments.len() >= 2 { - segments[1].to_pascal_case() - } else { - // Fallback: use first segment if only one exists - segments[0].to_pascal_case() - }; - format!("{}{}", prefix, info.simple_name) - } else { - info.simple_name.clone() - }; - - let variant_ident = syn::Ident::new(&variant_name, proc_macro2::Span::call_site()); - - // Get the Rust type for this ref - let rust_type = self.ref_to_rust_type(&info.ref_str)?; - - // Add serde rename for the full NSID - let ref_str_literal = &info.ref_str; - variants.push(quote! { - #[serde(rename = #ref_str_literal)] - #variant_ident(Box<#rust_type>) - }); - } + let union_variants = ctx.build_union_variants(refs, |ref_str| self.ref_to_rust_type(ref_str))?; + let variants = super::union_codegen::generate_variant_tokens(&union_variants); let doc = description .map(|d| quote! { #[doc = #d] }) diff --git a/crates/jacquard-lexicon/src/codegen/types.rs b/crates/jacquard-lexicon/src/codegen/types.rs --- a/crates/jacquard-lexicon/src/codegen/types.rs +++ b/crates/jacquard-lexicon/src/codegen/types.rs @@ -4,8 +4,9 @@ use proc_macro2::TokenStream; use quote::quote; -use super::nsid_utils::{NsidPath, RefPath}; use super::CodeGenerator; +use super::nsid_utils::{NsidPath, RefPath}; +use super::utils::{join_module_path, join_path_parts, namespace_prefix, sanitize_name_cow}; impl<'c> CodeGenerator<'c> { /// Convert a property type to Rust type @@ -178,7 +179,6 @@ /// Convert ref to Rust type path pub(super) fn ref_to_rust_type(&self, ref_str: &str) -> Result { - use super::utils::sanitize_name; use crate::error::CodegenError; // Parse ref to get NSID and def @@ -205,40 +205,28 @@ let path_str = if nsid_path.is_defs() && parts.len() >= 3 { // defs types go in parent module - let first_two = format!("{}_{}", sanitize_name(parts[0]), sanitize_name(parts[1])); + let first_two = namespace_prefix(parts[0], parts[1]); if parts.len() == 3 { // com.atproto.defs -> com_atproto::TypeName - format!("{}::{}::{}", self.root_module, first_two, type_name) + join_path_parts(&[&self.root_module, &first_two, &type_name]) } else { // app.bsky.actor.defs -> app_bsky::actor::TypeName - let middle: Vec<_> = parts[2..parts.len() - 1] - .iter() - .copied() - .map(|s| sanitize_name(s)) - .collect(); - format!( - "{}::{}::{}::{}", - self.root_module, - first_two, - middle.join("::"), - type_name - ) + let middle = &parts[2..parts.len() - 1]; + let middle_path = join_module_path(middle); + join_path_parts(&[&self.root_module, &first_two, &middle_path, &type_name]) } } else { // Regular types go in their own module file let (module_path, file_module) = if parts.len() >= 3 { // Join first two segments with underscore - let first_two = format!("{}_{}", sanitize_name(parts[0]), sanitize_name(parts[1])); - let file_name = sanitize_name(last_segment).to_snake_case(); + let first_two = namespace_prefix(parts[0], parts[1]); + let file_name = sanitize_name_cow(last_segment).to_string().to_snake_case(); if parts.len() > 3 { // Middle segments form the module path - let middle: Vec<_> = parts[2..parts.len() - 1] - .iter() - .copied() - .map(|s| sanitize_name(s)) - .collect(); - let base_path = format!("{}::{}", first_two, middle.join("::")); + let middle = &parts[2..parts.len() - 1]; + let middle_path = join_module_path(middle); + let base_path = join_path_parts(&[&first_two, &middle_path]); (base_path, file_name) } else { // Only 3 parts: com.atproto.label -> com_atproto, file: label @@ -246,17 +234,14 @@ } } else if parts.len() == 2 { // e.g., "com.example" -> "com_example", file: example - let first = sanitize_name(parts[0]); - let file_name = sanitize_name(parts[1]).to_snake_case(); + let first = sanitize_name_cow(parts[0]).to_string(); + let file_name = sanitize_name_cow(parts[1]).to_string().to_snake_case(); (first, file_name) } else { (parts[0].to_string(), "main".to_string()) }; - format!( - "{}::{}::{}::{}", - self.root_module, module_path, file_module, type_name - ) + join_path_parts(&[&self.root_module, &module_path, &file_module, &type_name]) }; let path: syn::Path = syn::parse_str(&path_str).map_err(|e| CodegenError::Other { diff --git a/crates/jacquard-lexicon/src/codegen/union_codegen.rs b/crates/jacquard-lexicon/src/codegen/union_codegen.rs new file mode 100644 --- /dev/null +++ b/crates/jacquard-lexicon/src/codegen/union_codegen.rs @@ -0,0 +1,184 @@ +use crate::codegen::nsid_utils::{NsidPath, RefPath}; +use crate::corpus::LexiconCorpus; +use crate::error::Result; +use heck::ToPascalCase; +use jacquard_common::CowStr; +use proc_macro2::TokenStream; +use quote::quote; +use std::cell::RefCell; +use std::collections::{HashMap, HashSet}; + +/// Information about a union variant +#[derive(Debug, Clone)] +pub struct UnionVariant { + /// The original ref string (normalized) + pub ref_str: String, + /// The variant name (may be disambiguated) + pub variant_name: String, + /// The Rust type for this variant + pub rust_type: TokenStream, +} + +/// Context for tracking namespace dependencies during union generation +pub struct UnionGenContext<'a> { + pub corpus: &'a LexiconCorpus, + pub namespace_deps: &'a RefCell>>, + pub current_nsid: &'a str, +} + +impl<'a> UnionGenContext<'a> { + /// Build variants for a union with collision detection and disambiguation + pub fn build_union_variants( + &self, + refs: &[CowStr<'static>], + ref_to_rust_type: impl Fn(&str) -> Result, + ) -> Result> { + let current_nsid_path = NsidPath::parse(self.current_nsid); + let current_namespace = current_nsid_path.namespace(); + + // First pass: collect all variant names and detect collisions + #[derive(Debug)] + struct VariantInfo { + ref_str: String, + ref_nsid: String, + simple_name: String, + is_current_namespace: bool, + } + + let mut variant_infos = Vec::new(); + for ref_str in refs { + let normalized_ref = RefPath::normalize(ref_str, self.current_nsid); + let ref_path = RefPath::parse(&normalized_ref, None); + let ref_nsid_str = ref_path.nsid(); + let ref_def = ref_path.def(); + + // Skip unknown refs + if !self.corpus.ref_exists(&normalized_ref) { + continue; + } + + let is_current_namespace = ref_nsid_str.starts_with(¤t_namespace); + let is_same_module = ref_nsid_str == self.current_nsid; + + // Generate simple variant name + let last_segment = ref_nsid_str.split('.').last().unwrap(); + let simple_name = if ref_def == "main" { + last_segment.to_pascal_case() + } else if last_segment == "defs" { + ref_def.to_pascal_case() + } else if is_same_module { + ref_def.to_pascal_case() + } else { + format!( + "{}{}", + last_segment.to_pascal_case(), + ref_def.to_pascal_case() + ) + }; + + variant_infos.push(VariantInfo { + ref_str: normalized_ref.clone(), + ref_nsid: ref_nsid_str.to_string(), + simple_name, + is_current_namespace, + }); + } + + // Second pass: detect collisions and disambiguate + let mut name_counts: HashMap = HashMap::new(); + for info in &variant_infos { + *name_counts.entry(info.simple_name.clone()).or_insert(0) += 1; + } + + let mut variants = Vec::new(); + for info in variant_infos { + let has_collision = name_counts.get(&info.simple_name).copied().unwrap_or(0) > 1; + + // Track namespace dependency for foreign refs + if !info.is_current_namespace { + let ref_nsid_path = NsidPath::parse(&info.ref_nsid); + let foreign_namespace = ref_nsid_path.namespace(); + self.namespace_deps + .borrow_mut() + .entry(current_namespace.clone()) + .or_default() + .insert(foreign_namespace); + } + + // Disambiguate: add second NSID segment prefix only to foreign refs when there's a collision + let variant_name = if has_collision && !info.is_current_namespace { + let ref_nsid_path = NsidPath::parse(&info.ref_nsid); + let segments = ref_nsid_path.segments(); + let prefix = if segments.len() >= 2 { + segments[1].to_pascal_case() + } else { + segments[0].to_pascal_case() + }; + format!("{}{}", prefix, info.simple_name) + } else { + info.simple_name.clone() + }; + + let rust_type = ref_to_rust_type(&info.ref_str)?; + + variants.push(UnionVariant { + ref_str: info.ref_str, + variant_name, + rust_type, + }); + } + + Ok(variants) + } + + /// Build variants for a union without collision detection (simple mode) + pub fn build_simple_union_variants( + &self, + refs: &[CowStr<'static>], + ref_to_rust_type: impl Fn(&str) -> Result, + ) -> Result> { + let mut variants = Vec::new(); + + for ref_str in refs { + let ref_str_s = ref_str.as_ref(); + let normalized_ref = RefPath::normalize(ref_str, self.current_nsid); + let ref_path = RefPath::parse(&normalized_ref, None); + let ref_nsid = ref_path.nsid(); + let ref_def = ref_path.def(); + + let variant_name = if ref_def == "main" { + let ref_nsid_path = NsidPath::parse(ref_nsid); + ref_nsid_path.last_segment().to_pascal_case() + } else { + ref_def.to_pascal_case() + }; + + let rust_type = ref_to_rust_type(&normalized_ref)?; + + variants.push(UnionVariant { + ref_str: ref_str_s.to_string(), + variant_name, + rust_type, + }); + } + + Ok(variants) + } +} + +/// Generate variant tokens for a union enum +pub fn generate_variant_tokens(variants: &[UnionVariant]) -> Vec { + variants + .iter() + .map(|variant| { + let variant_ident = syn::Ident::new(&variant.variant_name, proc_macro2::Span::call_site()); + let ref_str_literal = &variant.ref_str; + let rust_type = &variant.rust_type; + + quote! { + #[serde(rename = #ref_str_literal)] + #variant_ident(Box<#rust_type>) + } + }) + .collect() +} diff --git a/crates/jacquard-lexicon/src/codegen/utils.rs b/crates/jacquard-lexicon/src/codegen/utils.rs --- a/crates/jacquard-lexicon/src/codegen/utils.rs +++ b/crates/jacquard-lexicon/src/codegen/utils.rs @@ -19,10 +19,34 @@ } } -/// Sanitize a string to be safe for identifiers and filenames -pub(super) fn sanitize_name(s: &str) -> String { +/// Check if a string is already a valid identifier (alphanumeric + underscore, not starting with digit) +#[inline] +fn is_valid_identifier(s: &str) -> bool { if s.is_empty() { - return "unknown".to_string(); + return false; + } + + let mut chars = s.chars(); + let first = chars.next().unwrap(); + + // Must start with letter or underscore + if !first.is_ascii_alphabetic() && first != '_' { + return false; + } + + // Rest must be alphanumeric or underscore + chars.all(|c| c.is_ascii_alphanumeric() || c == '_') +} + +/// Sanitize a string to be safe for identifiers and filenames, returning CowStr. +/// Borrows if already valid, allocates if modifications needed. +pub(super) fn sanitize_name_cow(s: &str) -> CowStr<'_> { + if is_valid_identifier(s) { + return CowStr::Borrowed(s); + } + + if s.is_empty() { + return CowStr::Owned(jacquard_common::smol_str::SmolStr::new_static("unknown")); } // Replace invalid characters with underscores @@ -46,7 +70,37 @@ sanitized = format!("_{}", sanitized); } + CowStr::Owned(sanitized.into()) +} + +/// Sanitize a string to be safe for identifiers and filenames, always returning String. +/// Convenience wrapper around sanitize_name_cow for existing callsites. +pub(super) fn sanitize_name(s: &str) -> String { + sanitize_name_cow(s).to_string() +} + +/// Build namespace prefix from first two NSID segments (e.g., "com", "atproto" → "com_atproto") +pub(super) fn namespace_prefix(first: &str, second: &str) -> String { + format!("{}_{}", sanitize_name_cow(first), sanitize_name_cow(second)) +} + +/// Join NSID segments into a module path (e.g., ["repo", "admin"] → "repo::admin") +pub(super) fn join_module_path(segments: &[&str]) -> String { + let sanitized: Vec<_> = segments.iter().map(|s| sanitize_name_cow(s)).collect(); sanitized + .iter() + .map(|s| s.as_ref()) + .collect::>() + .join("::") +} + +/// Join already-processed strings into a Rust module path (e.g., ["crate", "foo", "Bar"] → "crate::foo::Bar") +pub(super) fn join_path_parts(parts: &[impl AsRef]) -> String { + parts + .iter() + .map(|p| p.as_ref()) + .collect::>() + .join("::") } /// Create an identifier, using raw identifier if necessary for keywords diff --git a/crates/jacquard-lexicon/src/codegen/xrpc.rs b/crates/jacquard-lexicon/src/codegen/xrpc.rs --- a/crates/jacquard-lexicon/src/codegen/xrpc.rs +++ b/crates/jacquard-lexicon/src/codegen/xrpc.rs @@ -1,13 +1,12 @@ use crate::error::Result; use crate::lexicon::{ - LexArrayItem, LexObjectProperty, LexXrpcBody, LexXrpcBodySchema, LexXrpcError, - LexXrpcProcedure, LexXrpcQuery, LexXrpcSubscription, LexXrpcSubscriptionMessageSchema, + LexXrpcBody, LexXrpcBodySchema, LexXrpcError, LexXrpcProcedure, LexXrpcQuery, + LexXrpcSubscription, LexXrpcSubscriptionMessageSchema, }; use heck::{ToPascalCase, ToSnakeCase}; use proc_macro2::TokenStream; use quote::quote; -use super::nsid_utils::{NsidPath, RefPath}; use super::CodeGenerator; use super::utils::make_ident; @@ -224,43 +223,31 @@ let enum_name = format!("{}Message", type_base); let enum_ident = syn::Ident::new(&enum_name, proc_macro2::Span::call_site()); - let mut variants = Vec::new(); - let mut decode_arms = Vec::new(); + // Build variants using the union_codegen module (simple mode, no collision detection) + let ctx = super::union_codegen::UnionGenContext { + corpus: self.corpus, + namespace_deps: &self.namespace_deps, + current_nsid: nsid, + }; - for ref_str in &union.refs { - let ref_str_s = ref_str.as_ref(); + let union_variants = ctx.build_simple_union_variants(&union.refs, |ref_str| self.ref_to_rust_type(ref_str))?; + let variants = super::union_codegen::generate_variant_tokens(&union_variants); - // Normalize local refs (starting with #) by prepending current NSID - let normalized_ref = RefPath::normalize(ref_str, nsid); - - // Parse ref to get NSID and def name - let ref_path = RefPath::parse(&normalized_ref, None); - let ref_nsid = ref_path.nsid(); - let ref_def = ref_path.def(); - - let variant_name = if ref_def == "main" { - let ref_nsid_path = NsidPath::parse(ref_nsid); - ref_nsid_path.last_segment().to_pascal_case() - } else { - ref_def.to_pascal_case() - }; - let variant_ident = - syn::Ident::new(&variant_name, proc_macro2::Span::call_site()); - let type_path = self.ref_to_rust_type(&normalized_ref)?; - - variants.push(quote! { - #[serde(rename = #ref_str_s)] - #variant_ident(Box<#type_path>) - }); - - // Generate decode arm for framed decoding - decode_arms.push(quote! { - #ref_str_s => { - let variant = serde_ipld_dagcbor::from_slice(body)?; - Ok(Self::#variant_ident(Box::new(variant))) + // Generate decode arms for framed decoding + let decode_arms: Vec<_> = union_variants + .iter() + .map(|variant| { + let ref_str_literal = &variant.ref_str; + let variant_ident = + syn::Ident::new(&variant.variant_name, proc_macro2::Span::call_site()); + quote! { + #ref_str_literal => { + let variant = serde_ipld_dagcbor::from_slice(body)?; + Ok(Self::#variant_ident(Box::new(variant))) + } } - }); - } + }) + .collect(); let doc = self.generate_doc_comment(union.description.as_ref()); @@ -314,57 +301,7 @@ }; // Generate union types for this message - let mut unions = Vec::new(); - for (field_name, field_type) in &obj.properties { - match field_type { - LexObjectProperty::Union(union) => { - // Skip empty, single-variant unions unless they're self-referential - if !union.refs.is_empty() - && (union.refs.len() > 1 - || self.is_self_referential_union(nsid, &struct_name, union)) - { - let union_name = self.generate_field_type_name( - nsid, - &struct_name, - field_name, - "", - ); - let refs: Vec<_> = union.refs.iter().cloned().collect(); - let union_def = self.generate_union( - nsid, - &union_name, - &refs, - None, - union.closed, - )?; - unions.push(union_def); - } - } - LexObjectProperty::Array(array) => { - if let LexArrayItem::Union(union) = &array.items { - // Skip single-variant array unions - if union.refs.len() > 1 { - let union_name = self.generate_field_type_name( - nsid, - &struct_name, - field_name, - "Item", - ); - let refs: Vec<_> = union.refs.iter().cloned().collect(); - let union_def = self.generate_union( - nsid, - &union_name, - &refs, - None, - union.closed, - )?; - unions.push(union_def); - } - } - } - _ => {} - } - } + let unions = self.generate_nested_types(nsid, &struct_name, &obj.properties, false)?; Ok(quote! { #struct_def @@ -496,15 +433,8 @@ let (has_default, has_builder) = if is_binary_body { (false, true) } else if let Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) = &body.schema { - use crate::codegen::structs::{ - all_required_are_defaultable_strings, conflicts_with_builder_macro, - count_required_fields, - }; - let required_count = count_required_fields(obj); - let can_default = required_count == 0 || all_required_are_defaultable_strings(obj); - let can_builder = - required_count >= 1 && !can_default && !conflicts_with_builder_macro(type_base); - (can_default, can_builder) + let decision = super::builder_heuristics::should_generate_builder(type_base, obj); + (decision.has_default, decision.has_builder) } else { (false, false) }; @@ -574,46 +504,11 @@ }; // Generate union types if schema is an Object - let mut unions = Vec::new(); - if let Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) = &body.schema { - for (field_name, field_type) in &obj.properties { - match field_type { - LexObjectProperty::Union(union) => { - // Skip empty, single-variant unions unless they're self-referential - if !union.refs.is_empty() - && (union.refs.len() > 1 - || self.is_self_referential_union(nsid, type_base, union)) - { - let union_name = - self.generate_field_type_name(nsid, type_base, field_name, ""); - let refs: Vec<_> = union.refs.iter().cloned().collect(); - let union_def = - self.generate_union(nsid, &union_name, &refs, None, union.closed)?; - unions.push(union_def); - } - } - LexObjectProperty::Array(array) => { - if let LexArrayItem::Union(union) = &array.items { - // Skip single-variant array unions - if union.refs.len() > 1 { - let union_name = self - .generate_field_type_name(nsid, type_base, field_name, "Item"); - let refs: Vec<_> = union.refs.iter().cloned().collect(); - let union_def = self.generate_union( - nsid, - &union_name, - &refs, - None, - union.closed, - )?; - unions.push(union_def); - } - } - } - _ => {} - } - } - } + let unions = if let Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) = &body.schema { + self.generate_nested_types(nsid, type_base, &obj.properties, false)? + } else { + Vec::new() + }; Ok(quote! { #struct_def @@ -645,11 +540,7 @@ // Check if schema is an Object and apply heuristics let has_default = if let Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) = &body.schema { - use crate::codegen::structs::{ - all_required_are_defaultable_strings, count_required_fields, - }; - let required_count = count_required_fields(obj); - required_count == 0 || all_required_are_defaultable_strings(obj) + super::builder_heuristics::should_generate_builder(&struct_name, obj).has_default } else { false }; @@ -688,49 +579,11 @@ }; // Generate union types if schema is an Object - let mut unions = Vec::new(); - if let Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) = &body.schema { - for (field_name, field_type) in &obj.properties { - match field_type { - LexObjectProperty::Union(union) => { - // Skip single-variant unions unless they're self-referential - if union.refs.len() > 1 - || self.is_self_referential_union(nsid, &struct_name, union) - { - let union_name = - self.generate_field_type_name(nsid, &struct_name, field_name, ""); - let refs: Vec<_> = union.refs.iter().cloned().collect(); - let union_def = - self.generate_union(nsid, &union_name, &refs, None, union.closed)?; - unions.push(union_def); - } - } - LexObjectProperty::Array(array) => { - if let LexArrayItem::Union(union) = &array.items { - // Skip single-variant array unions - if union.refs.len() > 1 { - let union_name = self.generate_field_type_name( - nsid, - &struct_name, - field_name, - "Item", - ); - let refs: Vec<_> = union.refs.iter().cloned().collect(); - let union_def = self.generate_union( - nsid, - &union_name, - &refs, - None, - union.closed, - )?; - unions.push(union_def); - } - } - } - _ => {} - } - } - } + let unions = if let Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) = &body.schema { + self.generate_nested_types(nsid, &struct_name, &obj.properties, false)? + } else { + Vec::new() + }; Ok(quote! { #struct_def diff --git a/crates/jacquard-lexicon/src/derive_impl/doc_to_tokens.rs b/crates/jacquard-lexicon/src/derive_impl/doc_to_tokens.rs --- a/crates/jacquard-lexicon/src/derive_impl/doc_to_tokens.rs +++ b/crates/jacquard-lexicon/src/derive_impl/doc_to_tokens.rs @@ -795,8 +795,8 @@ ConstraintCheck::MaxLength { max } => quote! { #[allow(unused_comparisons)] if #len_expr > #max { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: #field_name_literal, + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field(#field_name_literal), max: #max, actual: #len_expr, }); @@ -805,8 +805,8 @@ ConstraintCheck::MinLength { min } => quote! { #[allow(unused_comparisons)] if #len_expr < #min { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: #field_name_literal, + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field(#field_name_literal), min: #min, actual: #len_expr, }); @@ -819,8 +819,8 @@ true ).count(); if count > #max { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: #field_name_literal, + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field(#field_name_literal), max: #max, actual: count, }); @@ -834,8 +834,8 @@ true ).count(); if count < #min { - return Err(::jacquard_lexicon::schema::ValidationError::MinGraphemes { - field: #field_name_literal, + return Err(::jacquard_lexicon::validation::ConstraintError::MinGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field(#field_name_literal), min: #min, actual: count, }); @@ -844,8 +844,8 @@ }, ConstraintCheck::Maximum { max } => quote! { if *value > #max { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: #field_name_literal, + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field(#field_name_literal), max: #max, actual: *value, }); @@ -853,8 +853,8 @@ }, ConstraintCheck::Minimum { min } => quote! { if *value < #min { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: #field_name_literal, + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field(#field_name_literal), min: #min, actual: *value, }); diff --git a/crates/jacquard-lexicon/src/derive_impl/lexicon_schema.rs b/crates/jacquard-lexicon/src/derive_impl/lexicon_schema.rs --- a/crates/jacquard-lexicon/src/derive_impl/lexicon_schema.rs +++ b/crates/jacquard-lexicon/src/derive_impl/lexicon_schema.rs @@ -96,7 +96,7 @@ #doc_tokens } - fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { #validation_tokens } } @@ -150,7 +150,7 @@ #doc_tokens } - fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_blebbit/authr/folder.rs b/crates/jacquard-api/src/app_blebbit/authr/folder.rs --- a/crates/jacquard-api/src/app_blebbit/authr/folder.rs +++ b/crates/jacquard-api/src/app_blebbit/authr/folder.rs @@ -149,7 +149,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -189,7 +189,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_blebbit/authr/group.rs b/crates/jacquard-api/src/app_blebbit/authr/group.rs --- a/crates/jacquard-api/src/app_blebbit/authr/group.rs +++ b/crates/jacquard-api/src/app_blebbit/authr/group.rs @@ -220,7 +220,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -266,7 +266,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_blebbit/authr/page.rs b/crates/jacquard-api/src/app_blebbit/authr/page.rs --- a/crates/jacquard-api/src/app_blebbit/authr/page.rs +++ b/crates/jacquard-api/src/app_blebbit/authr/page.rs @@ -164,7 +164,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -207,7 +207,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_bsky/actor/profile.rs b/crates/jacquard-api/src/app_bsky/actor/profile.rs --- a/crates/jacquard-api/src/app_bsky/actor/profile.rs +++ b/crates/jacquard-api/src/app_bsky/actor/profile.rs @@ -140,12 +140,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -159,8 +161,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 256usize, actual: count, }); @@ -170,8 +174,10 @@ if let Some(ref value) = self.display_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -185,8 +191,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 64usize, actual: count, }); @@ -196,8 +204,10 @@ if let Some(ref value) = self.pronouns { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 200usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "pronouns", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "pronouns", + ), max: 200usize, actual: ::len(value.as_ref()), }); @@ -211,8 +221,10 @@ ) .count(); if count > 20usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "pronouns", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "pronouns", + ), max: 20usize, actual: count, }); diff --git a/crates/jacquard-api/src/app_bsky/actor/status.rs b/crates/jacquard-api/src/app_bsky/actor/status.rs --- a/crates/jacquard-api/src/app_bsky/actor/status.rs +++ b/crates/jacquard-api/src/app_bsky/actor/status.rs @@ -126,11 +126,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.duration_minutes { if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "duration_minutes", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "duration_minutes", + ), min: 1i64, actual: *value, }); diff --git a/crates/jacquard-api/src/app_bsky/embed/external.rs b/crates/jacquard-api/src/app_bsky/embed/external.rs --- a/crates/jacquard-api/src/app_bsky/embed/external.rs +++ b/crates/jacquard-api/src/app_bsky/embed/external.rs @@ -274,7 +274,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -309,7 +309,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -343,7 +343,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -387,7 +387,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_bsky/embed/images.rs b/crates/jacquard-api/src/app_bsky/embed/images.rs --- a/crates/jacquard-api/src/app_bsky/embed/images.rs +++ b/crates/jacquard-api/src/app_bsky/embed/images.rs @@ -258,7 +258,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -292,13 +292,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.images; #[allow(unused_comparisons)] if value.len() > 4usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "images", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "images", + ), max: 4usize, actual: value.len(), }); @@ -337,13 +339,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.images; #[allow(unused_comparisons)] if value.len() > 4usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "images", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "images", + ), max: 4usize, actual: value.len(), }); @@ -394,7 +398,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_bsky/embed/record.rs b/crates/jacquard-api/src/app_bsky/embed/record.rs --- a/crates/jacquard-api/src/app_bsky/embed/record.rs +++ b/crates/jacquard-api/src/app_bsky/embed/record.rs @@ -418,7 +418,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -483,7 +483,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -520,7 +520,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -555,7 +555,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -590,7 +590,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -677,7 +677,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_bsky/embed/record_with_media.rs b/crates/jacquard-api/src/app_bsky/embed/record_with_media.rs --- a/crates/jacquard-api/src/app_bsky/embed/record_with_media.rs +++ b/crates/jacquard-api/src/app_bsky/embed/record_with_media.rs @@ -150,7 +150,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -207,7 +207,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_bsky/embed/video.rs b/crates/jacquard-api/src/app_bsky/embed/video.rs --- a/crates/jacquard-api/src/app_bsky/embed/video.rs +++ b/crates/jacquard-api/src/app_bsky/embed/video.rs @@ -255,7 +255,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -303,12 +303,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.alt { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "alt", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "alt", + ), max: 10000usize, actual: ::len(value.as_ref()), }); @@ -322,8 +324,10 @@ ) .count(); if count > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "alt", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "alt", + ), max: 1000usize, actual: count, }); @@ -333,8 +337,10 @@ if let Some(ref value) = self.captions { #[allow(unused_comparisons)] if value.len() > 20usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "captions", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "captions", + ), max: 20usize, actual: value.len(), }); @@ -387,12 +393,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.alt { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "alt", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "alt", + ), max: 10000usize, actual: ::len(value.as_ref()), }); @@ -406,8 +414,10 @@ ) .count(); if count > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "alt", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "alt", + ), max: 1000usize, actual: count, }); diff --git a/crates/jacquard-api/src/app_bsky/feed/describe_feed_generator.rs b/crates/jacquard-api/src/app_bsky/feed/describe_feed_generator.rs --- a/crates/jacquard-api/src/app_bsky/feed/describe_feed_generator.rs +++ b/crates/jacquard-api/src/app_bsky/feed/describe_feed_generator.rs @@ -137,7 +137,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -175,7 +175,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_bsky/feed/generator.rs b/crates/jacquard-api/src/app_bsky/feed/generator.rs --- a/crates/jacquard-api/src/app_bsky/feed/generator.rs +++ b/crates/jacquard-api/src/app_bsky/feed/generator.rs @@ -125,12 +125,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 3000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 3000usize, actual: ::len(value.as_ref()), }); @@ -144,8 +146,10 @@ ) .count(); if count > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 300usize, actual: count, }); @@ -156,8 +160,10 @@ let value = &self.display_name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 240usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 240usize, actual: ::len(value.as_ref()), }); @@ -172,8 +178,10 @@ ) .count(); if count > 24usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 24usize, actual: count, }); diff --git a/crates/jacquard-api/src/app_bsky/feed/get_likes.rs b/crates/jacquard-api/src/app_bsky/feed/get_likes.rs --- a/crates/jacquard-api/src/app_bsky/feed/get_likes.rs +++ b/crates/jacquard-api/src/app_bsky/feed/get_likes.rs @@ -208,7 +208,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_bsky/feed/like.rs b/crates/jacquard-api/src/app_bsky/feed/like.rs --- a/crates/jacquard-api/src/app_bsky/feed/like.rs +++ b/crates/jacquard-api/src/app_bsky/feed/like.rs @@ -101,7 +101,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_bsky/feed/post.rs b/crates/jacquard-api/src/app_bsky/feed/post.rs --- a/crates/jacquard-api/src/app_bsky/feed/post.rs +++ b/crates/jacquard-api/src/app_bsky/feed/post.rs @@ -388,7 +388,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -545,12 +545,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.langs { #[allow(unused_comparisons)] if value.len() > 3usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "langs", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "langs", + ), max: 3usize, actual: value.len(), }); @@ -559,8 +561,10 @@ if let Some(ref value) = self.tags { #[allow(unused_comparisons)] if value.len() > 8usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "tags", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "tags", + ), max: 8usize, actual: value.len(), }); @@ -570,8 +574,10 @@ let value = &self.text; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 3000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 3000usize, actual: ::len(value.as_ref()), }); @@ -586,8 +592,10 @@ ) .count(); if count > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 300usize, actual: count, }); @@ -629,7 +637,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -664,12 +672,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.end; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "end", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "end", + ), min: 0i64, actual: *value, }); @@ -678,8 +688,10 @@ { let value = &self.start; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "start", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "start", + ), min: 0i64, actual: *value, }); diff --git a/crates/jacquard-api/src/app_bsky/feed/postgate.rs b/crates/jacquard-api/src/app_bsky/feed/postgate.rs --- a/crates/jacquard-api/src/app_bsky/feed/postgate.rs +++ b/crates/jacquard-api/src/app_bsky/feed/postgate.rs @@ -178,7 +178,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -286,12 +286,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.detached_embedding_uris { #[allow(unused_comparisons)] if value.len() > 50usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "detached_embedding_uris", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "detached_embedding_uris", + ), max: 50usize, actual: value.len(), }); @@ -300,8 +302,10 @@ if let Some(ref value) = self.embedding_rules { #[allow(unused_comparisons)] if value.len() > 5usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "embedding_rules", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "embedding_rules", + ), max: 5usize, actual: value.len(), }); diff --git a/crates/jacquard-api/src/app_bsky/feed/repost.rs b/crates/jacquard-api/src/app_bsky/feed/repost.rs --- a/crates/jacquard-api/src/app_bsky/feed/repost.rs +++ b/crates/jacquard-api/src/app_bsky/feed/repost.rs @@ -101,7 +101,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_bsky/feed/threadgate.rs b/crates/jacquard-api/src/app_bsky/feed/threadgate.rs --- a/crates/jacquard-api/src/app_bsky/feed/threadgate.rs +++ b/crates/jacquard-api/src/app_bsky/feed/threadgate.rs @@ -249,7 +249,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -280,7 +280,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -315,7 +315,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -446,12 +446,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.allow { #[allow(unused_comparisons)] if value.len() > 5usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "allow", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "allow", + ), max: 5usize, actual: value.len(), }); @@ -460,8 +462,10 @@ if let Some(ref value) = self.hidden_replies { #[allow(unused_comparisons)] if value.len() > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "hidden_replies", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "hidden_replies", + ), max: 300usize, actual: value.len(), }); @@ -497,7 +501,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_bsky/graph/block.rs b/crates/jacquard-api/src/app_bsky/graph/block.rs --- a/crates/jacquard-api/src/app_bsky/graph/block.rs +++ b/crates/jacquard-api/src/app_bsky/graph/block.rs @@ -98,7 +98,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_bsky/graph/follow.rs b/crates/jacquard-api/src/app_bsky/graph/follow.rs --- a/crates/jacquard-api/src/app_bsky/graph/follow.rs +++ b/crates/jacquard-api/src/app_bsky/graph/follow.rs @@ -97,7 +97,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_bsky/graph/get_lists_with_membership.rs b/crates/jacquard-api/src/app_bsky/graph/get_lists_with_membership.rs --- a/crates/jacquard-api/src/app_bsky/graph/get_lists_with_membership.rs +++ b/crates/jacquard-api/src/app_bsky/graph/get_lists_with_membership.rs @@ -185,7 +185,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_bsky/graph/get_starter_packs_with_membership.rs b/crates/jacquard-api/src/app_bsky/graph/get_starter_packs_with_membership.rs --- a/crates/jacquard-api/src/app_bsky/graph/get_starter_packs_with_membership.rs +++ b/crates/jacquard-api/src/app_bsky/graph/get_starter_packs_with_membership.rs @@ -238,7 +238,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_bsky/graph/list.rs b/crates/jacquard-api/src/app_bsky/graph/list.rs --- a/crates/jacquard-api/src/app_bsky/graph/list.rs +++ b/crates/jacquard-api/src/app_bsky/graph/list.rs @@ -118,12 +118,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 3000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 3000usize, actual: ::len(value.as_ref()), }); @@ -137,8 +139,10 @@ ) .count(); if count > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 300usize, actual: count, }); @@ -149,8 +153,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 64usize, actual: ::len(value.as_ref()), }); @@ -160,8 +166,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), min: 1usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/app_bsky/graph/listblock.rs b/crates/jacquard-api/src/app_bsky/graph/listblock.rs --- a/crates/jacquard-api/src/app_bsky/graph/listblock.rs +++ b/crates/jacquard-api/src/app_bsky/graph/listblock.rs @@ -98,7 +98,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_bsky/graph/listitem.rs b/crates/jacquard-api/src/app_bsky/graph/listitem.rs --- a/crates/jacquard-api/src/app_bsky/graph/listitem.rs +++ b/crates/jacquard-api/src/app_bsky/graph/listitem.rs @@ -101,7 +101,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_bsky/graph/starterpack.rs b/crates/jacquard-api/src/app_bsky/graph/starterpack.rs --- a/crates/jacquard-api/src/app_bsky/graph/starterpack.rs +++ b/crates/jacquard-api/src/app_bsky/graph/starterpack.rs @@ -212,7 +212,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -326,12 +326,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 3000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 3000usize, actual: ::len(value.as_ref()), }); @@ -345,8 +347,10 @@ ) .count(); if count > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 300usize, actual: count, }); @@ -356,8 +360,10 @@ if let Some(ref value) = self.feeds { #[allow(unused_comparisons)] if value.len() > 3usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "feeds", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "feeds", + ), max: 3usize, actual: value.len(), }); @@ -367,8 +373,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 500usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 500usize, actual: ::len(value.as_ref()), }); @@ -378,8 +386,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -394,8 +404,10 @@ ) .count(); if count > 50usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 50usize, actual: count, }); diff --git a/crates/jacquard-api/src/app_bsky/graph/verification.rs b/crates/jacquard-api/src/app_bsky/graph/verification.rs --- a/crates/jacquard-api/src/app_bsky/graph/verification.rs +++ b/crates/jacquard-api/src/app_bsky/graph/verification.rs @@ -106,7 +106,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_bsky/labeler/service.rs b/crates/jacquard-api/src/app_bsky/labeler/service.rs --- a/crates/jacquard-api/src/app_bsky/labeler/service.rs +++ b/crates/jacquard-api/src/app_bsky/labeler/service.rs @@ -116,7 +116,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_bsky/notification/declaration.rs b/crates/jacquard-api/src/app_bsky/notification/declaration.rs --- a/crates/jacquard-api/src/app_bsky/notification/declaration.rs +++ b/crates/jacquard-api/src/app_bsky/notification/declaration.rs @@ -98,7 +98,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_bsky/notification/list_notifications.rs b/crates/jacquard-api/src/app_bsky/notification/list_notifications.rs --- a/crates/jacquard-api/src/app_bsky/notification/list_notifications.rs +++ b/crates/jacquard-api/src/app_bsky/notification/list_notifications.rs @@ -396,7 +396,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_bsky/richtext/facet.rs b/crates/jacquard-api/src/app_bsky/richtext/facet.rs --- a/crates/jacquard-api/src/app_bsky/richtext/facet.rs +++ b/crates/jacquard-api/src/app_bsky/richtext/facet.rs @@ -248,12 +248,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.byte_end; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "byte_end", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "byte_end", + ), min: 0i64, actual: *value, }); @@ -262,8 +264,10 @@ { let value = &self.byte_start; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "byte_start", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "byte_start", + ), min: 0i64, actual: *value, }); @@ -303,7 +307,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -361,7 +365,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -396,7 +400,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -431,13 +435,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.tag; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "tag", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "tag", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -452,8 +458,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "tag", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "tag", + ), max: 64usize, actual: count, }); diff --git a/crates/jacquard-api/src/app_bsky/unspecced/get_config.rs b/crates/jacquard-api/src/app_bsky/unspecced/get_config.rs --- a/crates/jacquard-api/src/app_bsky/unspecced/get_config.rs +++ b/crates/jacquard-api/src/app_bsky/unspecced/get_config.rs @@ -115,7 +115,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_other_v2.rs b/crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_other_v2.rs --- a/crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_other_v2.rs +++ b/crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_other_v2.rs @@ -229,7 +229,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_v2.rs b/crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_v2.rs --- a/crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_v2.rs +++ b/crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_v2.rs @@ -325,7 +325,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_bsky/unspecced/get_tagged_suggestions.rs b/crates/jacquard-api/src/app_bsky/unspecced/get_tagged_suggestions.rs --- a/crates/jacquard-api/src/app_bsky/unspecced/get_tagged_suggestions.rs +++ b/crates/jacquard-api/src/app_bsky/unspecced/get_tagged_suggestions.rs @@ -199,7 +199,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/app_ocho/edu/verification.rs b/crates/jacquard-api/src/app_ocho/edu/verification.rs --- a/crates/jacquard-api/src/app_ocho/edu/verification.rs +++ b/crates/jacquard-api/src/app_ocho/edu/verification.rs @@ -103,7 +103,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_ocho/plugin/service.rs b/crates/jacquard-api/src/app_ocho/plugin/service.rs --- a/crates/jacquard-api/src/app_ocho/plugin/service.rs +++ b/crates/jacquard-api/src/app_ocho/plugin/service.rs @@ -101,7 +101,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/beauty_cybernetic/trustcow/review.rs b/crates/jacquard-api/src/beauty_cybernetic/trustcow/review.rs --- a/crates/jacquard-api/src/beauty_cybernetic/trustcow/review.rs +++ b/crates/jacquard-api/src/beauty_cybernetic/trustcow/review.rs @@ -117,12 +117,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 1000usize, actual: ::len(value.as_ref()), }); @@ -131,8 +133,10 @@ { let value = &self.rating; if *value > 5i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "rating", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "rating", + ), max: 5i64, actual: *value, }); @@ -141,8 +145,10 @@ { let value = &self.rating; if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "rating", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "rating", + ), min: 1i64, actual: *value, }); @@ -151,8 +157,10 @@ if let Some(ref value) = self.title { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 100usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/beauty_cybernetic/trustcow/transaction.rs b/crates/jacquard-api/src/beauty_cybernetic/trustcow/transaction.rs --- a/crates/jacquard-api/src/beauty_cybernetic/trustcow/transaction.rs +++ b/crates/jacquard-api/src/beauty_cybernetic/trustcow/transaction.rs @@ -123,12 +123,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.currency { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "currency", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "currency", + ), max: 10usize, actual: ::len(value.as_ref()), }); @@ -137,8 +139,10 @@ if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 500usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 500usize, actual: ::len(value.as_ref()), }); @@ -148,8 +152,10 @@ let value = &self.transaction_id; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 128usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "transaction_id", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "transaction_id", + ), max: 128usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/beauty_cybernetic/trustcow/warrant.rs b/crates/jacquard-api/src/beauty_cybernetic/trustcow/warrant.rs --- a/crates/jacquard-api/src/beauty_cybernetic/trustcow/warrant.rs +++ b/crates/jacquard-api/src/beauty_cybernetic/trustcow/warrant.rs @@ -119,12 +119,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 300usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/blue__2048/key/game.rs b/crates/jacquard-api/src/blue__2048/key/game.rs --- a/crates/jacquard-api/src/blue__2048/key/game.rs +++ b/crates/jacquard-api/src/blue__2048/key/game.rs @@ -98,7 +98,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/blue__2048/player/profile.rs b/crates/jacquard-api/src/blue__2048/player/profile.rs --- a/crates/jacquard-api/src/blue__2048/player/profile.rs +++ b/crates/jacquard-api/src/blue__2048/player/profile.rs @@ -100,7 +100,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/blue__2048/player/stats.rs b/crates/jacquard-api/src/blue__2048/player/stats.rs --- a/crates/jacquard-api/src/blue__2048/player/stats.rs +++ b/crates/jacquard-api/src/blue__2048/player/stats.rs @@ -112,7 +112,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/blue__2048/verification/game.rs b/crates/jacquard-api/src/blue__2048/verification/game.rs --- a/crates/jacquard-api/src/blue__2048/verification/game.rs +++ b/crates/jacquard-api/src/blue__2048/verification/game.rs @@ -102,7 +102,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/blue__2048/verification/stats.rs b/crates/jacquard-api/src/blue__2048/verification/stats.rs --- a/crates/jacquard-api/src/blue__2048/verification/stats.rs +++ b/crates/jacquard-api/src/blue__2048/verification/stats.rs @@ -102,7 +102,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/blue_rito/feed/bookmark.rs b/crates/jacquard-api/src/blue_rito/feed/bookmark.rs --- a/crates/jacquard-api/src/blue_rito/feed/bookmark.rs +++ b/crates/jacquard-api/src/blue_rito/feed/bookmark.rs @@ -292,12 +292,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.comment { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "comment", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "comment", + ), max: 100000usize, actual: ::len(value.as_ref()), }); @@ -311,8 +313,10 @@ ) .count(); if count > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "comment", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "comment", + ), max: 10000usize, actual: count, }); @@ -323,8 +327,10 @@ let value = &self.lang; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 6usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "lang", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "lang", + ), max: 6usize, actual: ::len(value.as_ref()), }); @@ -334,8 +340,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 500usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 500usize, actual: ::len(value.as_ref()), }); @@ -350,8 +358,10 @@ ) .count(); if count > 50usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 50usize, actual: count, }); @@ -477,13 +487,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.comments; #[allow(unused_comparisons)] if value.len() < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "comments", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "comments", + ), min: 1usize, actual: value.len(), }); @@ -492,8 +504,10 @@ if let Some(ref value) = self.tags { #[allow(unused_comparisons)] if value.len() > 10usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "tags", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "tags", + ), max: 10usize, actual: value.len(), }); diff --git a/crates/jacquard-api/src/blue_rito/feed/like.rs b/crates/jacquard-api/src/blue_rito/feed/like.rs --- a/crates/jacquard-api/src/blue_rito/feed/like.rs +++ b/crates/jacquard-api/src/blue_rito/feed/like.rs @@ -97,7 +97,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/blue_rito/service/get_schema.rs b/crates/jacquard-api/src/blue_rito/service/get_schema.rs --- a/crates/jacquard-api/src/blue_rito/service/get_schema.rs +++ b/crates/jacquard-api/src/blue_rito/service/get_schema.rs @@ -191,7 +191,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/blue_rito/service/schema.rs b/crates/jacquard-api/src/blue_rito/service/schema.rs --- a/crates/jacquard-api/src/blue_rito/service/schema.rs +++ b/crates/jacquard-api/src/blue_rito/service/schema.rs @@ -97,7 +97,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/blue_zio/atfile/finger.rs b/crates/jacquard-api/src/blue_zio/atfile/finger.rs --- a/crates/jacquard-api/src/blue_zio/atfile/finger.rs +++ b/crates/jacquard-api/src/blue_zio/atfile/finger.rs @@ -180,7 +180,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -225,7 +225,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/blue_zio/atfile/lock.rs b/crates/jacquard-api/src/blue_zio/atfile/lock.rs --- a/crates/jacquard-api/src/blue_zio/atfile/lock.rs +++ b/crates/jacquard-api/src/blue_zio/atfile/lock.rs @@ -97,7 +97,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/blue_zio/atfile/meta.rs b/crates/jacquard-api/src/blue_zio/atfile/meta.rs --- a/crates/jacquard-api/src/blue_zio/atfile/meta.rs +++ b/crates/jacquard-api/src/blue_zio/atfile/meta.rs @@ -83,7 +83,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/chat_bsky/actor/declaration.rs b/crates/jacquard-api/src/chat_bsky/actor/declaration.rs --- a/crates/jacquard-api/src/chat_bsky/actor/declaration.rs +++ b/crates/jacquard-api/src/chat_bsky/actor/declaration.rs @@ -97,7 +97,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/chat_bsky/convo/send_message_batch.rs b/crates/jacquard-api/src/chat_bsky/convo/send_message_batch.rs --- a/crates/jacquard-api/src/chat_bsky/convo/send_message_batch.rs +++ b/crates/jacquard-api/src/chat_bsky/convo/send_message_batch.rs @@ -137,7 +137,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/chat_bsky/moderation/get_actor_metadata.rs b/crates/jacquard-api/src/chat_bsky/moderation/get_actor_metadata.rs --- a/crates/jacquard-api/src/chat_bsky/moderation/get_actor_metadata.rs +++ b/crates/jacquard-api/src/chat_bsky/moderation/get_actor_metadata.rs @@ -226,7 +226,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/club_stellz/evm/address_control.rs b/crates/jacquard-api/src/club_stellz/evm/address_control.rs --- a/crates/jacquard-api/src/club_stellz/evm/address_control.rs +++ b/crates/jacquard-api/src/club_stellz/evm/address_control.rs @@ -295,7 +295,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -354,13 +354,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.address; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 42usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "address", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "address", + ), max: 42usize, actual: ::len(value.as_ref()), }); @@ -370,8 +372,10 @@ let value = &self.address; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 42usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "address", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "address", + ), min: 42usize, actual: ::len(value.as_ref()), }); @@ -381,8 +385,10 @@ let value = &self.nonce; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "nonce", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "nonce", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -392,8 +398,10 @@ let value = &self.nonce; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 8usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "nonce", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "nonce", + ), min: 8usize, actual: ::len(value.as_ref()), }); @@ -403,8 +411,10 @@ let value = &self.statement; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 78usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "statement", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "statement", + ), min: 78usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/com_atproto/label/subscribe_labels.rs b/crates/jacquard-api/src/com_atproto/label/subscribe_labels.rs --- a/crates/jacquard-api/src/com_atproto/label/subscribe_labels.rs +++ b/crates/jacquard-api/src/com_atproto/label/subscribe_labels.rs @@ -171,7 +171,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -206,7 +206,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/com_atproto/lexicon/schema.rs b/crates/jacquard-api/src/com_atproto/lexicon/schema.rs --- a/crates/jacquard-api/src/com_atproto/lexicon/schema.rs +++ b/crates/jacquard-api/src/com_atproto/lexicon/schema.rs @@ -96,7 +96,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/com_atproto/moderation/create_report.rs b/crates/jacquard-api/src/com_atproto/moderation/create_report.rs --- a/crates/jacquard-api/src/com_atproto/moderation/create_report.rs +++ b/crates/jacquard-api/src/com_atproto/moderation/create_report.rs @@ -309,7 +309,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/com_atproto/repo/apply_writes.rs b/crates/jacquard-api/src/com_atproto/repo/apply_writes.rs --- a/crates/jacquard-api/src/com_atproto/repo/apply_writes.rs +++ b/crates/jacquard-api/src/com_atproto/repo/apply_writes.rs @@ -506,12 +506,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.rkey { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 512usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "rkey", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "rkey", + ), max: 512usize, actual: ::len(value.as_ref()), }); @@ -556,7 +558,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -595,7 +597,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -625,7 +627,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -829,7 +831,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -869,7 +871,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/com_atproto/repo/list_missing_blobs.rs b/crates/jacquard-api/src/com_atproto/repo/list_missing_blobs.rs --- a/crates/jacquard-api/src/com_atproto/repo/list_missing_blobs.rs +++ b/crates/jacquard-api/src/com_atproto/repo/list_missing_blobs.rs @@ -217,7 +217,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/com_atproto/repo/list_records.rs b/crates/jacquard-api/src/com_atproto/repo/list_records.rs --- a/crates/jacquard-api/src/com_atproto/repo/list_records.rs +++ b/crates/jacquard-api/src/com_atproto/repo/list_records.rs @@ -287,7 +287,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/com_atproto/repo/strong_ref.rs b/crates/jacquard-api/src/com_atproto/repo/strong_ref.rs --- a/crates/jacquard-api/src/com_atproto/repo/strong_ref.rs +++ b/crates/jacquard-api/src/com_atproto/repo/strong_ref.rs @@ -103,7 +103,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/com_atproto/server/create_app_password.rs b/crates/jacquard-api/src/com_atproto/server/create_app_password.rs --- a/crates/jacquard-api/src/com_atproto/server/create_app_password.rs +++ b/crates/jacquard-api/src/com_atproto/server/create_app_password.rs @@ -197,7 +197,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/com_atproto/server/create_invite_codes.rs b/crates/jacquard-api/src/com_atproto/server/create_invite_codes.rs --- a/crates/jacquard-api/src/com_atproto/server/create_invite_codes.rs +++ b/crates/jacquard-api/src/com_atproto/server/create_invite_codes.rs @@ -189,7 +189,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/com_atproto/server/describe_server.rs b/crates/jacquard-api/src/com_atproto/server/describe_server.rs --- a/crates/jacquard-api/src/com_atproto/server/describe_server.rs +++ b/crates/jacquard-api/src/com_atproto/server/describe_server.rs @@ -138,7 +138,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -176,7 +176,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/com_atproto/server/list_app_passwords.rs b/crates/jacquard-api/src/com_atproto/server/list_app_passwords.rs --- a/crates/jacquard-api/src/com_atproto/server/list_app_passwords.rs +++ b/crates/jacquard-api/src/com_atproto/server/list_app_passwords.rs @@ -125,7 +125,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/com_atproto/sync/list_hosts.rs b/crates/jacquard-api/src/com_atproto/sync/list_hosts.rs --- a/crates/jacquard-api/src/com_atproto/sync/list_hosts.rs +++ b/crates/jacquard-api/src/com_atproto/sync/list_hosts.rs @@ -172,7 +172,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/com_atproto/sync/list_repos.rs b/crates/jacquard-api/src/com_atproto/sync/list_repos.rs --- a/crates/jacquard-api/src/com_atproto/sync/list_repos.rs +++ b/crates/jacquard-api/src/com_atproto/sync/list_repos.rs @@ -274,7 +274,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/com_atproto/sync/list_repos_by_collection.rs b/crates/jacquard-api/src/com_atproto/sync/list_repos_by_collection.rs --- a/crates/jacquard-api/src/com_atproto/sync/list_repos_by_collection.rs +++ b/crates/jacquard-api/src/com_atproto/sync/list_repos_by_collection.rs @@ -220,7 +220,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/com_atproto/sync/subscribe_repos.rs b/crates/jacquard-api/src/com_atproto/sync/subscribe_repos.rs --- a/crates/jacquard-api/src/com_atproto/sync/subscribe_repos.rs +++ b/crates/jacquard-api/src/com_atproto/sync/subscribe_repos.rs @@ -675,7 +675,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -737,13 +737,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.ops; #[allow(unused_comparisons)] if value.len() > 200usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "ops", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "ops", + ), max: 200usize, actual: value.len(), }); @@ -790,7 +792,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -827,7 +829,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1027,7 +1029,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1073,7 +1075,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/com_atproto/temp/check_handle_availability.rs b/crates/jacquard-api/src/com_atproto/temp/check_handle_availability.rs --- a/crates/jacquard-api/src/com_atproto/temp/check_handle_availability.rs +++ b/crates/jacquard-api/src/com_atproto/temp/check_handle_availability.rs @@ -370,7 +370,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -408,7 +408,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -446,7 +446,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/com_crabdance/nandi/post.rs b/crates/jacquard-api/src/com_crabdance/nandi/post.rs --- a/crates/jacquard-api/src/com_crabdance/nandi/post.rs +++ b/crates/jacquard-api/src/com_crabdance/nandi/post.rs @@ -119,13 +119,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.content; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "content", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "content", + ), max: 10000usize, actual: ::len(value.as_ref()), }); @@ -135,8 +137,10 @@ let value = &self.content; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "content", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "content", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -145,8 +149,10 @@ if let Some(ref value) = self.summary { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 500usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "summary", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "summary", + ), max: 500usize, actual: ::len(value.as_ref()), }); @@ -155,8 +161,10 @@ if let Some(ref value) = self.tags { #[allow(unused_comparisons)] if value.len() > 10usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "tags", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "tags", + ), max: 10usize, actual: value.len(), }); @@ -166,8 +174,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 200usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 200usize, actual: ::len(value.as_ref()), }); @@ -177,8 +187,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), min: 1usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/com_shinolabs/pinksea/app_view_defs.rs b/crates/jacquard-api/src/com_shinolabs/pinksea/app_view_defs.rs --- a/crates/jacquard-api/src/com_shinolabs/pinksea/app_view_defs.rs +++ b/crates/jacquard-api/src/com_shinolabs/pinksea/app_view_defs.rs @@ -324,7 +324,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -382,12 +382,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.tags { #[allow(unused_comparisons)] if value.len() > 10usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "tags", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "tags", + ), max: 10usize, actual: value.len(), }); @@ -428,7 +430,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/com_shinolabs/pinksea/oekaki.rs b/crates/jacquard-api/src/com_shinolabs/pinksea/oekaki.rs --- a/crates/jacquard-api/src/com_shinolabs/pinksea/oekaki.rs +++ b/crates/jacquard-api/src/com_shinolabs/pinksea/oekaki.rs @@ -220,7 +220,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -257,7 +257,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -369,12 +369,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.tags { #[allow(unused_comparisons)] if value.len() > 10usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "tags", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "tags", + ), max: 10usize, actual: value.len(), }); diff --git a/crates/jacquard-api/src/com_shinolabs/pinksea/profile.rs b/crates/jacquard-api/src/com_shinolabs/pinksea/profile.rs --- a/crates/jacquard-api/src/com_shinolabs/pinksea/profile.rs +++ b/crates/jacquard-api/src/com_shinolabs/pinksea/profile.rs @@ -114,12 +114,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.bio { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2400usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "bio", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "bio", + ), max: 2400usize, actual: ::len(value.as_ref()), }); @@ -133,8 +135,10 @@ ) .count(); if count > 240usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "bio", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "bio", + ), max: 240usize, actual: count, }); @@ -144,8 +148,10 @@ if let Some(ref value) = self.links { #[allow(unused_comparisons)] if value.len() > 5usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "links", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "links", + ), max: 5usize, actual: value.len(), }); @@ -154,8 +160,10 @@ if let Some(ref value) = self.nickname { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "nickname", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "nickname", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -169,8 +177,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "nickname", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "nickname", + ), max: 64usize, actual: count, }); @@ -374,13 +384,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 500usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 500usize, actual: ::len(value.as_ref()), }); @@ -395,8 +407,10 @@ ) .count(); if count > 50usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 50usize, actual: count, }); diff --git a/crates/jacquard-api/src/com_whtwnd/blog/entry.rs b/crates/jacquard-api/src/com_whtwnd/blog/entry.rs --- a/crates/jacquard-api/src/com_whtwnd/blog/entry.rs +++ b/crates/jacquard-api/src/com_whtwnd/blog/entry.rs @@ -129,13 +129,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.content; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "content", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "content", + ), max: 100000usize, actual: ::len(value.as_ref()), }); @@ -144,8 +146,10 @@ if let Some(ref value) = self.subtitle { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "subtitle", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "subtitle", + ), max: 1000usize, actual: ::len(value.as_ref()), }); @@ -154,8 +158,10 @@ if let Some(ref value) = self.title { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 1000usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/community_lexicon/bookmarks/bookmark.rs b/crates/jacquard-api/src/community_lexicon/bookmarks/bookmark.rs --- a/crates/jacquard-api/src/community_lexicon/bookmarks/bookmark.rs +++ b/crates/jacquard-api/src/community_lexicon/bookmarks/bookmark.rs @@ -102,7 +102,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/community_lexicon/calendar/event.rs b/crates/jacquard-api/src/community_lexicon/calendar/event.rs --- a/crates/jacquard-api/src/community_lexicon/calendar/event.rs +++ b/crates/jacquard-api/src/community_lexicon/calendar/event.rs @@ -212,7 +212,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -906,7 +906,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/community_lexicon/calendar/rsvp.rs b/crates/jacquard-api/src/community_lexicon/calendar/rsvp.rs --- a/crates/jacquard-api/src/community_lexicon/calendar/rsvp.rs +++ b/crates/jacquard-api/src/community_lexicon/calendar/rsvp.rs @@ -135,7 +135,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/community_lexicon/interaction/like.rs b/crates/jacquard-api/src/community_lexicon/interaction/like.rs --- a/crates/jacquard-api/src/community_lexicon/interaction/like.rs +++ b/crates/jacquard-api/src/community_lexicon/interaction/like.rs @@ -97,7 +97,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/community_lexicon/location/address.rs b/crates/jacquard-api/src/community_lexicon/location/address.rs --- a/crates/jacquard-api/src/community_lexicon/location/address.rs +++ b/crates/jacquard-api/src/community_lexicon/location/address.rs @@ -204,13 +204,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.country; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "country", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "country", + ), max: 10usize, actual: ::len(value.as_ref()), }); @@ -220,8 +222,10 @@ let value = &self.country; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 2usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "country", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "country", + ), min: 2usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/community_lexicon/location/fsq.rs b/crates/jacquard-api/src/community_lexicon/location/fsq.rs --- a/crates/jacquard-api/src/community_lexicon/location/fsq.rs +++ b/crates/jacquard-api/src/community_lexicon/location/fsq.rs @@ -154,7 +154,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/community_lexicon/location/geo.rs b/crates/jacquard-api/src/community_lexicon/location/geo.rs --- a/crates/jacquard-api/src/community_lexicon/location/geo.rs +++ b/crates/jacquard-api/src/community_lexicon/location/geo.rs @@ -147,7 +147,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/community_lexicon/location/hthree.rs b/crates/jacquard-api/src/community_lexicon/location/hthree.rs --- a/crates/jacquard-api/src/community_lexicon/location/hthree.rs +++ b/crates/jacquard-api/src/community_lexicon/location/hthree.rs @@ -112,7 +112,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/community_lexicon/payments/web_monetization.rs b/crates/jacquard-api/src/community_lexicon/payments/web_monetization.rs --- a/crates/jacquard-api/src/community_lexicon/payments/web_monetization.rs +++ b/crates/jacquard-api/src/community_lexicon/payments/web_monetization.rs @@ -102,7 +102,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/dev_baileytownsend/health/calories.rs b/crates/jacquard-api/src/dev_baileytownsend/health/calories.rs --- a/crates/jacquard-api/src/dev_baileytownsend/health/calories.rs +++ b/crates/jacquard-api/src/dev_baileytownsend/health/calories.rs @@ -97,7 +97,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/dev_baileytownsend/health/rings.rs b/crates/jacquard-api/src/dev_baileytownsend/health/rings.rs --- a/crates/jacquard-api/src/dev_baileytownsend/health/rings.rs +++ b/crates/jacquard-api/src/dev_baileytownsend/health/rings.rs @@ -107,7 +107,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/dev_baileytownsend/health/steps.rs b/crates/jacquard-api/src/dev_baileytownsend/health/steps.rs --- a/crates/jacquard-api/src/dev_baileytownsend/health/steps.rs +++ b/crates/jacquard-api/src/dev_baileytownsend/health/steps.rs @@ -95,7 +95,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/dev_baileytownsend/health/workout.rs b/crates/jacquard-api/src/dev_baileytownsend/health/workout.rs --- a/crates/jacquard-api/src/dev_baileytownsend/health/workout.rs +++ b/crates/jacquard-api/src/dev_baileytownsend/health/workout.rs @@ -111,7 +111,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/dev_ocbwoy3/blueboard/board.rs b/crates/jacquard-api/src/dev_ocbwoy3/blueboard/board.rs --- a/crates/jacquard-api/src/dev_ocbwoy3/blueboard/board.rs +++ b/crates/jacquard-api/src/dev_ocbwoy3/blueboard/board.rs @@ -105,7 +105,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.description; { @@ -115,8 +115,10 @@ ) .count(); if count > 30usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 30usize, actual: count, }); @@ -127,8 +129,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 10usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/dev_ocbwoy3/blueboard/post.rs b/crates/jacquard-api/src/dev_ocbwoy3/blueboard/post.rs --- a/crates/jacquard-api/src/dev_ocbwoy3/blueboard/post.rs +++ b/crates/jacquard-api/src/dev_ocbwoy3/blueboard/post.rs @@ -107,13 +107,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.text; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 1000usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/dev_regnault/webfishing/savefile.rs b/crates/jacquard-api/src/dev_regnault/webfishing/savefile.rs --- a/crates/jacquard-api/src/dev_regnault/webfishing/savefile.rs +++ b/crates/jacquard-api/src/dev_regnault/webfishing/savefile.rs @@ -99,7 +99,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/fm_teal/alpha/actor.rs b/crates/jacquard-api/src/fm_teal/alpha/actor.rs --- a/crates/jacquard-api/src/fm_teal/alpha/actor.rs +++ b/crates/jacquard-api/src/fm_teal/alpha/actor.rs @@ -380,7 +380,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -448,7 +448,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -490,7 +490,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/fm_teal/alpha/feed.rs b/crates/jacquard-api/src/fm_teal/alpha/feed.rs --- a/crates/jacquard-api/src/fm_teal/alpha/feed.rs +++ b/crates/jacquard-api/src/fm_teal/alpha/feed.rs @@ -372,13 +372,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.artist_name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "artist_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "artist_name", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -388,8 +390,10 @@ let value = &self.artist_name; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "artist_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "artist_name", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -404,8 +408,10 @@ ) .count(); if count > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "artist_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "artist_name", + ), max: 2560usize, actual: count, }); @@ -498,12 +504,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.release_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "release_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "release_name", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -517,8 +525,10 @@ ) .count(); if count > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "release_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "release_name", + ), max: 2560usize, actual: count, }); @@ -528,8 +538,10 @@ if let Some(ref value) = self.submission_client_agent { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "submission_client_agent", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "submission_client_agent", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -543,8 +555,10 @@ ) .count(); if count > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "submission_client_agent", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "submission_client_agent", + ), max: 2560usize, actual: count, }); @@ -555,8 +569,10 @@ let value = &self.track_name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "track_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "track_name", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -566,8 +582,10 @@ let value = &self.track_name; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "track_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "track_name", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -582,8 +600,10 @@ ) .count(); if count > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "track_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "track_name", + ), max: 2560usize, actual: count, }); diff --git a/crates/jacquard-api/src/fm_teal/alpha/stats.rs b/crates/jacquard-api/src/fm_teal/alpha/stats.rs --- a/crates/jacquard-api/src/fm_teal/alpha/stats.rs +++ b/crates/jacquard-api/src/fm_teal/alpha/stats.rs @@ -269,7 +269,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -311,7 +311,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -353,7 +353,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/fyi_frontpage/feed/comment.rs b/crates/jacquard-api/src/fyi_frontpage/feed/comment.rs --- a/crates/jacquard-api/src/fyi_frontpage/feed/comment.rs +++ b/crates/jacquard-api/src/fyi_frontpage/feed/comment.rs @@ -105,13 +105,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.blocks; #[allow(unused_comparisons)] if value.len() > 50usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "blocks", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "blocks", + ), max: 50usize, actual: value.len(), }); diff --git a/crates/jacquard-api/src/fyi_frontpage/feed/post.rs b/crates/jacquard-api/src/fyi_frontpage/feed/post.rs --- a/crates/jacquard-api/src/fyi_frontpage/feed/post.rs +++ b/crates/jacquard-api/src/fyi_frontpage/feed/post.rs @@ -105,13 +105,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 3000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 3000usize, actual: ::len(value.as_ref()), }); @@ -126,8 +128,10 @@ ) .count(); if count > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 300usize, actual: count, }); @@ -296,7 +300,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/fyi_frontpage/feed/vote.rs b/crates/jacquard-api/src/fyi_frontpage/feed/vote.rs --- a/crates/jacquard-api/src/fyi_frontpage/feed/vote.rs +++ b/crates/jacquard-api/src/fyi_frontpage/feed/vote.rs @@ -99,7 +99,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/fyi_frontpage/richtext/block.rs b/crates/jacquard-api/src/fyi_frontpage/richtext/block.rs --- a/crates/jacquard-api/src/fyi_frontpage/richtext/block.rs +++ b/crates/jacquard-api/src/fyi_frontpage/richtext/block.rs @@ -104,7 +104,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -138,13 +138,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.text; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 100000usize, actual: ::len(value.as_ref()), }); @@ -159,8 +161,10 @@ ) .count(); if count > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 10000usize, actual: count, }); diff --git a/crates/jacquard-api/src/fyi_unravel/frontpage/comment.rs b/crates/jacquard-api/src/fyi_unravel/frontpage/comment.rs --- a/crates/jacquard-api/src/fyi_unravel/frontpage/comment.rs +++ b/crates/jacquard-api/src/fyi_unravel/frontpage/comment.rs @@ -106,13 +106,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.content; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "content", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "content", + ), max: 100000usize, actual: ::len(value.as_ref()), }); @@ -127,8 +129,10 @@ ) .count(); if count > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "content", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "content", + ), max: 10000usize, actual: count, }); diff --git a/crates/jacquard-api/src/fyi_unravel/frontpage/post.rs b/crates/jacquard-api/src/fyi_unravel/frontpage/post.rs --- a/crates/jacquard-api/src/fyi_unravel/frontpage/post.rs +++ b/crates/jacquard-api/src/fyi_unravel/frontpage/post.rs @@ -103,13 +103,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 3000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 3000usize, actual: ::len(value.as_ref()), }); @@ -124,8 +126,10 @@ ) .count(); if count > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 300usize, actual: count, }); diff --git a/crates/jacquard-api/src/fyi_unravel/frontpage/vote.rs b/crates/jacquard-api/src/fyi_unravel/frontpage/vote.rs --- a/crates/jacquard-api/src/fyi_unravel/frontpage/vote.rs +++ b/crates/jacquard-api/src/fyi_unravel/frontpage/vote.rs @@ -98,7 +98,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/moe_karashiiro/kpaste/paste.rs b/crates/jacquard-api/src/moe_karashiiro/kpaste/paste.rs --- a/crates/jacquard-api/src/moe_karashiiro/kpaste/paste.rs +++ b/crates/jacquard-api/src/moe_karashiiro/kpaste/paste.rs @@ -112,12 +112,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.language { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 50usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "language", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "language", + ), max: 50usize, actual: ::len(value.as_ref()), }); @@ -126,8 +128,10 @@ if let Some(ref value) = self.title { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 200usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 200usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/net_anisota/feed/draft.rs b/crates/jacquard-api/src/net_anisota/feed/draft.rs --- a/crates/jacquard-api/src/net_anisota/feed/draft.rs +++ b/crates/jacquard-api/src/net_anisota/feed/draft.rs @@ -156,12 +156,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.langs { #[allow(unused_comparisons)] if value.len() > 3usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "langs", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "langs", + ), max: 3usize, actual: value.len(), }); @@ -170,8 +172,10 @@ if let Some(ref value) = self.tags { #[allow(unused_comparisons)] if value.len() > 8usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "tags", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "tags", + ), max: 8usize, actual: value.len(), }); @@ -181,8 +185,10 @@ let value = &self.text; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 3000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 3000usize, actual: ::len(value.as_ref()), }); @@ -197,8 +203,10 @@ ) .count(); if count > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 300usize, actual: count, }); @@ -485,7 +493,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/net_anisota/feed/like.rs b/crates/jacquard-api/src/net_anisota/feed/like.rs --- a/crates/jacquard-api/src/net_anisota/feed/like.rs +++ b/crates/jacquard-api/src/net_anisota/feed/like.rs @@ -99,7 +99,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/net_anisota/feed/list.rs b/crates/jacquard-api/src/net_anisota/feed/list.rs --- a/crates/jacquard-api/src/net_anisota/feed/list.rs +++ b/crates/jacquard-api/src/net_anisota/feed/list.rs @@ -115,12 +115,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 300usize, actual: ::len(value.as_ref()), }); @@ -130,8 +132,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 64usize, actual: ::len(value.as_ref()), }); @@ -140,8 +144,10 @@ if let Some(ref value) = self.tags { #[allow(unused_comparisons)] if value.len() > 10usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "tags", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "tags", + ), max: 10usize, actual: value.len(), }); diff --git a/crates/jacquard-api/src/net_anisota/feed/list_item.rs b/crates/jacquard-api/src/net_anisota/feed/list_item.rs --- a/crates/jacquard-api/src/net_anisota/feed/list_item.rs +++ b/crates/jacquard-api/src/net_anisota/feed/list_item.rs @@ -102,7 +102,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/net_anisota/feed/post.rs b/crates/jacquard-api/src/net_anisota/feed/post.rs --- a/crates/jacquard-api/src/net_anisota/feed/post.rs +++ b/crates/jacquard-api/src/net_anisota/feed/post.rs @@ -152,12 +152,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.langs { #[allow(unused_comparisons)] if value.len() > 3usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "langs", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "langs", + ), max: 3usize, actual: value.len(), }); @@ -166,8 +168,10 @@ if let Some(ref value) = self.tags { #[allow(unused_comparisons)] if value.len() > 8usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "tags", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "tags", + ), max: 8usize, actual: value.len(), }); @@ -177,8 +181,10 @@ let value = &self.text; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 3000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 3000usize, actual: ::len(value.as_ref()), }); @@ -193,8 +199,10 @@ ) .count(); if count > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 300usize, actual: count, }); @@ -458,7 +466,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/net_anisota/feed/repost.rs b/crates/jacquard-api/src/net_anisota/feed/repost.rs --- a/crates/jacquard-api/src/net_anisota/feed/repost.rs +++ b/crates/jacquard-api/src/net_anisota/feed/repost.rs @@ -99,7 +99,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/net_anisota/graph/list_mute.rs b/crates/jacquard-api/src/net_anisota/graph/list_mute.rs --- a/crates/jacquard-api/src/net_anisota/graph/list_mute.rs +++ b/crates/jacquard-api/src/net_anisota/graph/list_mute.rs @@ -260,7 +260,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -378,12 +378,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.reason { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "reason", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "reason", + ), max: 300usize, actual: ::len(value.as_ref()), }); @@ -392,8 +394,10 @@ if let Some(ref value) = self.target_feeds { #[allow(unused_comparisons)] if value.len() > 50usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "target_feeds", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "target_feeds", + ), max: 50usize, actual: value.len(), }); diff --git a/crates/jacquard-api/src/net_anisota/graph/mute.rs b/crates/jacquard-api/src/net_anisota/graph/mute.rs --- a/crates/jacquard-api/src/net_anisota/graph/mute.rs +++ b/crates/jacquard-api/src/net_anisota/graph/mute.rs @@ -260,7 +260,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -378,12 +378,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.reason { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "reason", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "reason", + ), max: 300usize, actual: ::len(value.as_ref()), }); @@ -392,8 +394,10 @@ if let Some(ref value) = self.target_feeds { #[allow(unused_comparisons)] if value.len() > 50usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "target_feeds", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "target_feeds", + ), max: 50usize, actual: value.len(), }); diff --git a/crates/jacquard-api/src/net_bnewbold/demo/mushies.rs b/crates/jacquard-api/src/net_bnewbold/demo/mushies.rs --- a/crates/jacquard-api/src/net_bnewbold/demo/mushies.rs +++ b/crates/jacquard-api/src/net_bnewbold/demo/mushies.rs @@ -104,13 +104,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.common_name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "common_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "common_name", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -125,8 +127,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "common_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "common_name", + ), max: 256usize, actual: count, }); @@ -136,8 +140,10 @@ if let Some(ref value) = self.species { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "species", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "species", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -151,8 +157,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "species", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "species", + ), max: 256usize, actual: count, }); diff --git a/crates/jacquard-api/src/net_bnewbold/demo/mushroom.rs b/crates/jacquard-api/src/net_bnewbold/demo/mushroom.rs --- a/crates/jacquard-api/src/net_bnewbold/demo/mushroom.rs +++ b/crates/jacquard-api/src/net_bnewbold/demo/mushroom.rs @@ -104,13 +104,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.common_name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "common_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "common_name", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -125,8 +127,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "common_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "common_name", + ), max: 256usize, actual: count, }); @@ -136,8 +140,10 @@ if let Some(ref value) = self.species { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "species", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "species", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -151,8 +157,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "species", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "species", + ), max: 256usize, actual: count, }); diff --git a/crates/jacquard-api/src/net_mmatt/right/now.rs b/crates/jacquard-api/src/net_mmatt/right/now.rs --- a/crates/jacquard-api/src/net_mmatt/right/now.rs +++ b/crates/jacquard-api/src/net_mmatt/right/now.rs @@ -105,7 +105,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/net_mmatt/vitals/car.rs b/crates/jacquard-api/src/net_mmatt/vitals/car.rs --- a/crates/jacquard-api/src/net_mmatt/vitals/car.rs +++ b/crates/jacquard-api/src/net_mmatt/vitals/car.rs @@ -121,7 +121,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/network_slices/actor/profile.rs b/crates/jacquard-api/src/network_slices/actor/profile.rs --- a/crates/jacquard-api/src/network_slices/actor/profile.rs +++ b/crates/jacquard-api/src/network_slices/actor/profile.rs @@ -111,12 +111,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -130,8 +132,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 256usize, actual: count, }); @@ -141,8 +145,10 @@ if let Some(ref value) = self.display_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -156,8 +162,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 64usize, actual: count, }); diff --git a/crates/jacquard-api/src/network_slices/slice/get_actors.rs b/crates/jacquard-api/src/network_slices/slice/get_actors.rs --- a/crates/jacquard-api/src/network_slices/slice/get_actors.rs +++ b/crates/jacquard-api/src/network_slices/slice/get_actors.rs @@ -250,7 +250,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/network_slices/slice/get_job_logs.rs b/crates/jacquard-api/src/network_slices/slice/get_job_logs.rs --- a/crates/jacquard-api/src/network_slices/slice/get_job_logs.rs +++ b/crates/jacquard-api/src/network_slices/slice/get_job_logs.rs @@ -307,7 +307,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/network_slices/slice/get_job_status.rs b/crates/jacquard-api/src/network_slices/slice/get_job_status.rs --- a/crates/jacquard-api/src/network_slices/slice/get_job_status.rs +++ b/crates/jacquard-api/src/network_slices/slice/get_job_status.rs @@ -387,7 +387,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -493,7 +493,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/network_slices/slice/get_o_auth_clients.rs b/crates/jacquard-api/src/network_slices/slice/get_o_auth_clients.rs --- a/crates/jacquard-api/src/network_slices/slice/get_o_auth_clients.rs +++ b/crates/jacquard-api/src/network_slices/slice/get_o_auth_clients.rs @@ -516,7 +516,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/network_slices/slice/get_slice_records.rs b/crates/jacquard-api/src/network_slices/slice/get_slice_records.rs --- a/crates/jacquard-api/src/network_slices/slice/get_slice_records.rs +++ b/crates/jacquard-api/src/network_slices/slice/get_slice_records.rs @@ -295,7 +295,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/network_slices/slice/get_sparklines.rs b/crates/jacquard-api/src/network_slices/slice/get_sparklines.rs --- a/crates/jacquard-api/src/network_slices/slice/get_sparklines.rs +++ b/crates/jacquard-api/src/network_slices/slice/get_sparklines.rs @@ -287,7 +287,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/network_slices/slice/get_sync_summary.rs b/crates/jacquard-api/src/network_slices/slice/get_sync_summary.rs --- a/crates/jacquard-api/src/network_slices/slice/get_sync_summary.rs +++ b/crates/jacquard-api/src/network_slices/slice/get_sync_summary.rs @@ -217,7 +217,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/network_slices/slice/stats.rs b/crates/jacquard-api/src/network_slices/slice/stats.rs --- a/crates/jacquard-api/src/network_slices/slice/stats.rs +++ b/crates/jacquard-api/src/network_slices/slice/stats.rs @@ -162,7 +162,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/network_slices/waitlist/invite.rs b/crates/jacquard-api/src/network_slices/waitlist/invite.rs --- a/crates/jacquard-api/src/network_slices/waitlist/invite.rs +++ b/crates/jacquard-api/src/network_slices/waitlist/invite.rs @@ -106,7 +106,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/network_slices/waitlist/request.rs b/crates/jacquard-api/src/network_slices/waitlist/request.rs --- a/crates/jacquard-api/src/network_slices/waitlist/request.rs +++ b/crates/jacquard-api/src/network_slices/waitlist/request.rs @@ -99,7 +99,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/org_devcon/event/test.rs b/crates/jacquard-api/src/org_devcon/event/test.rs --- a/crates/jacquard-api/src/org_devcon/event/test.rs +++ b/crates/jacquard-api/src/org_devcon/event/test.rs @@ -119,7 +119,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/org_robocracy/demo/fungus.rs b/crates/jacquard-api/src/org_robocracy/demo/fungus.rs --- a/crates/jacquard-api/src/org_robocracy/demo/fungus.rs +++ b/crates/jacquard-api/src/org_robocracy/demo/fungus.rs @@ -104,13 +104,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.common_name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "common_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "common_name", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -125,8 +127,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "common_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "common_name", + ), max: 256usize, actual: count, }); @@ -136,8 +140,10 @@ if let Some(ref value) = self.species { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "species", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "species", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -151,8 +157,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "species", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "species", + ), max: 256usize, actual: count, }); diff --git a/crates/jacquard-api/src/org_robocracy/demo/mushies.rs b/crates/jacquard-api/src/org_robocracy/demo/mushies.rs --- a/crates/jacquard-api/src/org_robocracy/demo/mushies.rs +++ b/crates/jacquard-api/src/org_robocracy/demo/mushies.rs @@ -104,13 +104,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.common_name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "common_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "common_name", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -125,8 +127,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "common_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "common_name", + ), max: 256usize, actual: count, }); @@ -136,8 +140,10 @@ if let Some(ref value) = self.species { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "species", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "species", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -151,8 +157,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "species", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "species", + ), max: 256usize, actual: count, }); diff --git a/crates/jacquard-api/src/place_stream/broadcast/origin.rs b/crates/jacquard-api/src/place_stream/broadcast/origin.rs --- a/crates/jacquard-api/src/place_stream/broadcast/origin.rs +++ b/crates/jacquard-api/src/place_stream/broadcast/origin.rs @@ -112,12 +112,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.iroh_ticket { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2048usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "iroh_ticket", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "iroh_ticket", + ), max: 2048usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/place_stream/broadcast/syndication.rs b/crates/jacquard-api/src/place_stream/broadcast/syndication.rs --- a/crates/jacquard-api/src/place_stream/broadcast/syndication.rs +++ b/crates/jacquard-api/src/place_stream/broadcast/syndication.rs @@ -102,7 +102,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/place_stream/chat/gate.rs b/crates/jacquard-api/src/place_stream/chat/gate.rs --- a/crates/jacquard-api/src/place_stream/chat/gate.rs +++ b/crates/jacquard-api/src/place_stream/chat/gate.rs @@ -97,7 +97,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/place_stream/chat/message.rs b/crates/jacquard-api/src/place_stream/chat/message.rs --- a/crates/jacquard-api/src/place_stream/chat/message.rs +++ b/crates/jacquard-api/src/place_stream/chat/message.rs @@ -112,13 +112,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.text; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 3000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 3000usize, actual: ::len(value.as_ref()), }); @@ -133,8 +135,10 @@ ) .count(); if count > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 300usize, actual: count, }); @@ -344,7 +348,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/place_stream/chat/profile.rs b/crates/jacquard-api/src/place_stream/chat/profile.rs --- a/crates/jacquard-api/src/place_stream/chat/profile.rs +++ b/crates/jacquard-api/src/place_stream/chat/profile.rs @@ -135,12 +135,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.blue; if *value > 255i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "blue", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "blue", + ), max: 255i64, actual: *value, }); @@ -149,8 +151,10 @@ { let value = &self.blue; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "blue", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "blue", + ), min: 0i64, actual: *value, }); @@ -159,8 +163,10 @@ { let value = &self.green; if *value > 255i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "green", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "green", + ), max: 255i64, actual: *value, }); @@ -169,8 +175,10 @@ { let value = &self.green; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "green", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "green", + ), min: 0i64, actual: *value, }); @@ -179,8 +187,10 @@ { let value = &self.red; if *value > 255i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "red", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "red", + ), max: 255i64, actual: *value, }); @@ -189,8 +199,10 @@ { let value = &self.red; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "red", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "red", + ), min: 0i64, actual: *value, }); @@ -293,7 +305,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/place_stream/metadata/configuration.rs b/crates/jacquard-api/src/place_stream/metadata/configuration.rs --- a/crates/jacquard-api/src/place_stream/metadata/configuration.rs +++ b/crates/jacquard-api/src/place_stream/metadata/configuration.rs @@ -112,7 +112,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/place_stream/metadata/content_rights.rs b/crates/jacquard-api/src/place_stream/metadata/content_rights.rs --- a/crates/jacquard-api/src/place_stream/metadata/content_rights.rs +++ b/crates/jacquard-api/src/place_stream/metadata/content_rights.rs @@ -369,7 +369,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/place_stream/metadata/content_warnings.rs b/crates/jacquard-api/src/place_stream/metadata/content_warnings.rs --- a/crates/jacquard-api/src/place_stream/metadata/content_warnings.rs +++ b/crates/jacquard-api/src/place_stream/metadata/content_warnings.rs @@ -258,7 +258,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/place_stream/metadata/distribution_policy.rs b/crates/jacquard-api/src/place_stream/metadata/distribution_policy.rs --- a/crates/jacquard-api/src/place_stream/metadata/distribution_policy.rs +++ b/crates/jacquard-api/src/place_stream/metadata/distribution_policy.rs @@ -113,7 +113,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/place_stream/richtext/facet.rs b/crates/jacquard-api/src/place_stream/richtext/facet.rs --- a/crates/jacquard-api/src/place_stream/richtext/facet.rs +++ b/crates/jacquard-api/src/place_stream/richtext/facet.rs @@ -118,7 +118,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/place_stream/server/settings.rs b/crates/jacquard-api/src/place_stream/server/settings.rs --- a/crates/jacquard-api/src/place_stream/server/settings.rs +++ b/crates/jacquard-api/src/place_stream/server/settings.rs @@ -98,7 +98,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/pub_leaflet/blocks/blockquote.rs b/crates/jacquard-api/src/pub_leaflet/blocks/blockquote.rs --- a/crates/jacquard-api/src/pub_leaflet/blocks/blockquote.rs +++ b/crates/jacquard-api/src/pub_leaflet/blocks/blockquote.rs @@ -100,7 +100,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/pub_leaflet/blocks/bsky_post.rs b/crates/jacquard-api/src/pub_leaflet/blocks/bsky_post.rs --- a/crates/jacquard-api/src/pub_leaflet/blocks/bsky_post.rs +++ b/crates/jacquard-api/src/pub_leaflet/blocks/bsky_post.rs @@ -73,7 +73,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/pub_leaflet/blocks/code.rs b/crates/jacquard-api/src/pub_leaflet/blocks/code.rs --- a/crates/jacquard-api/src/pub_leaflet/blocks/code.rs +++ b/crates/jacquard-api/src/pub_leaflet/blocks/code.rs @@ -121,7 +121,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/pub_leaflet/blocks/header.rs b/crates/jacquard-api/src/pub_leaflet/blocks/header.rs --- a/crates/jacquard-api/src/pub_leaflet/blocks/header.rs +++ b/crates/jacquard-api/src/pub_leaflet/blocks/header.rs @@ -113,11 +113,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.level { if *value > 6i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "level", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "level", + ), max: 6i64, actual: *value, }); @@ -125,8 +127,10 @@ } if let Some(ref value) = self.level { if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "level", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "level", + ), min: 1i64, actual: *value, }); diff --git a/crates/jacquard-api/src/pub_leaflet/blocks/horizontal_rule.rs b/crates/jacquard-api/src/pub_leaflet/blocks/horizontal_rule.rs --- a/crates/jacquard-api/src/pub_leaflet/blocks/horizontal_rule.rs +++ b/crates/jacquard-api/src/pub_leaflet/blocks/horizontal_rule.rs @@ -58,7 +58,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/pub_leaflet/blocks/iframe.rs b/crates/jacquard-api/src/pub_leaflet/blocks/iframe.rs --- a/crates/jacquard-api/src/pub_leaflet/blocks/iframe.rs +++ b/crates/jacquard-api/src/pub_leaflet/blocks/iframe.rs @@ -95,11 +95,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.height { if *value > 1600i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "height", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "height", + ), max: 1600i64, actual: *value, }); @@ -107,8 +109,10 @@ } if let Some(ref value) = self.height { if *value < 16i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "height", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "height", + ), min: 16i64, actual: *value, }); diff --git a/crates/jacquard-api/src/pub_leaflet/blocks/image.rs b/crates/jacquard-api/src/pub_leaflet/blocks/image.rs --- a/crates/jacquard-api/src/pub_leaflet/blocks/image.rs +++ b/crates/jacquard-api/src/pub_leaflet/blocks/image.rs @@ -143,7 +143,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -184,7 +184,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/pub_leaflet/blocks/math.rs b/crates/jacquard-api/src/pub_leaflet/blocks/math.rs --- a/crates/jacquard-api/src/pub_leaflet/blocks/math.rs +++ b/crates/jacquard-api/src/pub_leaflet/blocks/math.rs @@ -79,7 +79,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/pub_leaflet/blocks/page.rs b/crates/jacquard-api/src/pub_leaflet/blocks/page.rs --- a/crates/jacquard-api/src/pub_leaflet/blocks/page.rs +++ b/crates/jacquard-api/src/pub_leaflet/blocks/page.rs @@ -79,7 +79,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/pub_leaflet/blocks/poll.rs b/crates/jacquard-api/src/pub_leaflet/blocks/poll.rs --- a/crates/jacquard-api/src/pub_leaflet/blocks/poll.rs +++ b/crates/jacquard-api/src/pub_leaflet/blocks/poll.rs @@ -73,7 +73,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/pub_leaflet/blocks/text.rs b/crates/jacquard-api/src/pub_leaflet/blocks/text.rs --- a/crates/jacquard-api/src/pub_leaflet/blocks/text.rs +++ b/crates/jacquard-api/src/pub_leaflet/blocks/text.rs @@ -100,7 +100,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/pub_leaflet/blocks/unordered_list.rs b/crates/jacquard-api/src/pub_leaflet/blocks/unordered_list.rs --- a/crates/jacquard-api/src/pub_leaflet/blocks/unordered_list.rs +++ b/crates/jacquard-api/src/pub_leaflet/blocks/unordered_list.rs @@ -142,7 +142,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -176,7 +176,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/pub_leaflet/blocks/website.rs b/crates/jacquard-api/src/pub_leaflet/blocks/website.rs --- a/crates/jacquard-api/src/pub_leaflet/blocks/website.rs +++ b/crates/jacquard-api/src/pub_leaflet/blocks/website.rs @@ -135,7 +135,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/pub_leaflet/graph/subscription.rs b/crates/jacquard-api/src/pub_leaflet/graph/subscription.rs --- a/crates/jacquard-api/src/pub_leaflet/graph/subscription.rs +++ b/crates/jacquard-api/src/pub_leaflet/graph/subscription.rs @@ -96,7 +96,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/pub_leaflet/pages/canvas.rs b/crates/jacquard-api/src/pub_leaflet/pages/canvas.rs --- a/crates/jacquard-api/src/pub_leaflet/pages/canvas.rs +++ b/crates/jacquard-api/src/pub_leaflet/pages/canvas.rs @@ -330,7 +330,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -368,7 +368,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -402,7 +402,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -438,7 +438,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/pub_leaflet/pages/linear_document.rs b/crates/jacquard-api/src/pub_leaflet/pages/linear_document.rs --- a/crates/jacquard-api/src/pub_leaflet/pages/linear_document.rs +++ b/crates/jacquard-api/src/pub_leaflet/pages/linear_document.rs @@ -285,7 +285,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -323,7 +323,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -357,7 +357,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -393,7 +393,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/pub_leaflet/poll/definition.rs b/crates/jacquard-api/src/pub_leaflet/poll/definition.rs --- a/crates/jacquard-api/src/pub_leaflet/poll/definition.rs +++ b/crates/jacquard-api/src/pub_leaflet/poll/definition.rs @@ -102,13 +102,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 500usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 500usize, actual: ::len(value.as_ref()), }); @@ -123,8 +125,10 @@ ) .count(); if count > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 100usize, actual: count, }); @@ -276,12 +280,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.text { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 500usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 500usize, actual: ::len(value.as_ref()), }); @@ -295,8 +301,10 @@ ) .count(); if count > 50usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "text", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "text", + ), max: 50usize, actual: count, }); diff --git a/crates/jacquard-api/src/pub_leaflet/poll/vote.rs b/crates/jacquard-api/src/pub_leaflet/poll/vote.rs --- a/crates/jacquard-api/src/pub_leaflet/poll/vote.rs +++ b/crates/jacquard-api/src/pub_leaflet/poll/vote.rs @@ -98,7 +98,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/pub_leaflet/richtext/facet.rs b/crates/jacquard-api/src/pub_leaflet/richtext/facet.rs --- a/crates/jacquard-api/src/pub_leaflet/richtext/facet.rs +++ b/crates/jacquard-api/src/pub_leaflet/richtext/facet.rs @@ -311,7 +311,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -346,12 +346,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.byte_end; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "byte_end", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "byte_end", + ), min: 0i64, actual: *value, }); @@ -360,8 +362,10 @@ { let value = &self.byte_start; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "byte_start", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "byte_start", + ), min: 0i64, actual: *value, }); @@ -397,7 +401,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -428,7 +432,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -464,7 +468,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -495,7 +499,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -530,7 +534,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -598,7 +602,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -629,7 +633,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -660,7 +664,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/pub_leaflet/theme/background_image.rs b/crates/jacquard-api/src/pub_leaflet/theme/background_image.rs --- a/crates/jacquard-api/src/pub_leaflet/theme/background_image.rs +++ b/crates/jacquard-api/src/pub_leaflet/theme/background_image.rs @@ -97,7 +97,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/pub_leaflet/theme/color.rs b/crates/jacquard-api/src/pub_leaflet/theme/color.rs --- a/crates/jacquard-api/src/pub_leaflet/theme/color.rs +++ b/crates/jacquard-api/src/pub_leaflet/theme/color.rs @@ -166,12 +166,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.b; if *value > 255i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "b", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "b", + ), max: 255i64, actual: *value, }); @@ -180,8 +182,10 @@ { let value = &self.b; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "b", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "b", + ), min: 0i64, actual: *value, }); @@ -190,8 +194,10 @@ { let value = &self.g; if *value > 255i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "g", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "g", + ), max: 255i64, actual: *value, }); @@ -200,8 +206,10 @@ { let value = &self.g; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "g", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "g", + ), min: 0i64, actual: *value, }); @@ -210,8 +218,10 @@ { let value = &self.r; if *value > 255i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "r", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "r", + ), max: 255i64, actual: *value, }); @@ -220,8 +230,10 @@ { let value = &self.r; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "r", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "r", + ), min: 0i64, actual: *value, }); @@ -262,12 +274,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.a; if *value > 100i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "a", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "a", + ), max: 100i64, actual: *value, }); @@ -276,8 +290,10 @@ { let value = &self.a; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "a", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "a", + ), min: 0i64, actual: *value, }); @@ -286,8 +302,10 @@ { let value = &self.b; if *value > 255i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "b", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "b", + ), max: 255i64, actual: *value, }); @@ -296,8 +314,10 @@ { let value = &self.b; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "b", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "b", + ), min: 0i64, actual: *value, }); @@ -306,8 +326,10 @@ { let value = &self.g; if *value > 255i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "g", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "g", + ), max: 255i64, actual: *value, }); @@ -316,8 +338,10 @@ { let value = &self.g; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "g", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "g", + ), min: 0i64, actual: *value, }); @@ -326,8 +350,10 @@ { let value = &self.r; if *value > 255i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Maximum { - field: "r", + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "r", + ), max: 255i64, actual: *value, }); @@ -336,8 +362,10 @@ { let value = &self.r; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "r", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "r", + ), min: 0i64, actual: *value, }); diff --git a/crates/jacquard-api/src/sh_tangled/actor/profile.rs b/crates/jacquard-api/src/sh_tangled/actor/profile.rs --- a/crates/jacquard-api/src/sh_tangled/actor/profile.rs +++ b/crates/jacquard-api/src/sh_tangled/actor/profile.rs @@ -119,12 +119,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -138,8 +140,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 256usize, actual: count, }); @@ -149,8 +153,10 @@ if let Some(ref value) = self.links { #[allow(unused_comparisons)] if value.len() > 5usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "links", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "links", + ), max: 5usize, actual: value.len(), }); @@ -159,8 +165,10 @@ if let Some(ref value) = self.links { #[allow(unused_comparisons)] if value.len() < 0usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "links", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "links", + ), min: 0usize, actual: value.len(), }); @@ -169,8 +177,10 @@ if let Some(ref value) = self.location { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 400usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "location", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "location", + ), max: 400usize, actual: ::len(value.as_ref()), }); @@ -184,8 +194,10 @@ ) .count(); if count > 40usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "location", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "location", + ), max: 40usize, actual: count, }); @@ -195,8 +207,10 @@ if let Some(ref value) = self.pinned_repositories { #[allow(unused_comparisons)] if value.len() > 6usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "pinned_repositories", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "pinned_repositories", + ), max: 6usize, actual: value.len(), }); @@ -205,8 +219,10 @@ if let Some(ref value) = self.pinned_repositories { #[allow(unused_comparisons)] if value.len() < 0usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "pinned_repositories", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "pinned_repositories", + ), min: 0usize, actual: value.len(), }); @@ -215,8 +231,10 @@ if let Some(ref value) = self.stats { #[allow(unused_comparisons)] if value.len() > 2usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "stats", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "stats", + ), max: 2usize, actual: value.len(), }); @@ -225,8 +243,10 @@ if let Some(ref value) = self.stats { #[allow(unused_comparisons)] if value.len() < 0usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "stats", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "stats", + ), min: 0usize, actual: value.len(), }); diff --git a/crates/jacquard-api/src/sh_tangled/feed/reaction.rs b/crates/jacquard-api/src/sh_tangled/feed/reaction.rs --- a/crates/jacquard-api/src/sh_tangled/feed/reaction.rs +++ b/crates/jacquard-api/src/sh_tangled/feed/reaction.rs @@ -99,7 +99,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_tangled/feed/star.rs b/crates/jacquard-api/src/sh_tangled/feed/star.rs --- a/crates/jacquard-api/src/sh_tangled/feed/star.rs +++ b/crates/jacquard-api/src/sh_tangled/feed/star.rs @@ -96,7 +96,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_tangled/git/ref_update.rs b/crates/jacquard-api/src/sh_tangled/git/ref_update.rs --- a/crates/jacquard-api/src/sh_tangled/git/ref_update.rs +++ b/crates/jacquard-api/src/sh_tangled/git/ref_update.rs @@ -400,7 +400,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -436,7 +436,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -472,7 +472,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -509,7 +509,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -627,13 +627,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.new_sha; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 40usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "new_sha", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "new_sha", + ), max: 40usize, actual: ::len(value.as_ref()), }); @@ -643,8 +645,10 @@ let value = &self.new_sha; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 40usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "new_sha", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "new_sha", + ), min: 40usize, actual: ::len(value.as_ref()), }); @@ -654,8 +658,10 @@ let value = &self.old_sha; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 40usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "old_sha", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "old_sha", + ), max: 40usize, actual: ::len(value.as_ref()), }); @@ -665,8 +671,10 @@ let value = &self.old_sha; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 40usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "old_sha", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "old_sha", + ), min: 40usize, actual: ::len(value.as_ref()), }); @@ -676,8 +684,10 @@ let value = &self.r#ref; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "ref", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "ref", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -692,8 +702,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "ref", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "ref", + ), max: 256usize, actual: count, }); @@ -738,7 +750,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_tangled/graph/follow.rs b/crates/jacquard-api/src/sh_tangled/graph/follow.rs --- a/crates/jacquard-api/src/sh_tangled/graph/follow.rs +++ b/crates/jacquard-api/src/sh_tangled/graph/follow.rs @@ -96,7 +96,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_tangled/knot/list_keys.rs b/crates/jacquard-api/src/sh_tangled/knot/list_keys.rs --- a/crates/jacquard-api/src/sh_tangled/knot/list_keys.rs +++ b/crates/jacquard-api/src/sh_tangled/knot/list_keys.rs @@ -286,13 +286,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.key; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 4096usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "key", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "key", + ), max: 4096usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/sh_tangled/knot/member.rs b/crates/jacquard-api/src/sh_tangled/knot/member.rs --- a/crates/jacquard-api/src/sh_tangled/knot/member.rs +++ b/crates/jacquard-api/src/sh_tangled/knot/member.rs @@ -100,7 +100,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_tangled/label/definition.rs b/crates/jacquard-api/src/sh_tangled/label/definition.rs --- a/crates/jacquard-api/src/sh_tangled/label/definition.rs +++ b/crates/jacquard-api/src/sh_tangled/label/definition.rs @@ -113,7 +113,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.name; { @@ -123,8 +123,10 @@ ) .count(); if count > 40usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 40usize, actual: count, }); @@ -140,8 +142,10 @@ ) .count(); if count < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinGraphemes { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MinGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), min: 1usize, actual: count, }); @@ -410,7 +414,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_tangled/label/op.rs b/crates/jacquard-api/src/sh_tangled/label/op.rs --- a/crates/jacquard-api/src/sh_tangled/label/op.rs +++ b/crates/jacquard-api/src/sh_tangled/label/op.rs @@ -101,7 +101,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -301,7 +301,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_tangled/pipeline/status.rs b/crates/jacquard-api/src/sh_tangled/pipeline/status.rs --- a/crates/jacquard-api/src/sh_tangled/pipeline/status.rs +++ b/crates/jacquard-api/src/sh_tangled/pipeline/status.rs @@ -114,7 +114,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_tangled/repo/artifact.rs b/crates/jacquard-api/src/sh_tangled/repo/artifact.rs --- a/crates/jacquard-api/src/sh_tangled/repo/artifact.rs +++ b/crates/jacquard-api/src/sh_tangled/repo/artifact.rs @@ -107,7 +107,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_tangled/repo/blob.rs b/crates/jacquard-api/src/sh_tangled/repo/blob.rs --- a/crates/jacquard-api/src/sh_tangled/repo/blob.rs +++ b/crates/jacquard-api/src/sh_tangled/repo/blob.rs @@ -326,7 +326,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -527,7 +527,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_tangled/repo/branch.rs b/crates/jacquard-api/src/sh_tangled/repo/branch.rs --- a/crates/jacquard-api/src/sh_tangled/repo/branch.rs +++ b/crates/jacquard-api/src/sh_tangled/repo/branch.rs @@ -329,7 +329,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_tangled/repo/collaborator.rs b/crates/jacquard-api/src/sh_tangled/repo/collaborator.rs --- a/crates/jacquard-api/src/sh_tangled/repo/collaborator.rs +++ b/crates/jacquard-api/src/sh_tangled/repo/collaborator.rs @@ -99,7 +99,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_tangled/repo/get_default_branch.rs b/crates/jacquard-api/src/sh_tangled/repo/get_default_branch.rs --- a/crates/jacquard-api/src/sh_tangled/repo/get_default_branch.rs +++ b/crates/jacquard-api/src/sh_tangled/repo/get_default_branch.rs @@ -293,7 +293,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_tangled/repo/issue.rs b/crates/jacquard-api/src/sh_tangled/repo/issue.rs --- a/crates/jacquard-api/src/sh_tangled/repo/issue.rs +++ b/crates/jacquard-api/src/sh_tangled/repo/issue.rs @@ -106,7 +106,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_tangled/repo/languages.rs b/crates/jacquard-api/src/sh_tangled/repo/languages.rs --- a/crates/jacquard-api/src/sh_tangled/repo/languages.rs +++ b/crates/jacquard-api/src/sh_tangled/repo/languages.rs @@ -250,7 +250,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_tangled/repo/list_secrets.rs b/crates/jacquard-api/src/sh_tangled/repo/list_secrets.rs --- a/crates/jacquard-api/src/sh_tangled/repo/list_secrets.rs +++ b/crates/jacquard-api/src/sh_tangled/repo/list_secrets.rs @@ -244,13 +244,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.key; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 50usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "key", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "key", + ), max: 50usize, actual: ::len(value.as_ref()), }); @@ -260,8 +262,10 @@ let value = &self.key; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "key", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "key", + ), min: 1usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/sh_tangled/repo/merge_check.rs b/crates/jacquard-api/src/sh_tangled/repo/merge_check.rs --- a/crates/jacquard-api/src/sh_tangled/repo/merge_check.rs +++ b/crates/jacquard-api/src/sh_tangled/repo/merge_check.rs @@ -221,7 +221,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_tangled/repo/pull.rs b/crates/jacquard-api/src/sh_tangled/repo/pull.rs --- a/crates/jacquard-api/src/sh_tangled/repo/pull.rs +++ b/crates/jacquard-api/src/sh_tangled/repo/pull.rs @@ -113,7 +113,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -384,13 +384,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.sha; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 40usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "sha", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "sha", + ), max: 40usize, actual: ::len(value.as_ref()), }); @@ -400,8 +402,10 @@ let value = &self.sha; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 40usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "sha", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "sha", + ), min: 40usize, actual: ::len(value.as_ref()), }); @@ -443,7 +447,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_tangled/repo/tree.rs b/crates/jacquard-api/src/sh_tangled/repo/tree.rs --- a/crates/jacquard-api/src/sh_tangled/repo/tree.rs +++ b/crates/jacquard-api/src/sh_tangled/repo/tree.rs @@ -361,7 +361,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -547,7 +547,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -597,7 +597,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_tangled/spindle/member.rs b/crates/jacquard-api/src/sh_tangled/spindle/member.rs --- a/crates/jacquard-api/src/sh_tangled/spindle/member.rs +++ b/crates/jacquard-api/src/sh_tangled/spindle/member.rs @@ -100,7 +100,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_weaver/actor/profile.rs b/crates/jacquard-api/src/sh_weaver/actor/profile.rs --- a/crates/jacquard-api/src/sh_weaver/actor/profile.rs +++ b/crates/jacquard-api/src/sh_weaver/actor/profile.rs @@ -137,12 +137,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -156,8 +158,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 256usize, actual: count, }); @@ -167,8 +171,10 @@ if let Some(ref value) = self.display_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -182,8 +188,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 64usize, actual: count, }); @@ -193,8 +201,10 @@ if let Some(ref value) = self.links { #[allow(unused_comparisons)] if value.len() > 5usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "links", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "links", + ), max: 5usize, actual: value.len(), }); @@ -203,8 +213,10 @@ if let Some(ref value) = self.links { #[allow(unused_comparisons)] if value.len() < 0usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "links", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "links", + ), min: 0usize, actual: value.len(), }); @@ -213,8 +225,10 @@ if let Some(ref value) = self.location { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 400usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "location", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "location", + ), max: 400usize, actual: ::len(value.as_ref()), }); @@ -228,8 +242,10 @@ ) .count(); if count > 40usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "location", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "location", + ), max: 40usize, actual: count, }); diff --git a/crates/jacquard-api/src/sh_weaver/edit/cursor.rs b/crates/jacquard-api/src/sh_weaver/edit/cursor.rs --- a/crates/jacquard-api/src/sh_weaver/edit/cursor.rs +++ b/crates/jacquard-api/src/sh_weaver/edit/cursor.rs @@ -317,7 +317,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -351,7 +351,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -385,7 +385,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -489,7 +489,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -526,7 +526,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -562,7 +562,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_weaver/edit/diff.rs b/crates/jacquard-api/src/sh_weaver/edit/diff.rs --- a/crates/jacquard-api/src/sh_weaver/edit/diff.rs +++ b/crates/jacquard-api/src/sh_weaver/edit/diff.rs @@ -100,7 +100,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_weaver/edit/root.rs b/crates/jacquard-api/src/sh_weaver/edit/root.rs --- a/crates/jacquard-api/src/sh_weaver/edit/root.rs +++ b/crates/jacquard-api/src/sh_weaver/edit/root.rs @@ -102,7 +102,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_weaver/embed/external.rs b/crates/jacquard-api/src/sh_weaver/embed/external.rs --- a/crates/jacquard-api/src/sh_weaver/embed/external.rs +++ b/crates/jacquard-api/src/sh_weaver/embed/external.rs @@ -273,7 +273,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -307,13 +307,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.embeds; #[allow(unused_comparisons)] if value.len() > 48usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "embeds", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "embeds", + ), max: 48usize, actual: value.len(), }); @@ -352,7 +354,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -396,7 +398,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_weaver/embed/images.rs b/crates/jacquard-api/src/sh_weaver/embed/images.rs --- a/crates/jacquard-api/src/sh_weaver/embed/images.rs +++ b/crates/jacquard-api/src/sh_weaver/embed/images.rs @@ -188,12 +188,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.blurhash { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 32usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "blurhash", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "blurhash", + ), max: 32usize, actual: ::len(value.as_ref()), }); @@ -232,13 +234,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.images; #[allow(unused_comparisons)] if value.len() > 48usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "images", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "images", + ), max: 48usize, actual: value.len(), }); diff --git a/crates/jacquard-api/src/sh_weaver/embed/record_with_media.rs b/crates/jacquard-api/src/sh_weaver/embed/record_with_media.rs --- a/crates/jacquard-api/src/sh_weaver/embed/record_with_media.rs +++ b/crates/jacquard-api/src/sh_weaver/embed/record_with_media.rs @@ -181,7 +181,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -261,7 +261,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_weaver/embed/records.rs b/crates/jacquard-api/src/sh_weaver/embed/records.rs --- a/crates/jacquard-api/src/sh_weaver/embed/records.rs +++ b/crates/jacquard-api/src/sh_weaver/embed/records.rs @@ -425,13 +425,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.records; #[allow(unused_comparisons)] if value.len() > 48usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "records", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "records", + ), max: 48usize, actual: value.len(), }); @@ -501,7 +503,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -538,7 +540,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -573,7 +575,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -608,7 +610,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -697,7 +699,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_weaver/embed/video.rs b/crates/jacquard-api/src/sh_weaver/embed/video.rs --- a/crates/jacquard-api/src/sh_weaver/embed/video.rs +++ b/crates/jacquard-api/src/sh_weaver/embed/video.rs @@ -255,7 +255,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -303,12 +303,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.alt { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "alt", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "alt", + ), max: 10000usize, actual: ::len(value.as_ref()), }); @@ -322,8 +324,10 @@ ) .count(); if count > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "alt", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "alt", + ), max: 1000usize, actual: count, }); @@ -333,8 +337,10 @@ if let Some(ref value) = self.captions { #[allow(unused_comparisons)] if value.len() > 20usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "captions", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "captions", + ), max: 20usize, actual: value.len(), }); @@ -387,12 +393,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.alt { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "alt", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "alt", + ), max: 10000usize, actual: ::len(value.as_ref()), }); @@ -406,8 +414,10 @@ ) .count(); if count > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "alt", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "alt", + ), max: 1000usize, actual: count, }); diff --git a/crates/jacquard-api/src/sh_weaver/notebook/authors.rs b/crates/jacquard-api/src/sh_weaver/notebook/authors.rs --- a/crates/jacquard-api/src/sh_weaver/notebook/authors.rs +++ b/crates/jacquard-api/src/sh_weaver/notebook/authors.rs @@ -177,7 +177,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -276,7 +276,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_weaver/notebook/book.rs b/crates/jacquard-api/src/sh_weaver/notebook/book.rs --- a/crates/jacquard-api/src/sh_weaver/notebook/book.rs +++ b/crates/jacquard-api/src/sh_weaver/notebook/book.rs @@ -110,7 +110,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_weaver/notebook/chapter.rs b/crates/jacquard-api/src/sh_weaver/notebook/chapter.rs --- a/crates/jacquard-api/src/sh_weaver/notebook/chapter.rs +++ b/crates/jacquard-api/src/sh_weaver/notebook/chapter.rs @@ -111,7 +111,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_weaver/notebook/entry.rs b/crates/jacquard-api/src/sh_weaver/notebook/entry.rs --- a/crates/jacquard-api/src/sh_weaver/notebook/entry.rs +++ b/crates/jacquard-api/src/sh_weaver/notebook/entry.rs @@ -111,13 +111,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.content; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 200000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "content", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "content", + ), max: 200000usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/sh_weaver/publish/blob.rs b/crates/jacquard-api/src/sh_weaver/publish/blob.rs --- a/crates/jacquard-api/src/sh_weaver/publish/blob.rs +++ b/crates/jacquard-api/src/sh_weaver/publish/blob.rs @@ -97,7 +97,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_clippr/actor/profile.rs b/crates/jacquard-api/src/social_clippr/actor/profile.rs --- a/crates/jacquard-api/src/social_clippr/actor/profile.rs +++ b/crates/jacquard-api/src/social_clippr/actor/profile.rs @@ -110,12 +110,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 5000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 5000usize, actual: ::len(value.as_ref()), }); @@ -129,8 +131,10 @@ ) .count(); if count > 500usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 500usize, actual: count, }); @@ -141,8 +145,10 @@ let value = &self.display_name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -157,8 +163,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 64usize, actual: count, }); diff --git a/crates/jacquard-api/src/social_clippr/feed/clip.rs b/crates/jacquard-api/src/social_clippr/feed/clip.rs --- a/crates/jacquard-api/src/social_clippr/feed/clip.rs +++ b/crates/jacquard-api/src/social_clippr/feed/clip.rs @@ -127,13 +127,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.description; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 40960usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 40960usize, actual: ::len(value.as_ref()), }); @@ -148,8 +150,10 @@ ) .count(); if count > 4096usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 4096usize, actual: count, }); @@ -159,8 +163,10 @@ if let Some(ref value) = self.languages { #[allow(unused_comparisons)] if value.len() > 5usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "languages", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "languages", + ), max: 5usize, actual: value.len(), }); @@ -169,8 +175,10 @@ if let Some(ref value) = self.notes { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "notes", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "notes", + ), max: 100000usize, actual: ::len(value.as_ref()), }); @@ -184,8 +192,10 @@ ) .count(); if count > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "notes", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "notes", + ), max: 10000usize, actual: count, }); @@ -196,8 +206,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 20480usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 20480usize, actual: ::len(value.as_ref()), }); @@ -212,8 +224,10 @@ ) .count(); if count > 2048usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 2048usize, actual: count, }); @@ -224,8 +238,10 @@ let value = &self.url; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 20000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "url", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "url", + ), max: 20000usize, actual: ::len(value.as_ref()), }); @@ -240,8 +256,10 @@ ) .count(); if count > 2000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "url", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "url", + ), max: 2000usize, actual: count, }); diff --git a/crates/jacquard-api/src/social_clippr/feed/tag.rs b/crates/jacquard-api/src/social_clippr/feed/tag.rs --- a/crates/jacquard-api/src/social_clippr/feed/tag.rs +++ b/crates/jacquard-api/src/social_clippr/feed/tag.rs @@ -110,12 +110,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.color { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 70usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "color", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "color", + ), max: 70usize, actual: ::len(value.as_ref()), }); @@ -129,8 +131,10 @@ ) .count(); if count > 7usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "color", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "color", + ), max: 7usize, actual: count, }); @@ -140,8 +144,10 @@ if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 50000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 50000usize, actual: ::len(value.as_ref()), }); @@ -155,8 +161,10 @@ ) .count(); if count > 5000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 5000usize, actual: count, }); @@ -167,8 +175,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -183,8 +193,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 64usize, actual: count, }); diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/action.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/action.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/action.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/action.rs @@ -547,7 +547,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/aggregaterating.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/aggregaterating.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/aggregaterating.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/aggregaterating.rs @@ -356,7 +356,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/alignmentobject.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/alignmentobject.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/alignmentobject.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/alignmentobject.rs @@ -300,7 +300,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/audience.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/audience.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/audience.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/audience.rs @@ -300,7 +300,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/audioobject.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/audioobject.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/audioobject.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/audioobject.rs @@ -2592,7 +2592,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/brand.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/brand.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/brand.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/brand.rs @@ -352,7 +352,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/breadcrumblist.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/breadcrumblist.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/breadcrumblist.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/breadcrumblist.rs @@ -218,7 +218,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/categorycode.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/categorycode.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/categorycode.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/categorycode.rs @@ -327,7 +327,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/certification.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/certification.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/certification.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/certification.rs @@ -2447,7 +2447,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/claim.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/claim.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/claim.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/claim.rs @@ -2366,7 +2366,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/clip.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/clip.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/clip.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/clip.rs @@ -2537,7 +2537,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/comment.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/comment.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/comment.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/comment.rs @@ -2346,7 +2346,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/correctioncomment.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/correctioncomment.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/correctioncomment.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/correctioncomment.rs @@ -2346,7 +2346,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/country.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/country.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/country.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/country.rs @@ -1069,7 +1069,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/creativework.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/creativework.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/creativework.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/creativework.rs @@ -2288,7 +2288,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/creativeworkseason.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/creativeworkseason.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/creativeworkseason.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/creativeworkseason.rs @@ -2475,7 +2475,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/definedterm.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/definedterm.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/definedterm.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/definedterm.rs @@ -300,7 +300,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/demand.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/demand.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/demand.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/demand.rs @@ -854,7 +854,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/distance.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/distance.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/distance.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/distance.rs @@ -273,7 +273,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/duration.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/duration.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/duration.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/duration.rs @@ -273,7 +273,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/energyconsumptiondetails.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/energyconsumptiondetails.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/energyconsumptiondetails.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/energyconsumptiondetails.rs @@ -288,7 +288,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/episode.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/episode.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/episode.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/episode.rs @@ -2545,7 +2545,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/event.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/event.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/event.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/event.rs @@ -1074,7 +1074,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/grant.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/grant.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/grant.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/grant.rs @@ -362,7 +362,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/howtosection.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/howtosection.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/howtosection.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/howtosection.rs @@ -118,7 +118,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/howtostep.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/howtostep.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/howtostep.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/howtostep.rs @@ -92,7 +92,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/howtosupply.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/howtosupply.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/howtosupply.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/howtosupply.rs @@ -402,7 +402,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/howtotool.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/howtotool.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/howtotool.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/howtotool.rs @@ -376,7 +376,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/imageobject.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/imageobject.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/imageobject.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/imageobject.rs @@ -2617,7 +2617,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/interactioncounter.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/interactioncounter.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/interactioncounter.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/interactioncounter.rs @@ -357,7 +357,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/iptcdigitalsourceenumeration.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/iptcdigitalsourceenumeration.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/iptcdigitalsourceenumeration.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/iptcdigitalsourceenumeration.rs @@ -203,7 +203,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/itemlist.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/itemlist.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/itemlist.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/itemlist.rs @@ -349,7 +349,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/language.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/language.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/language.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/language.rs @@ -273,7 +273,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/listitem.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/listitem.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/listitem.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/listitem.rs @@ -350,7 +350,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/mass.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/mass.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/mass.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/mass.rs @@ -273,7 +273,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/mediaobject.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/mediaobject.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/mediaobject.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/mediaobject.rs @@ -2558,7 +2558,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/merchantreturnpolicy.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/merchantreturnpolicy.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/merchantreturnpolicy.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/merchantreturnpolicy.rs @@ -590,7 +590,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/monetaryamount.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/monetaryamount.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/monetaryamount.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/monetaryamount.rs @@ -316,7 +316,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/musicgroup.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/musicgroup.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/musicgroup.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/musicgroup.rs @@ -1892,7 +1892,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/musicrecording.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/musicrecording.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/musicrecording.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/musicrecording.rs @@ -2413,7 +2413,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/newsarticle.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/newsarticle.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/newsarticle.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/newsarticle.rs @@ -1235,7 +1235,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/nutritioninformation.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/nutritioninformation.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/nutritioninformation.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/nutritioninformation.rs @@ -540,7 +540,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/offer.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/offer.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/offer.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/offer.rs @@ -1206,7 +1206,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/offeritemcondition.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/offeritemcondition.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/offeritemcondition.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/offeritemcondition.rs @@ -295,7 +295,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/organization.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/organization.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/organization.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/organization.rs @@ -1767,7 +1767,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/performinggroup.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/performinggroup.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/performinggroup.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/performinggroup.rs @@ -1769,7 +1769,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/person.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/person.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/person.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/person.rs @@ -1534,7 +1534,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/physicalactivitycategory.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/physicalactivitycategory.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/physicalactivitycategory.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/physicalactivitycategory.rs @@ -295,7 +295,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/place.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/place.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/place.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/place.rs @@ -1069,7 +1069,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/product.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/product.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/product.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/product.rs @@ -1302,7 +1302,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/productgroup.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/productgroup.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/productgroup.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/productgroup.rs @@ -1361,7 +1361,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/productmodel.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/productmodel.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/productmodel.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/productmodel.rs @@ -1354,7 +1354,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/propertyvalue.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/propertyvalue.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/propertyvalue.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/propertyvalue.rs @@ -408,7 +408,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/publicationevent.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/publicationevent.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/publicationevent.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/publicationevent.rs @@ -1126,7 +1126,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/quantitativevalue.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/quantitativevalue.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/quantitativevalue.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/quantitativevalue.rs @@ -372,7 +372,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/rating.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/rating.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/rating.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/rating.rs @@ -324,7 +324,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/recipe.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/recipe.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/recipe.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/recipe.rs @@ -2688,7 +2688,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/restricteddiet.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/restricteddiet.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/restricteddiet.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/restricteddiet.rs @@ -295,7 +295,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/review.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/review.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/review.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/review.rs @@ -2479,7 +2479,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/service.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/service.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/service.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/service.rs @@ -815,7 +815,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/sizespecification.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/sizespecification.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/sizespecification.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/sizespecification.rs @@ -629,7 +629,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/socialmediaposting.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/socialmediaposting.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/socialmediaposting.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/socialmediaposting.rs @@ -1211,7 +1211,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/speakablespecification.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/speakablespecification.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/speakablespecification.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/speakablespecification.rs @@ -190,7 +190,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/textobject.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/textobject.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/textobject.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/textobject.rs @@ -2558,7 +2558,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/thing.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/thing.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/thing.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/thing.rs @@ -273,7 +273,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/videoobject.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/videoobject.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/videoobject.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/videoobject.rs @@ -2728,7 +2728,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/webcontent.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/webcontent.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/webcontent.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/webcontent.rs @@ -2288,7 +2288,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_flockfeeds/lexical/webpage.rs b/crates/jacquard-api/src/social_flockfeeds/lexical/webpage.rs --- a/crates/jacquard-api/src/social_flockfeeds/lexical/webpage.rs +++ b/crates/jacquard-api/src/social_flockfeeds/lexical/webpage.rs @@ -2469,7 +2469,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_grain/actor/profile.rs b/crates/jacquard-api/src/social_grain/actor/profile.rs --- a/crates/jacquard-api/src/social_grain/actor/profile.rs +++ b/crates/jacquard-api/src/social_grain/actor/profile.rs @@ -111,12 +111,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -130,8 +132,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 256usize, actual: count, }); @@ -141,8 +145,10 @@ if let Some(ref value) = self.display_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -156,8 +162,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 64usize, actual: count, }); diff --git a/crates/jacquard-api/src/social_grain/gallery/item.rs b/crates/jacquard-api/src/social_grain/gallery/item.rs --- a/crates/jacquard-api/src/social_grain/gallery/item.rs +++ b/crates/jacquard-api/src/social_grain/gallery/item.rs @@ -101,7 +101,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_grain/photo/exif.rs b/crates/jacquard-api/src/social_grain/photo/exif.rs --- a/crates/jacquard-api/src/social_grain/photo/exif.rs +++ b/crates/jacquard-api/src/social_grain/photo/exif.rs @@ -132,7 +132,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/social_psky/actor/profile.rs b/crates/jacquard-api/src/social_psky/actor/profile.rs --- a/crates/jacquard-api/src/social_psky/actor/profile.rs +++ b/crates/jacquard-api/src/social_psky/actor/profile.rs @@ -98,12 +98,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.nickname { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 320usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "nickname", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "nickname", + ), max: 320usize, actual: ::len(value.as_ref()), }); @@ -117,8 +119,10 @@ ) .count(); if count > 32usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "nickname", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "nickname", + ), max: 32usize, actual: count, }); diff --git a/crates/jacquard-api/src/social_psky/chat/message.rs b/crates/jacquard-api/src/social_psky/chat/message.rs --- a/crates/jacquard-api/src/social_psky/chat/message.rs +++ b/crates/jacquard-api/src/social_psky/chat/message.rs @@ -109,13 +109,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.content; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 20480usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "content", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "content", + ), max: 20480usize, actual: ::len(value.as_ref()), }); @@ -130,8 +132,10 @@ ) .count(); if count > 2048usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "content", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "content", + ), max: 2048usize, actual: count, }); diff --git a/crates/jacquard-api/src/social_psky/chat/room.rs b/crates/jacquard-api/src/social_psky/chat/room.rs --- a/crates/jacquard-api/src/social_psky/chat/room.rs +++ b/crates/jacquard-api/src/social_psky/chat/room.rs @@ -119,12 +119,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.languages { #[allow(unused_comparisons)] if value.len() > 3usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "languages", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "languages", + ), max: 3usize, actual: value.len(), }); @@ -134,8 +136,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 320usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 320usize, actual: ::len(value.as_ref()), }); @@ -150,8 +154,10 @@ ) .count(); if count > 32usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 32usize, actual: count, }); @@ -161,8 +167,10 @@ if let Some(ref value) = self.tags { #[allow(unused_comparisons)] if value.len() > 20usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "tags", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "tags", + ), max: 20usize, actual: value.len(), }); @@ -171,8 +179,10 @@ if let Some(ref value) = self.topic { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "topic", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "topic", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -186,8 +196,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "topic", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "topic", + ), max: 256usize, actual: count, }); @@ -412,7 +424,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/social_psky/richtext/facet.rs b/crates/jacquard-api/src/social_psky/richtext/facet.rs --- a/crates/jacquard-api/src/social_psky/richtext/facet.rs +++ b/crates/jacquard-api/src/social_psky/richtext/facet.rs @@ -248,12 +248,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.byte_end; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "byte_end", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "byte_end", + ), min: 0i64, actual: *value, }); @@ -262,8 +264,10 @@ { let value = &self.byte_start; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "byte_start", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "byte_start", + ), min: 0i64, actual: *value, }); @@ -303,7 +307,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -361,7 +365,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -396,7 +400,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -431,13 +435,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.room; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "room", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "room", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -452,8 +458,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "room", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "room", + ), max: 64usize, actual: count, }); diff --git a/crates/jacquard-api/src/tools_ozone/hosting/get_account_history.rs b/crates/jacquard-api/src/tools_ozone/hosting/get_account_history.rs --- a/crates/jacquard-api/src/tools_ozone/hosting/get_account_history.rs +++ b/crates/jacquard-api/src/tools_ozone/hosting/get_account_history.rs @@ -360,7 +360,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -394,7 +394,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -428,7 +428,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -501,7 +501,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -535,7 +535,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -637,7 +637,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/tools_ozone/moderation/cancel_scheduled_actions.rs b/crates/jacquard-api/src/tools_ozone/moderation/cancel_scheduled_actions.rs --- a/crates/jacquard-api/src/tools_ozone/moderation/cancel_scheduled_actions.rs +++ b/crates/jacquard-api/src/tools_ozone/moderation/cancel_scheduled_actions.rs @@ -266,7 +266,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -307,7 +307,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/tools_ozone/moderation/get_account_timeline.rs b/crates/jacquard-api/src/tools_ozone/moderation/get_account_timeline.rs --- a/crates/jacquard-api/src/tools_ozone/moderation/get_account_timeline.rs +++ b/crates/jacquard-api/src/tools_ozone/moderation/get_account_timeline.rs @@ -300,7 +300,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -339,7 +339,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/tools_ozone/moderation/schedule_action.rs b/crates/jacquard-api/src/tools_ozone/moderation/schedule_action.rs --- a/crates/jacquard-api/src/tools_ozone/moderation/schedule_action.rs +++ b/crates/jacquard-api/src/tools_ozone/moderation/schedule_action.rs @@ -459,7 +459,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -581,7 +581,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -623,7 +623,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -669,12 +669,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.policies { #[allow(unused_comparisons)] if value.len() > 5usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "policies", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "policies", + ), max: 5usize, actual: value.len(), }); diff --git a/crates/jacquard-api/src/tools_ozone/server/get_config.rs b/crates/jacquard-api/src/tools_ozone/server/get_config.rs --- a/crates/jacquard-api/src/tools_ozone/server/get_config.rs +++ b/crates/jacquard-api/src/tools_ozone/server/get_config.rs @@ -189,7 +189,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -224,7 +224,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/tools_ozone/signature/find_related_accounts.rs b/crates/jacquard-api/src/tools_ozone/signature/find_related_accounts.rs --- a/crates/jacquard-api/src/tools_ozone/signature/find_related_accounts.rs +++ b/crates/jacquard-api/src/tools_ozone/signature/find_related_accounts.rs @@ -230,7 +230,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/tools_ozone/verification/grant_verifications.rs b/crates/jacquard-api/src/tools_ozone/verification/grant_verifications.rs --- a/crates/jacquard-api/src/tools_ozone/verification/grant_verifications.rs +++ b/crates/jacquard-api/src/tools_ozone/verification/grant_verifications.rs @@ -275,7 +275,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -395,7 +395,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/tools_ozone/verification/revoke_verifications.rs b/crates/jacquard-api/src/tools_ozone/verification/revoke_verifications.rs --- a/crates/jacquard-api/src/tools_ozone/verification/revoke_verifications.rs +++ b/crates/jacquard-api/src/tools_ozone/verification/revoke_verifications.rs @@ -282,7 +282,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/us_polhem/blog/content.rs b/crates/jacquard-api/src/us_polhem/blog/content.rs --- a/crates/jacquard-api/src/us_polhem/blog/content.rs +++ b/crates/jacquard-api/src/us_polhem/blog/content.rs @@ -105,13 +105,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.content; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "content", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "content", + ), max: 100000usize, actual: ::len(value.as_ref()), }); @@ -121,8 +123,10 @@ let value = &self.slug; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "slug", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "slug", + ), max: 100usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/us_polhem/blog/post.rs b/crates/jacquard-api/src/us_polhem/blog/post.rs --- a/crates/jacquard-api/src/us_polhem/blog/post.rs +++ b/crates/jacquard-api/src/us_polhem/blog/post.rs @@ -125,13 +125,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.content; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "content", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "content", + ), max: 100000usize, actual: ::len(value.as_ref()), }); @@ -140,8 +142,10 @@ if let Some(ref value) = self.excerpt { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "excerpt", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "excerpt", + ), max: 1000usize, actual: ::len(value.as_ref()), }); @@ -151,8 +155,10 @@ let value = &self.slug; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "slug", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "slug", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -162,8 +168,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 1000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 1000usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/us_polhem/blog/tag.rs b/crates/jacquard-api/src/us_polhem/blog/tag.rs --- a/crates/jacquard-api/src/us_polhem/blog/tag.rs +++ b/crates/jacquard-api/src/us_polhem/blog/tag.rs @@ -104,13 +104,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.description; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 100000usize, actual: ::len(value.as_ref()), }); @@ -120,8 +122,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -131,8 +135,10 @@ let value = &self.slug; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "slug", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "slug", + ), max: 100usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/win_tomo_x/pushat/allow.rs b/crates/jacquard-api/src/win_tomo_x/pushat/allow.rs --- a/crates/jacquard-api/src/win_tomo_x/pushat/allow.rs +++ b/crates/jacquard-api/src/win_tomo_x/pushat/allow.rs @@ -99,7 +99,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_blebbit/authr/folder/record.rs b/crates/jacquard-api/src/app_blebbit/authr/folder/record.rs --- a/crates/jacquard-api/src/app_blebbit/authr/folder/record.rs +++ b/crates/jacquard-api/src/app_blebbit/authr/folder/record.rs @@ -104,7 +104,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_blebbit/authr/group/record.rs b/crates/jacquard-api/src/app_blebbit/authr/group/record.rs --- a/crates/jacquard-api/src/app_blebbit/authr/group/record.rs +++ b/crates/jacquard-api/src/app_blebbit/authr/group/record.rs @@ -112,7 +112,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/app_blebbit/authr/page/record.rs b/crates/jacquard-api/src/app_blebbit/authr/page/record.rs --- a/crates/jacquard-api/src/app_blebbit/authr/page/record.rs +++ b/crates/jacquard-api/src/app_blebbit/authr/page/record.rs @@ -108,7 +108,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/blue__2048/key/player/stats.rs b/crates/jacquard-api/src/blue__2048/key/player/stats.rs --- a/crates/jacquard-api/src/blue__2048/key/player/stats.rs +++ b/crates/jacquard-api/src/blue__2048/key/player/stats.rs @@ -98,7 +98,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/fm_teal/alpha/actor/profile.rs b/crates/jacquard-api/src/fm_teal/alpha/actor/profile.rs --- a/crates/jacquard-api/src/fm_teal/alpha/actor/profile.rs +++ b/crates/jacquard-api/src/fm_teal/alpha/actor/profile.rs @@ -234,7 +234,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -360,12 +360,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 2560usize, actual: ::len(value.as_ref()), }); @@ -379,8 +381,10 @@ ) .count(); if count > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 256usize, actual: count, }); @@ -390,8 +394,10 @@ if let Some(ref value) = self.display_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 640usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 640usize, actual: ::len(value.as_ref()), }); @@ -405,8 +411,10 @@ ) .count(); if count > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "display_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "display_name", + ), max: 64usize, actual: count, }); diff --git a/crates/jacquard-api/src/fm_teal/alpha/actor/profile_status.rs b/crates/jacquard-api/src/fm_teal/alpha/actor/profile_status.rs --- a/crates/jacquard-api/src/fm_teal/alpha/actor/profile_status.rs +++ b/crates/jacquard-api/src/fm_teal/alpha/actor/profile_status.rs @@ -106,7 +106,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/fm_teal/alpha/actor/status.rs b/crates/jacquard-api/src/fm_teal/alpha/actor/status.rs --- a/crates/jacquard-api/src/fm_teal/alpha/actor/status.rs +++ b/crates/jacquard-api/src/fm_teal/alpha/actor/status.rs @@ -102,7 +102,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/fm_teal/alpha/feed/play.rs b/crates/jacquard-api/src/fm_teal/alpha/feed/play.rs --- a/crates/jacquard-api/src/fm_teal/alpha/feed/play.rs +++ b/crates/jacquard-api/src/fm_teal/alpha/feed/play.rs @@ -170,12 +170,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.release_discriminant { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 128usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "release_discriminant", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "release_discriminant", + ), max: 128usize, actual: ::len(value.as_ref()), }); @@ -189,8 +191,10 @@ ) .count(); if count > 1280usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "release_discriminant", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "release_discriminant", + ), max: 1280usize, actual: count, }); @@ -200,8 +204,10 @@ if let Some(ref value) = self.release_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "release_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "release_name", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -215,8 +221,10 @@ ) .count(); if count > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "release_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "release_name", + ), max: 2560usize, actual: count, }); @@ -226,8 +234,10 @@ if let Some(ref value) = self.submission_client_agent { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "submission_client_agent", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "submission_client_agent", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -241,8 +251,10 @@ ) .count(); if count > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "submission_client_agent", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "submission_client_agent", + ), max: 2560usize, actual: count, }); @@ -252,8 +264,10 @@ if let Some(ref value) = self.track_discriminant { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 128usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "track_discriminant", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "track_discriminant", + ), max: 128usize, actual: ::len(value.as_ref()), }); @@ -267,8 +281,10 @@ ) .count(); if count > 1280usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "track_discriminant", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "track_discriminant", + ), max: 1280usize, actual: count, }); @@ -279,8 +295,10 @@ let value = &self.track_name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "track_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "track_name", + ), max: 256usize, actual: ::len(value.as_ref()), }); @@ -290,8 +308,10 @@ let value = &self.track_name; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "track_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "track_name", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -306,8 +326,10 @@ ) .count(); if count > 2560usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "track_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "track_name", + ), max: 2560usize, actual: count, }); diff --git a/crates/jacquard-api/src/net_anisota/beta/game/collection.rs b/crates/jacquard-api/src/net_anisota/beta/game/collection.rs --- a/crates/jacquard-api/src/net_anisota/beta/game/collection.rs +++ b/crates/jacquard-api/src/net_anisota/beta/game/collection.rs @@ -169,12 +169,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.common_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 200usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "common_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "common_name", + ), max: 200usize, actual: ::len(value.as_ref()), }); @@ -183,8 +185,10 @@ if let Some(ref value) = self.family { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "family", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "family", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -193,8 +197,10 @@ if let Some(ref value) = self.genus { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "genus", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "genus", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -203,8 +209,10 @@ { let value = &self.quantity; if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "quantity", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "quantity", + ), min: 1i64, actual: *value, }); @@ -213,8 +221,10 @@ if let Some(ref value) = self.scientific_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 200usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "scientific_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "scientific_name", + ), max: 200usize, actual: ::len(value.as_ref()), }); @@ -223,8 +233,10 @@ if let Some(ref value) = self.species { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "species", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "species", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -234,8 +246,10 @@ let value = &self.specimen_id; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "specimen_id", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "specimen_id", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -798,7 +812,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -839,7 +853,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/net_anisota/beta/game/inventory.rs b/crates/jacquard-api/src/net_anisota/beta/game/inventory.rs --- a/crates/jacquard-api/src/net_anisota/beta/game/inventory.rs +++ b/crates/jacquard-api/src/net_anisota/beta/game/inventory.rs @@ -156,13 +156,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.item_id; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "item_id", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "item_id", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -171,8 +173,10 @@ if let Some(ref value) = self.item_name { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 200usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "item_name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "item_name", + ), max: 200usize, actual: ::len(value.as_ref()), }); @@ -181,8 +185,10 @@ if let Some(ref value) = self.item_type { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 50usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "item_type", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "item_type", + ), max: 50usize, actual: ::len(value.as_ref()), }); @@ -190,8 +196,10 @@ } if let Some(ref value) = self.item_value { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "item_value", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "item_value", + ), min: 0i64, actual: *value, }); @@ -199,8 +207,10 @@ } if let Some(ref value) = self.max_stack { if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "max_stack", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "max_stack", + ), min: 1i64, actual: *value, }); @@ -209,8 +219,10 @@ { let value = &self.quantity; if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "quantity", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "quantity", + ), min: 1i64, actual: *value, }); @@ -629,7 +641,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/net_anisota/beta/game/log.rs b/crates/jacquard-api/src/net_anisota/beta/game/log.rs --- a/crates/jacquard-api/src/net_anisota/beta/game/log.rs +++ b/crates/jacquard-api/src/net_anisota/beta/game/log.rs @@ -982,11 +982,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.time_since_generation { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "time_since_generation", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "time_since_generation", + ), min: 0i64, actual: *value, }); @@ -994,8 +996,10 @@ } if let Some(ref value) = self.time_since_viewed { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "time_since_viewed", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "time_since_viewed", + ), min: 0i64, actual: *value, }); @@ -1047,11 +1051,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.rewards_count { if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "rewards_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "rewards_count", + ), min: 1i64, actual: *value, }); @@ -1059,8 +1065,10 @@ } if let Some(ref value) = self.streak { if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "streak", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "streak", + ), min: 1i64, actual: *value, }); @@ -1068,8 +1076,10 @@ } if let Some(ref value) = self.time_since_last_claim { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "time_since_last_claim", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "time_since_last_claim", + ), min: 0i64, actual: *value, }); @@ -1120,11 +1130,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.game_card_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "game_card_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "game_card_count", + ), min: 0i64, actual: *value, }); @@ -1132,8 +1144,10 @@ } if let Some(ref value) = self.post_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "post_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "post_count", + ), min: 0i64, actual: *value, }); @@ -1141,8 +1155,10 @@ } if let Some(ref value) = self.scroll_position { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "scroll_position", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "scroll_position", + ), min: 0i64, actual: *value, }); @@ -1206,11 +1222,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.injection_position { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "injection_position", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "injection_position", + ), min: 0i64, actual: *value, }); @@ -1218,8 +1236,10 @@ } if let Some(ref value) = self.quantity { if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "quantity", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "quantity", + ), min: 1i64, actual: *value, }); @@ -1275,11 +1295,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.quantity_used { if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "quantity_used", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "quantity_used", + ), min: 1i64, actual: *value, }); @@ -1287,8 +1309,10 @@ } if let Some(ref value) = self.remaining_quantity { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "remaining_quantity", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "remaining_quantity", + ), min: 0i64, actual: *value, }); @@ -1447,13 +1471,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.session_id; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 64usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "session_id", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "session_id", + ), max: 64usize, actual: ::len(value.as_ref()), }); @@ -1508,11 +1534,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.network_latency { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "network_latency", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "network_latency", + ), min: 0i64, actual: *value, }); @@ -1558,11 +1586,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.quantity { if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "quantity", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "quantity", + ), min: 1i64, actual: *value, }); diff --git a/crates/jacquard-api/src/net_anisota/beta/game/pack.rs b/crates/jacquard-api/src/net_anisota/beta/game/pack.rs --- a/crates/jacquard-api/src/net_anisota/beta/game/pack.rs +++ b/crates/jacquard-api/src/net_anisota/beta/game/pack.rs @@ -117,11 +117,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.longest_streak { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "longest_streak", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "longest_streak", + ), min: 0i64, actual: *value, }); @@ -130,8 +132,10 @@ if let Some(ref value) = self.pack_history { #[allow(unused_comparisons)] if value.len() > 30usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "pack_history", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "pack_history", + ), max: 30usize, actual: value.len(), }); @@ -140,8 +144,10 @@ { let value = &self.streak; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "streak", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "streak", + ), min: 0i64, actual: *value, }); @@ -150,8 +156,10 @@ { let value = &self.total_opens; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "total_opens", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "total_opens", + ), min: 0i64, actual: *value, }); @@ -505,7 +513,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -549,7 +557,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/net_anisota/beta/game/progress.rs b/crates/jacquard-api/src/net_anisota/beta/game/progress.rs --- a/crates/jacquard-api/src/net_anisota/beta/game/progress.rs +++ b/crates/jacquard-api/src/net_anisota/beta/game/progress.rs @@ -152,12 +152,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.level; if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "level", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "level", + ), min: 1i64, actual: *value, }); @@ -165,8 +167,10 @@ } if let Some(ref value) = self.previous_level { if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "previous_level", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "previous_level", + ), min: 1i64, actual: *value, }); @@ -175,8 +179,10 @@ { let value = &self.total_xp; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "total_xp", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "total_xp", + ), min: 0i64, actual: *value, }); @@ -184,8 +190,10 @@ } if let Some(ref value) = self.xp_gained_since_last_save { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "xp_gained_since_last_save", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "xp_gained_since_last_save", + ), min: 0i64, actual: *value, }); @@ -194,8 +202,10 @@ { let value = &self.xp_to_next_level; if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "xp_to_next_level", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "xp_to_next_level", + ), min: 0i64, actual: *value, }); @@ -723,7 +733,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -782,11 +792,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.daily_rewards_claimed { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "daily_rewards_claimed", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "daily_rewards_claimed", + ), min: 0i64, actual: *value, }); @@ -794,8 +806,10 @@ } if let Some(ref value) = self.items_collected { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "items_collected", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "items_collected", + ), min: 0i64, actual: *value, }); @@ -803,8 +817,10 @@ } if let Some(ref value) = self.posts_read_today { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "posts_read_today", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "posts_read_today", + ), min: 0i64, actual: *value, }); @@ -812,8 +828,10 @@ } if let Some(ref value) = self.posts_read_total { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "posts_read_total", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "posts_read_total", + ), min: 0i64, actual: *value, }); @@ -821,8 +839,10 @@ } if let Some(ref value) = self.posts_viewed { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "posts_viewed", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "posts_viewed", + ), min: 0i64, actual: *value, }); @@ -830,8 +850,10 @@ } if let Some(ref value) = self.shuffles_performed { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "shuffles_performed", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "shuffles_performed", + ), min: 0i64, actual: *value, }); @@ -839,8 +861,10 @@ } if let Some(ref value) = self.specimens_collected { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "specimens_collected", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "specimens_collected", + ), min: 0i64, actual: *value, }); diff --git a/crates/jacquard-api/src/net_anisota/beta/game/session.rs b/crates/jacquard-api/src/net_anisota/beta/game/session.rs --- a/crates/jacquard-api/src/net_anisota/beta/game/session.rs +++ b/crates/jacquard-api/src/net_anisota/beta/game/session.rs @@ -834,11 +834,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.current_level { if *value < 1i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "current_level", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "current_level", + ), min: 1i64, actual: *value, }); @@ -846,8 +848,10 @@ } if let Some(ref value) = self.current_xp { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "current_xp", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "current_xp", + ), min: 0i64, actual: *value, }); @@ -855,8 +859,10 @@ } if let Some(ref value) = self.total_events { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "total_events", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "total_events", + ), min: 0i64, actual: *value, }); @@ -864,8 +870,10 @@ } if let Some(ref value) = self.xp_gained_this_session { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "xp_gained_this_session", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "xp_gained_this_session", + ), min: 0i64, actual: *value, }); @@ -915,11 +923,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.daily_rewards_claimed { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "daily_rewards_claimed", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "daily_rewards_claimed", + ), min: 0i64, actual: *value, }); @@ -927,8 +937,10 @@ } if let Some(ref value) = self.feeds_loaded { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "feeds_loaded", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "feeds_loaded", + ), min: 0i64, actual: *value, }); @@ -936,8 +948,10 @@ } if let Some(ref value) = self.items_collected { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "items_collected", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "items_collected", + ), min: 0i64, actual: *value, }); @@ -945,8 +959,10 @@ } if let Some(ref value) = self.level_ups { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "level_ups", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "level_ups", + ), min: 0i64, actual: *value, }); @@ -954,8 +970,10 @@ } if let Some(ref value) = self.posts_viewed { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "posts_viewed", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "posts_viewed", + ), min: 0i64, actual: *value, }); @@ -963,8 +981,10 @@ } if let Some(ref value) = self.specimens_collected { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "specimens_collected", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "specimens_collected", + ), min: 0i64, actual: *value, }); @@ -1138,11 +1158,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.duration { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "duration", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "duration", + ), min: 0i64, actual: *value, }); @@ -1193,7 +1215,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -1232,11 +1254,13 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.average_response_time { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "average_response_time", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "average_response_time", + ), min: 0i64, actual: *value, }); @@ -1244,8 +1268,10 @@ } if let Some(ref value) = self.error_count { if *value < 0i64 { - return Err(::jacquard_lexicon::schema::ValidationError::Minimum { - field: "error_count", + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "error_count", + ), min: 0i64, actual: *value, }); @@ -1298,7 +1324,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } \ No newline at end of file diff --git a/crates/jacquard-api/src/sh_tangled/repo/issue/comment.rs b/crates/jacquard-api/src/sh_tangled/repo/issue/comment.rs --- a/crates/jacquard-api/src/sh_tangled/repo/issue/comment.rs +++ b/crates/jacquard-api/src/sh_tangled/repo/issue/comment.rs @@ -103,7 +103,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_tangled/repo/issue/state.rs b/crates/jacquard-api/src/sh_tangled/repo/issue/state.rs --- a/crates/jacquard-api/src/sh_tangled/repo/issue/state.rs +++ b/crates/jacquard-api/src/sh_tangled/repo/issue/state.rs @@ -102,7 +102,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_tangled/repo/pull/comment.rs b/crates/jacquard-api/src/sh_tangled/repo/pull/comment.rs --- a/crates/jacquard-api/src/sh_tangled/repo/pull/comment.rs +++ b/crates/jacquard-api/src/sh_tangled/repo/pull/comment.rs @@ -99,7 +99,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/sh_tangled/repo/pull/status.rs b/crates/jacquard-api/src/sh_tangled/repo/pull/status.rs --- a/crates/jacquard-api/src/sh_tangled/repo/pull/status.rs +++ b/crates/jacquard-api/src/sh_tangled/repo/pull/status.rs @@ -103,7 +103,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } diff --git a/crates/jacquard-api/src/tools_smokesignal/blahg/content/post.rs b/crates/jacquard-api/src/tools_smokesignal/blahg/content/post.rs --- a/crates/jacquard-api/src/tools_smokesignal/blahg/content/post.rs +++ b/crates/jacquard-api/src/tools_smokesignal/blahg/content/post.rs @@ -199,7 +199,7 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { Ok(()) } } @@ -315,12 +315,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.langs { #[allow(unused_comparisons)] if value.len() > 3usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "langs", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "langs", + ), max: 3usize, actual: value.len(), }); @@ -329,8 +331,10 @@ if let Some(ref value) = self.title { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 2000usize, actual: ::len(value.as_ref()), }); @@ -344,8 +348,10 @@ ) .count(); if count > 200usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 200usize, actual: count, }); diff --git a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/post.rs b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/post.rs --- a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/post.rs +++ b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/post.rs @@ -114,13 +114,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.content; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "content", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "content", + ), max: 10000usize, actual: ::len(value.as_ref()), }); @@ -130,8 +132,10 @@ let value = &self.content; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "content", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "content", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -141,8 +145,10 @@ let value = &self.tags; #[allow(unused_comparisons)] if value.len() > 20usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "tags", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "tags", + ), max: 20usize, actual: value.len(), }); @@ -152,8 +158,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -163,8 +171,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), min: 1usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/reply.rs b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/reply.rs --- a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/reply.rs +++ b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/reply.rs @@ -103,13 +103,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.content; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "content", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "content", + ), max: 10000usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/announcement.rs b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/announcement.rs --- a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/announcement.rs +++ b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/announcement.rs @@ -102,13 +102,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.body; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10000usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "body", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "body", + ), max: 10000usize, actual: ::len(value.as_ref()), }); @@ -118,8 +120,10 @@ let value = &self.body; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "body", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "body", + ), min: 1usize, actual: ::len(value.as_ref()), }); @@ -129,8 +133,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -140,8 +146,10 @@ let value = &self.title; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "title", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "title", + ), min: 1usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/category.rs b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/category.rs --- a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/category.rs +++ b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/category.rs @@ -106,13 +106,15 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { { let value = &self.category_type; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 30usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "category_type", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "category_type", + ), max: 30usize, actual: ::len(value.as_ref()), }); @@ -121,8 +123,10 @@ if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 300usize, actual: ::len(value.as_ref()), }); @@ -132,8 +136,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -143,8 +149,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), min: 1usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/group.rs b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/group.rs --- a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/group.rs +++ b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/group.rs @@ -101,12 +101,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 300usize, actual: ::len(value.as_ref()), }); @@ -116,8 +118,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 100usize, actual: ::len(value.as_ref()), }); @@ -127,8 +131,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 1usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), min: 1usize, actual: ::len(value.as_ref()), }); diff --git a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/identity.rs b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/identity.rs --- a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/identity.rs +++ b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/forum/identity.rs @@ -105,12 +105,14 @@ } fn validate( &self, - ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> { + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { if let Some(ref value) = self.accent { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 7usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "accent", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "accent", + ), max: 7usize, actual: ::len(value.as_ref()), }); @@ -119,8 +121,10 @@ if let Some(ref value) = self.accent { #[allow(unused_comparisons)] if ::len(value.as_ref()) < 7usize { - return Err(::jacquard_lexicon::schema::ValidationError::MinLength { - field: "accent", + return Err(::jacquard_lexicon::validation::ConstraintError::MinLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "accent", + ), min: 7usize, actual: ::len(value.as_ref()), }); @@ -129,8 +133,10 @@ if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 300usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "description", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "description", + ), max: 300usize, actual: ::len(value.as_ref()), }); @@ -140,8 +146,10 @@ let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 100usize { - return Err(::jacquard_lexicon::schema::ValidationError::MaxLength { - field: "name", + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { + path: ::jacquard_lexicon::validation::ValidationPath::from_field( + "name", + ), max: 100usize, actual: ::len(value.as_ref()), }); -- tangled.sh