lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

dto.rs (5083B)

      1 #![allow(dead_code, unused_imports)]
      2 
      3 use crate::envelope::EventEnvelope;
      4 
      5 #[derive(dto_bindgen::Dto)]
      6 #[dto(export)]
      7 pub struct Nip01EventWireDto {
      8     pub id: String,
      9     pub pubkey: String,
     10     #[dto(int = "json_number")]
     11     pub created_at: u64,
     12     pub kind: u32,
     13     pub tags: Vec<Vec<String>>,
     14     pub content: String,
     15     pub sig: String,
     16     pub extra: Nip01EventExtraDto,
     17 }
     18 
     19 #[derive(dto_bindgen::Dto)]
     20 #[dto(export)]
     21 #[dto(as = "string_enum")]
     22 pub enum SignedEventVerificationStateDto {
     23     #[dto(rename = "id_verified")]
     24     IdVerified,
     25 }
     26 
     27 #[derive(dto_bindgen::Dto)]
     28 #[dto(export)]
     29 #[dto(as = "string_enum")]
     30 pub enum VerifiedSignedEventVerificationStateDto {
     31     #[dto(rename = "signature_verified")]
     32     SignatureVerified,
     33 }
     34 
     35 #[derive(dto_bindgen::Dto)]
     36 #[dto(export)]
     37 pub struct SignedEventDto {
     38     pub state: SignedEventVerificationStateDto,
     39     pub envelope: EventEnvelope,
     40     pub wire: Nip01EventWireDto,
     41     pub raw_json: String,
     42 }
     43 
     44 #[derive(dto_bindgen::Dto)]
     45 #[dto(export)]
     46 pub struct VerifiedSignedEventDto {
     47     pub state: VerifiedSignedEventVerificationStateDto,
     48     pub signed_event: SignedEventDto,
     49 }
     50 
     51 pub struct Nip01EventExtraDto;
     52 
     53 impl dto_bindgen::Dto for Nip01EventExtraDto {
     54     fn describe(_ctx: &mut dto_bindgen::__private::DescribeCtx) -> dto_bindgen::__private::TypeRef {
     55         dto_bindgen::__private::TypeRef::Override(dto_bindgen::__private::TargetOverride::new(
     56             dto_bindgen::__private::BackendId::TypeScript,
     57             "{ [key: string]: unknown }",
     58         ))
     59     }
     60 }
     61 
     62 #[path = "generated/dto_roots.rs"]
     63 mod generated_roots;
     64 
     65 pub use generated_roots::dto_bindgen_roots as dto_roots;
     66 
     67 #[cfg(test)]
     68 #[cfg_attr(coverage_nightly, coverage(off))]
     69 mod tests {
     70     use std::collections::BTreeSet;
     71 
     72     use dto_bindgen::export::{Registry, build_registry};
     73 
     74     use super::dto_roots;
     75 
     76     #[test]
     77     fn event_descriptor_roots_build_registry() {
     78         let registry = build_registry(dto_roots());
     79 
     80         assert!(!registry.has_errors());
     81         assert_eq!(registry.roots.len(), dto_roots().len());
     82         let export_names = registry_export_names(&registry);
     83 
     84         assert!(export_names.contains("EventEnvelope"));
     85         assert!(export_names.contains("Nip01EventWireDto"));
     86         assert!(export_names.contains("SignedEventDto"));
     87         assert!(export_names.contains("VerifiedSignedEventDto"));
     88         assert!(export_names.contains("OperationalListingImageSize"));
     89     }
     90 
     91     #[test]
     92     fn option_fields_are_optional_nullable() {
     93         let registry = build_registry(dto_roots());
     94 
     95         let summary = registry
     96             .struct_field_presence("OperationalListingProduct", "summary")
     97             .expect("summary field exists");
     98         assert!(!summary.required_on_deserialize);
     99         assert!(summary.nullable);
    100 
    101         let d_tag = registry
    102             .struct_field_presence("EventRef", "d_tag")
    103             .expect("d_tag field exists");
    104         assert!(!d_tag.required_on_deserialize);
    105         assert!(d_tag.nullable);
    106     }
    107 
    108     #[test]
    109     fn order_descriptor_roots_are_source_owned() {
    110         let registry = build_registry(dto_roots());
    111         let export_names = registry_export_names(&registry);
    112         let rust_names = registry_rust_names(&registry);
    113 
    114         for obsolete_export in [
    115             "OrderEnvelope",
    116             "RadrootsCommercialEnvelope",
    117             "RadrootsCommercialMessagePayload",
    118             "RadrootsCommercialMessageType",
    119             "RadrootsCommercialTransportLane",
    120             "RadrootsOrderStatus",
    121             "RadrootsOrderQuestion",
    122             "RadrootsOrderAnswer",
    123             "RadrootsOrderDiscountRequest",
    124             "RadrootsOrderDiscountOffer",
    125             "RadrootsOrderDiscountDecision",
    126             "RadrootsListingCancel",
    127             "RadrootsOperationalListingCancel",
    128             "RadrootsOrderChange",
    129             "RadrootsOrderResponse",
    130             "RadrootsOrderRevision",
    131             "RadrootsOrderRevisionResponse",
    132             "RadrootsOrderRevisionProposal",
    133             "RadrootsOrderRevisionDecision",
    134             "RadrootsOrderRevisionOutcome",
    135             "RadrootsTradeValidationListingRequest",
    136             "RadrootsTradeValidationListingResult",
    137         ] {
    138             assert!(
    139                 !export_names.contains(obsolete_export),
    140                 "{obsolete_export} should not remain as a binding-only descriptor root"
    141             );
    142         }
    143 
    144         for source_root in [
    145             "CommercialDomain",
    146             "OrderEventType",
    147             "OrderRequest",
    148             "OrderDecision",
    149             "OrderDecisionOutcome",
    150             "OrderCancellation",
    151             "OperationalListingParseError",
    152         ] {
    153             assert!(
    154                 rust_names.contains(source_root),
    155                 "{source_root} should be registered from source"
    156             );
    157         }
    158     }
    159 
    160     fn registry_export_names(registry: &Registry) -> BTreeSet<&str> {
    161         registry.type_export_names().collect()
    162     }
    163 
    164     fn registry_rust_names(registry: &Registry) -> BTreeSet<&str> {
    165         registry.type_rust_names().collect()
    166     }
    167 }